.py
```

## FAQ & Notes

Frequently anticipated questions and tips.

### This is not working on OS X

Unfortunately OS X has a bug that does not allow you to use the Databroker default port 55555. To change when starting the server:

```
docker run -it --rm --net=host ghcr.io/eclipse-kuksa/kuksa-databroker:main  --port 55556 --insecure
```

Using the databroker-cli

```
docker run -it --rm --net=host -e KUKSA_DATABROKER_PORT=55556 ghcr.io/eclipse-kuksa/kuksa-databroker-cli:main
```

Using kuksa-client CLI

```
docker run -it --rm --net=host ghcr.io/eclipse-kuksa/kuksa-python-sdk/kuksa-client:main grpc://127.0.0.1:55556
```

### Docker desktop: Host networking not supported

The examples above all used docker's `--net=host` option. That is quite convenient for development, as basically your containers "share" your hosts networking and there is no need for any port publishing.

However when using Docker Desktop on Mac OS or Windows, [host networking is not supported](https://docs.docker.com/network/host/).

One alternative is using a Docker distribution, that does support it even on Mac OS or Windows. [Rancher Desktop](https://rancherdesktop.io) is an alternative that does.

With Docker Desktop you can still forward ports, so this should work:

```
docker run -it --rm  --publish 55556:55556 ghcr.io/eclipse-kuksa/kuksa-databroker:main  --port 55556 --insecure
```

From your host computer you can now reach databroker at `127.0.0.1:55556`. To connect from another container, you need to use your computers IP address (**not** 127.0.0.1), i.e. to use the client

```
docker run -it --rm  -e KUKSA_DATABROKER_PORT=55556 -e KUKSA_DATABROKER_ADDR=<YOUR_IP> ghcr.io/eclipse-kuksa/kuksa-databroker-cli:main
```

Recent versions of the databroker-cli also support command line arguments, so you can also write

```
docker run -it --rm   ghcr.io/eclipse-kuksa/kuksa-databroker-cli:main  --server http://<YOUR_IP>:55556
```

### feed/set: Why is my data not updated?

Some VSS points are "sensors", e.g. Vehicle.Speed. You can read/get Vehicle speed, but we are not expecting to be able to influence it via VSS.
Historically components, that gather the actual vehicle speed from some sensors/busses in a vehicle and providing a VSS representation to kuksa.val have been called `feeders`. Hence, to update the current speed in the Rust-cli, you use

```
feed Vehicle.Speed 200
```

while in the Python-cli you use

```
set Vehicle.Speed 200
```

The other thing, that VSS provides you are "actuators" `Vehicle.Body.Trunk.Rear.IsOpen`. The most important thing to remember about actuators: Every actuators is also a sensor, so everything written on top applies as well!
The second-most important thing is: For VSS actuatorss, it is expected that you might be able to influence the state of the real Vehicle by writing to them. So while being used as a sensor, you will get the current position of the Window in the example, you might also want to set the _desired_ position.

You express this in the databroker-cli as

```
set Vehicle.Body.Trunk.Rear.IsOpen true
```

In kuksa-client cli you do

```
Test Client> setValue -a  targetValue Vehicle.Body.Trunk.Rear.IsOpen True
```

In the code examples above you would do

```python
client.set_target_values({
        'Vehicle.Body.Trunk.Rear.IsOpen': Datapoint(True),
    })
```

### All I see is Python, shouldn't this be high-performance?

Our Python library makes it easy to interact with databroker. While this is often sufficient for many applications, you are not limited by it: Databroker's native interface is based on GRPC, a high-performance GRPC framework. GRPC enables you to generate bindings for _any_ language. Check the [GRPC website](https://grpc.io) and take a look at the [dat


   const gppConsent = {
        gppString: 'gpp_string',
        applicableSections: [ 1, 2 ]
      };

      const gdprConsent = {
        gdprApplies: true,
        consentString: 'ABC',
        vendorData: {
          purpose: {
            consents: {
              1: true
            }
          }
        }
      };

      const userSyncs = spec.getUserSyncs(syncOptions, undefined, gdprConsent, usPrivacy, gppConsent);

      expect(userSyncs).to.eql([{
        type: 'image',
        url: 'https://ssp-sync.criteo.com/user-sync/redirect?profile=207&gdprapplies=true&gdpr=ABC&ccpa=usp_string&gpp=gpp_string&gpp_sid=1&gpp_sid=2'
      }]);
    });
  });

  describe('getUserSyncs in iframe mode', function () {
    const syncOptionsIframeEnabled = {
      iframeEnabled: true
    };

    const expectedHash = {
      cw: true,
      lsw: true,
      origin: 'criteoPrebidAdapter',
      requestId: '123456',
      tld: 'www.abc.com',
      topUrl: 'www.abc.com',
      version: '$prebid.version$'.replace(/\./g, '_'),
    };

    let sandbox,
      randomStub,
      getConfigStub,
      getRefererInfoStub,
      cookiesAreEnabledStub,
      localStorageIsEnabledStub,
      getCookieStub,
      setCookieStub,
      getDataFromLocalStorageStub,
      setDataInLocalStorageStub,
      removeDataFromLocalStorageStub,
      triggerPixelStub;

    beforeEach(function () {
      sandbox = sinon.createSandbox();
      getConfigStub = sandbox.stub(config, 'getConfig');
      getConfigStub.withArgs('criteo.fastBidVersion').returns('none');

      randomStub = sandbox.stub(Math, 'random');
      randomStub.returns(123456);

      getRefererInfoStub = sandbox.stub(refererDetection, 'getRefererInfo');
      getRefererInfoStub.returns({
        domain: 'www.abc.com'
      });

      cookiesAreEnabledStub = sandbox.stub(storage, 'cookiesAreEnabled');
      cookiesAreEnabledStub.returns(true);
      localStorageIsEnabledStub = sandbox.stub(storage, 'localStorageIsEnabled');
      localStorageIsEnabledStub.returns(true);

      getCookieStub = sandbox.stub(storage, 'getCookie');
      setCookieStub = sandbox.stub(storage, 'setCookie');
      getDataFromLocalStorageStub = sandbox.stub(storage, 'getDataFromLocalStorage');
      setDataInLocalStorageStub = sandbox.stub(storage, 'setDataInLocalStorage');
      removeDataFromLocalStorageStub = sandbox.stub(storage, 'removeDataFromLocalStorage');

      triggerPixelStub = sandbox.stub(utils, 'triggerPixel');
    });

    afterEach(function () {
      sandbox?.restore();
    });

    it('should not trigger sync if publisher did not enable iframe based syncs', function () {
      const userSyncs = spec.getUserSyncs({
        iframeEnabled: false
      }, undefined, undefined, undefined);

      expect(userSyncs).to.eql([]);
    });

    it('should not trigger sync if purpose one is not granted', function () {
      const gdprConsent = {
        gdprApplies: true,
        consentString: 'ABC',
        vendorData: {
          purpose: {
            consents: {
              1: false
            }
          }
        }
      };
      const userSyncs = spec.getUserSyncs(syncOptionsIframeEnabled, undefined, gdprConsent, undefined);

      expect(userSyncs).to.eq


kelvin_-273_15celsius",
    fromUnit: BaseUnits.Kelvin,
    fromValue: 0.0,
    toUnit: Units.Celsius,
    toValue: -273.15,
  },
  {
    name: "354kelvin_80_85celsius",
    fromUnit: BaseUnits.Kelvin,
    fromValue: 354.0,
    toUnit: Units.Celsius,
    toValue: 80.85,
    delta: 0.00000001,
  },
  {
    name: "-56kelvin_-329_15celsius",
    fromUnit: BaseUnits.Kelvin,
    fromValue: -56.0,
    toUnit: Units.Celsius,
    toValue: -329.15,
  },
  {
    name: "0kelvin_0rankine",
    fromUnit: BaseUnits.Kelvin,
    fromValue: 0.0,
    toUnit: Units.Rankine,
    toValue: 0.0,
  },
  {
    name: "245kelvin_441rankine",
    fromUnit: BaseUnits.Kelvin,
    fromValue: 245.0,
    toUnit: Units.Rankine,
    toValue: 441.0,
  },
];

/*

  it("For_Value_56_8_kelvin_we_should_get_value_102_24_rankine", () => {
    const value: number = 56.8;
    const amountToTest = Amount.create(value, Units.Kelvin);
    const convertedAmount: number = Amount.valueAs(Units.Rankine, amountToTest);
    assert.closeTo(convertedAmount, TemperatureConversion.K2R(value), 0.00001);
  });

  it("For_Value_minus_143_4_kelvin_we_should_get_value_minus_258_12_rankine", () => {
    const value: number = -143.4;
    const amountToTest = Amount.create(value, Units.Kelvin);
    const convertedAmount: number = Amount.valueAs(Units.Rankine, amountToTest);
    assert.closeTo(convertedAmount, TemperatureConversion.K2R(value), 0.00001);
  });

  //kelvin 2 fahrenheit

  it("For_Value_0_kelvin_we_should_get_value_minus_459_67_fahrenheit", () => {
    const value: number = 0.0;
    const amountToTest = Amount.create(value, Units.Kelvin);
    const convertedAmount: number = Amount.valueAs(
      Units.Fahrenheit,
      amountToTest
    );
    assert.closeTo(convertedAmount, TemperatureConversion.K2F(value), 0.00001);
  });

  it("For_Value_459_67_kelvin_we_should_get_value_367_736_fahrenheit", () => {
    const value: number = 459.67;
    const amountToTest = Amount.create(value, Units.Kelvin);
    const convertedAmount: number = Amount.valueAs(
      Units.Fahrenheit,
      amountToTest
    );
    assert.closeTo(convertedAmount, TemperatureConversion.K2F(value), 0.00001);
  });

  it("For_Value_minus_10_kelvin_we_should_get_value_minus_477_67_fahrenheit", () => {
    const value: number = -10.0;
    const amountToTest = Amount.create(value, Units.Kelvin);
    const convertedAmount: number = Amount.valueAs(
      Units.Fahrenheit,
      amountToTest
    );
    assert.closeTo(convertedAmount, TemperatureConversion.K2F(value), 0.00001);
  });

  //celsius

  //celsius 2 kelvin

  it("For_Value_0_celsius_we_should_get_value_273_15_kelvin", () => {
    const value: number = 0.0;
    const amountToTest = Amount.create(value, Units.Celsius);
    const convertedAmount: number = Amount.valueAs(U


withpan SE_M_TAIL_WHIP, SOUND_PAN_ATTACKER
	launchtemplate gLungeGreenBubbleTemplate 0x82 0x6 0xa 0x0 0x0 0x0 0x19 0xffe0
	delay 0xF
	monbg ANIM_DEF_PARTNER
	delay 0x1
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0x46 0x0 0x6
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0x28 0x28 0x6
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0xa 0xffc4 0x6
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0xffce 0xffd8 0x6
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0xffd8 0x28 0x6
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0x32 0xffce 0x6
	launchtask AnimTask_ShakeMon 0x5 0x5 ANIM_TARGET 0x0 0x5 0xb 0x1
	delay 0x2
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0x32 0xffe2 0x6
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0x3c 0xa 0x6
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0x0 0x3c 0x6
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0x0 0xffd8 0x6
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0xffc4 0x14 0x6
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0xffc4 0xffe2 0x6
	delay 0x2
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0xffce 0x32 0x6
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0xffc4 0x14 0x6
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0xffd8 0xffd8 0x6
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0x14 0xffc4 0x6
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0x32 0xffce 0x6
	launchtemplate gTealAlertSpriteTemplate 0x4 0x3 0x23 0x28 0x6
	waitforvisualfinish
	playsewithpan SE_M_DOUBLE_SLAP, SOUND_PAN_TARGET
	launchtemplate gLungeGreenImpactTemplate 0x2 0x4 0x0 0x0 0x1 0x2
	waitforvisualfinish
	visible ANIM_ATTACKER
	clearmonbg ANIM_DEF_PARTNER
	end

Move_FIRE_LASH::
	loadspritegfx ANIM_TAG_SMALL_EMBER
	monbg ANIM_DEF_PARTNER
	splitbgprio_foes ANIM_TARGET
	launchtemplate gFireSpiralOutwardSpriteTemplate 0x3 0x4 0x0 0x0 0x38 0x0
	playsewithpan SE_M_FLAME_WHEEL, SOUND_PAN_ATTACKER
	delay 0x2
	launchtemplate gFireSpiralOutwardSpriteTemplate 0x3 0x4 0x0 0x0 0x38 0x4
	playsewithpan SE_M_FLAME_WHEEL, SOUND_PAN_ATTACKER
	delay 0x2
	launchtemplate gFireSpiralOutwardSpriteTemplate 0x3 0x4 0x0 0x0 0x38 0x8
	playsewithpan SE_M_FLAME_WHEEL, SOUND_PAN_ATTACKER
	delay 0x2
	launchtemplate gFireSpiralOutwardSpriteTemplate 0x3 0x4 0x0 0x0 0x38 0xc
	playsewithpan SE_M_FLA


 string;
  static EntityToDTO(admin: Admin): AdminDto {
    const { id, username, name } = admin;
    return {
      id,
      username,
      name,
    };
  }
}
import * as yup from 'yup';

export interface FormFieldOptions {
  disabled?: boolean;
  helperText?: string;
  keyPropName?: string;
  displayPropName?: string;
  options?: any[];
  row?: boolean;
  onChangeListener?: (_e, _field, _form) => void;
  elementType?: string;
  initialValue?: any;
  validationType?: any;
  required?: boolean;
  requiredMessage?: string;
}

export interface TextInputOptions {
  disabled?: boolean;
  helperText?: string;
  onChangeListener?: (_e, _field, _form) => void;
  initialValue?: any;
  required?: boolean;
  requiredMessage?: string;
}

export interface RadioOptions {
  disabled?: boolean;
  helperText?: string;
  keyPropName?: string;
  displayPropName?: string;
  options?: any[];
  row?: boolean;
  onChangeListener?: (_e, _field, _form) => void;
  initialValue?: any;
  required?: boolean;
  requiredMessage?: string;
}

export interface SelectOptions {
  disabled?: boolean;
  helperText?: string;
  keyPropName?: string;
  displayPropName?: string;
  options?: any[];
  onChangeListener?: (_e, _field, _form) => void;
  initialValue?: any;
  required?: boolean;
  requiredMessage?: string;
}

export class FormField {
  name: string;
  label: string;

  disabled?: boolean;
  helperText?: string;
  keyPropName?: string;
  displayPropName?: string;
  options?: any[];
  row?: boolean;
  onChangeListener?: (_e, _field, _form) => void;

  elementType?: string;
  initialValue?: any;
  required?: boolean;
  requiredMessage?: string;

  validation?: any;

  constructor(name: string, label: string, fieldOptions: FormFieldOptions) {
    this.name = name;
    this.label = label;

    const {
      disabled,
      helperText,
      keyPropName,
      displayPropName,
      options,
      row,
      onChangeListener,
      elementType,
      initialValue,
      validationType,
      required,
      requiredMessage,
    } = fieldOptions;

    this.disabled = disabled;
    this.helperText = helperText;
    this.keyPropName = keyPropName;
    this.displayPropName = displayPropName;
    this.options = options;
    this.row = row;
    this.onChangeListener = onChangeListener;
    this.elementType = elementType;
    this.initialValue = initialValue;
    this.required = required;
    this.requiredMessage = requiredMessage;

    this.generateValidation(validationType);
  }

  generateValidation = (validationType?: string) => {
    if (!this.required) {
      this.validation = null;
      return;
    }

    const message = this.requiredMessage
      ? this.requiredMessage
      : `${this.label} is a required value`;

    switch (validationType) {
      case 'object':


    case Qualifiers::OCL_None: llvm_unreachable("none but true");
    case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break;
    case Qualifiers::OCL_Strong:
      if (!Policy.SuppressStrongLifetime)
        OS << "__strong";
      break;

    case Qualifiers::OCL_Weak: OS << "__weak"; break;
    case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break;
    }
  }

  if (appendSpaceIfNonEmpty && addSpace)
    OS << ' ';
}

std::string QualType::getAsString() const {
  return getAsString(split(), LangOptions());
}

std::string QualType::getAsString(const PrintingPolicy &Policy) const {
  std::string S;
  getAsStringInternal(S, Policy);
  return S;
}

std::string QualType::getAsString(const Type *ty, Qualifiers qs,
                                  const PrintingPolicy &Policy) {
  std::string buffer;
  getAsStringInternal(ty, qs, buffer, Policy);
  return buffer;
}

void QualType::print(raw_ostream &OS, const PrintingPolicy &Policy,
                     const Twine &PlaceHolder, unsigned Indentation) const {
  print(splitAccordingToPolicy(*this, Policy), OS, Policy, PlaceHolder,
        Indentation);
}

void QualType::print(const Type *ty, Qualifiers qs,
                     raw_ostream &OS, const PrintingPolicy &policy,
                     const Twine &PlaceHolder, unsigned Indentation) {
  SmallString<128> PHBuf;
  StringRef PH = PlaceHolder.toStringRef(PHBuf);

  TypePrinter(policy, Indentation).print(ty, qs, OS, PH);
}

void QualType::getAsStringInternal(std::string &Str,
                                   const PrintingPolicy &Policy) const {
  return getAsStringInternal(splitAccordingToPolicy(*this, Policy), Str,
                             Policy);
}

void QualType::getAsStringInternal(const Type *ty, Qualifiers qs,
                                   std::string &buffer,
                                   const PrintingPolicy &policy) {
  SmallString<256> Buf;
  llvm::raw_svector_ostream StrOS(Buf);
  TypePrinter(policy).print(ty, qs, StrOS, buffer);
  std::string str = StrOS.str();
  buffer.swap(str);
}
//===- TemplateBase.cpp - Common template AST class implementation --------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements common classes used throughout C++ template
// representations.
//
//===----------------------------------------------------------------------===//

#include "clang/AST/TemplateBase.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclBase.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/Expr.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/PrettyPrinter.h"
#include "clang/AST/TemplateName.h"
#include "clang/AST/Type.h"
#include "clang/AST/TypeLoc.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/SourceLocation.h"
#include "llvm/ADT/APSInt.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/None.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/ErrorHandl


称
		/// </summary>
		//public string BundleManifestFileName = "BundleManifest.txt";

        /// <summary>
		/// 默认的沙盒目录是 persistent 目录，你可以强制指定这个目录，到本地某个版本的时候
		/// </summary>
       // public string ForceSandboxDirectory = string.Empty;
        /// <summary>
        /// 构建输出的Unity清单文件名称
        /// </summary>
       // public string UnityManifestFileName = "UnityManifest";

		/// <summary>
		/// 构建输出的说明文件
		/// </summary>
		//public string ReadmeFileName = "readme.txt";

       // public YooAssets.EPlayMode PlayMode = YooAssets.EPlayMode.EditorPlayMode;

       // public string DefaultHostServer = "";

       // public string FallbackHostServer = "";
    }
}


new A.vB(m,0))
q=i.w
q.m(0,m,!0)
q.h(0,m).toString
n.d=0
i.w.h(0,m).toString
q=a.f
if(q!==0){s=n.c
if(s!=null)s.aN()
n.c=null
l=A.B(Math.abs(q),100,1e4)
s=n.r
if(n.a===B.hq)r=0.3
else{r=n.w
r===$&&A.a()
r=r.b.ae(r.a.gq())}s.a=r
r.toString
s.b=A.B(l*0.00006,r,0.5)
r=n.x
s=n.y
s===$&&A.a()
r.a=s.b.ae(s.a.gq())
r.b=Math.min(0.025+75e-8*l*l,1)
r=n.b
r===$&&A.a()
r.e=A.dr(0,B.c.au(0.15+l*0.02))
r.ic(0)
n.at=0.5
n.a=B.RD}else{q=a.d
if(q!=null){p=a.b.gZ()
p.toString
t.x.a(p)
k=p.gu()
j=p.d7(q.d)
switch(A.be(r).a){case 0:n.toString
r=k.b
n.Pt(Math.abs(s),k.a,A.B(j.b,0,r),r)
break
case 1:n.toString
r=k.a
n.Pt(Math.abs(s),k.b,A.B(j.a,0,r),r)
break}}}}else{if(!(a instanceof A.h5&&a.d!=null))s=a instanceof A.n6&&a.d!=null
else s=!0
if(s){if(q.a===B.hr)q.lw(B.dK)
s=i.e
if(s.a===B.hr)s.lw(B.dK)}}i.r=A.o(a)
return!1},
l(){this.d.l()
this.e.l()
this.V0()},
S(a){var s=this,r=null,q=s.a,p=s.d,o=s.e,n=q.e,m=s.f
return new A.dc(s.gzG(),new A.hO(A.iq(new A.hO(q.w,r),new A.Kf(p,o,n,m),r,r,B.E),r),r,t.WA)}}
A.qD.prototype={
G(){return"_GlowState."+this.b}}
A.yH.prototype={
sdI(a){if(this.ay.i(0,a))return
this.ay=a
this.a5()},
sMd(a){if(this.ch===a)return
this.ch=a
this.a5()},
l(){var s=this,r=s.b
r===$&&A.a()
r.l()
r=s.f
r===$&&A.a()
r.l()
r=s.z
r===$&&A.a()
r.w.cE$.E(0,r)
r.Fn()
r=s.c
if(r!=null)r.aN()
s.cQ()},
Pt(a,b,c,d){var s,r,q,p,o=this,n=o.c
if(n!=null)n.aN()
o.ax=o.ax+a/200
n=o.r
s=o.w
s===$&&A.a()
r=s.b
s=s.a
n.a=r.ae(s.gq())
n.


      downloadOrigImage: downloadOrigImage,
      reDownload: reDownload,
      cancelToken: cancelToken,
      showKey: showKey,
      updateShowKeyCallback: (gid, showKey, {updateDB}) {
        dState.showKeyMap[gid] = showKey;
        if (!(dState.showKeyCompleteMap[gid]?.isCompleted ?? false)) {
          dState.showKeyCompleteMap[gid]?.complete(true);
        }
      },
    );

    if (downloadInfo.updatedImage.sourceId?.isEmpty ?? true) {
      logger.d(
          '>>>> downloadInfo.updatedImage.sourceId is empty, gid: $gid, ser: ${preImage.ser}');
    }

    // 定义下载进度回调
    void progressCallback(int count, int total) {
      dState.downloadCounts['${gid}_${preImage.ser}'] = count;
    }

    try {
      // 下载图片
      await downloadToPath(
        downloadInfo.imageUrl,
        downloadParentPath,
        downloadInfo.fileNameWithoutExtension,
        cancelToken: cancelToken,
        onDownloadCompleteWithFileName: (fileName) async {
          // 下载成功，重置重试计数
          resetReDownloadCount(gid, preImage.ser);

          if (putImageTaskCallback != null) {
            await putImageTaskCallback(
              gid,
              downloadInfo.updatedImage,
              fileName,
              TaskStatus.complete.value,
            );
          }
          onDownloadCompleteWithFileName?.call(fileName);
        },
        progressCallback: progressCallback,
      );
    } on DioException catch (e) {
      if (e.response?.statusCode == 403) {
        await handleExpiredLink(
          preImage,
          gid,
          downloadParentPath,
          downloadInfo.fileNameWithoutExtension,
          downloadOrigImage,
          cancelToken,
          progressCallback,
          onDownloadCompleteWithFileName,
          downloadInfo.updatedImage.sourceId,
          showKey,
          putImageTaskCallback: putImageTaskCallback,
        );
      } else {
        rethrow;
      }
    }
  }

  /// 获取下载URL和更新的图片信息
  Future<ImageDownloadInfo> getImageDownloadInfo(
    GalleryImage preImage,
    GalleryImageTask? imageTask,
    int gid,
    int maxSer, {
    bool downloadOrigImage = false,
    bool reDownload = false,
    CancelToken? cancelToken,
    String? showKey,
    Function? updateShowKeyCallback,
    Function? addAllImagesCallback,
    Function? putImageTaskCallback,
  }) async {
    late String imageUrl;
    late GalleryImage updatedImage;
    late String fileNameWithoutExtension;

    // 存在imageTask的 用原url下载
    final bool useOldUrl = imageTask != null &&
        imageTask.imageUrl != null &&
        (imageTask.imageUrl?.isNotEmpty ?? false);
    final String? imageUrlFromTask = imageTask?.imageUrl;

    // 使用原有url下载
    if (useOldUrl && !reDownload && imageUrlFromTask != null) {
      logger.t('使用原有url下载 ${preImage.ser} DL $imageUrlFromTask');

      imageUrl = imageUrlFromTask;
      updatedImage = preImage;
      if (imageTask.filePath != null && imageTask.filePath!.isNotEmpty) {
        fileNameWithoutExtension =
            path.basenameWithoutExtension(imageTask.filePath!);
      } else {
        fileNameWithoutExtension =
            genFileNameWithoutExtension(preImage, maxSer);
      }
    } else if (preImage.href != null) {
      logger.t('获取新的图片url');
      if (reDownload) {
        logger.d(
            '重下载 ${preImage.ser}, �


�异滚动存在很多难点：

> 差异滚动在浏览器兼容方面有很多挑战。要做出最好的滚动效果需要一些经验。这其实不是真正的视差效果，而是在页面转换时的各遮罩层的变换技巧。
>

>

> ——W+K

W+K也透露说，要正确的选择工具，以达到较快的载入和绘制速度。

> 做到更快的关键是尽可能地使用CSS，因为DOM操作会减慢渲染速度，尤其是在过时的浏览设备上。
>

>

> ——W+K

比如下面这个在鼠标悬浮时会旋转的按钮，这个效果是通过CSS 3 实现的。在不支持CSS 3 动画的浏览器中，这个图标想要表达的意思依然显而易见。 [![CSS 3 的使用][image-6]][16]

## 添加更多元素

差异滚动的另一个特点就是页面上很多的元素在滚动，而不仅仅是背景在滚动。现在我们有两类元素在相互独立地滚动着：一是页面本身在滚动，当用户拖动滚动条时触发滚动。二是背景在滚动，借助jQuery和CSS，它滚得慢一些。

也许这样就足够了，对于一个博客而言，这样的滚动效果已然很赞。但是Nike加了一些元素，他们滚动的速度和背景及页面都不同。简单起见，我们把这些元素称为贴图层(sprites)。

HTML见下：

首先们给这个div一个id以便我们引用，然后使用HTML 5的data属性来存储一些值。

## 真正的开始

这一部分可能会让你晕头转向，而且也是本文最难理解的部分。

（真是太难懂了，掠过看不懂的部分……大体意思是，如果页面的y偏移是2000px，那么贴图的y偏移就是2000/2+200=1200px，blablabla）

[![贴图层的offset][image-7]][17]

JavaScript代码见下：

// 检查section里的贴图

$('[data-type="sprite"]', $self).each(function() {

  $sprite = $(this);

  // 算出偏移量

  var yPos = -($.Window.scrollTop() / $sprite.data('speed'));

  var coords = $sprite.data('Xposition') + '


				}
	end

	if name:sub(-2):lower() == "7z" then
		return {
				name = name,
				type = "7z"
				}
	end

	return {
		name = name,
		type = "ukn"
	}
end


   return '$_illustrationsRoot/logo.png';
      case ImageKey.mediumEmoji:
        return '$_illustrationsRoot/medium_emoji.png';
      case ImageKey.userAvatar:
        return '$_illustrationsRoot/user_avatar.png';
    }
  }
}

const _iconsRoot = '$_imgsRoot/icons';
const _editorIconsRoot = '$_iconsRoot/editor';
final addCircleAsset = ImageKey.addCircle.path;
final boldAsset = ImageKey.bold.path;
final chevronLeftAsset = ImageKey.chevronLeft.path;
final chevronRightAsset = ImageKey.chevronRight.path;
final codeAsset = ImageKey.code.path;
final closeAsset = ImageKey.close.path;
final clearAsset = ImageKey.clear.path;
final dragAsset = ImageKey.drag.path;
final folderAsset = ImageKey.folder.path;
final italicAsset = ImageKey.italic.path;
final linkAsset = ImageKey.link.path;
final organizeAsset = ImageKey.organize.path;
final settingsAsset = ImageKey.settings.path;
final trashAsset = ImageKey.trash.path;
final trendingUpArrowAsset = ImageKey.trendingUpArrow.path;
final underlineAsset = ImageKey.underline.path;

const _illustrationsRoot = '$_imgsRoot/illustrations';
final easyEmojiAsset = ImageKey.easyEmoji.path;
final folderBigAsset = ImageKey.folderBig.path;
final hardEmojiAsset = ImageKey.hardEmoji.path;
final logoAsset = ImageKey.logo.path;
final mediumEmojiAsset = ImageKey.mediumEmoji.path;
final userAvatarAsset = ImageKey.userAvatar.path;

String memoDifficultyEmoji(MemoDifficulty difficulty) {
  switch (difficulty) {
    case MemoDifficulty.easy:
      return easyEmojiAsset;
    case MemoDifficulty.medium:
      return mediumEmojiAsset;
    case MemoDifficulty.hard:
      return hardEmojiAsset;
  }
}
import 'dart:ui' as ui;

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:layoutr/common_layout.dart';
import 'package:memo/application/constants/animations.dart' as anims;
import 'package:memo/application/constants/colors.dart' as colors;
import 'package:memo/application/constants/dimensions.dart' as dimens;
import 'package:memo/application/theme/memo_theme_data.dart';
import 'package:memo/application/theme/theme_controller.dart';
import 'package:memo/application/widgets/animatable_progress.dart';
import 'package:memo/application/widgets/theme/themed_text_tag.dart';

/// Represents a collection card.
///
/// See also:
///   - `buildHeroCollectionCardFromItem`, which creates this exact same card but for [Hero] transitions.
class CollectionCard extends ConsumerWidget {
  CollectionCard({
    required this.name,
    required this.tags,
    required this.padding,
    this.hasBorder = true,
    this.progressDescription,
    this.progressValue,
    this.progressSemanticLabel,
    this.onTap,
    Key? key,
  })  : assert(tags.isNotEmpty),
        super(key: key);

  /// Name for this collection.
  final String name;

  /// List of tags associated with this collection.
  final List<String> tags;

  /// If this widget should draw a border for this card.
  final bool hasBorder;

  /// Padding added between the card contents and its edges.
  final EdgeInsets padding;

  /// Auxiliar description to describe this collection's progress.
  final String? progressDescription;

  /// Raw value for this collection's generic progress value - ranging from 0 to 1.
  final double? progressValue;

  /// Accessibility description for


delProvider
 * @extends {SchemaProvider}
 */
export class InputModelProvider implements SchemaProvider {
  private oldSchemaDir: string;
  private newSchemaDir: string;
  constructor(oldSchemaDir: string, newSchemaDir: string) {
    this.oldSchemaDir = oldSchemaDir;
    this.newSchemaDir = newSchemaDir;
  }

  public getCurrentSchemaText(): string {
    return buildSchemaText(this.newSchemaDir);
  }

  public getPreviousSchemaText(): string {
    return buildSchemaText(this.oldSchemaDir);
  }

  public async updatePreviousSchema(newSchema: string) {
    if (!existsSync(this.oldSchemaDir)) {
      mkdirSync(this.oldSchemaDir);
    }

    await removeFiles(join(this.oldSchemaDir, '*.graphql'));
    writeFileSync(join(this.oldSchemaDir, 'Previous.graphql'), newSchema);
  }
}
export class timeOption{
    public _timeIn:number;
    get timeIn() :number{
        return this._timeIn;
    }
    set timeIn(value:number) {
        if(value){
            this._timeIn = value;
        }
    }

}var WHILE = (condition:()=>boolean, command:()=>void) => {
    if (!condition()) return;
    command();
    WHILE(condition, command);
};

var x = 5;

WHILE(() => x > 0, ()=> {
    console.log(x);
    x--;
});import { API } from 'aws-amplify';

let debug = require('debug')
let log = debug('[paperBalance]')

/**
   * ペーパーアカウントの資産を自分のアカウントに送金
   * @param code
   */
export function claimPaperAsset(code: string, qty: number = 0) {
  return new Promise((resolve, reject) => {

    log("claimPaperAsset", code)

    let apiName = 'IBCoin_User';
    let guest_path = '/paper';
    let myInit = { // OPTIONAL
      headers: {},
      response: false, // OPTIONAL (return the entire Axios response object instead of only response.data)
      // body: "to=" + to + "&qty=" + qty + "&assetName=" + assetName
      body: {
        code, qty
      }
    }
    API.post(apiName, guest_path, myInit)
      .then(response => {

        log('API.post', apiName, guest_path, myInit)
        log('API.post > response =', response)
        return response
      })
      .then((res: any) => {
        log('res', res)
        // this.getBalances(res.sendTo)
        // this.dispatch(onSuccessPaperAsset(res))
        resolve(res)
      })
      .catch(err => {
        log('[ERR] API.put', apiName, guest_path, myInit, err)
        log(err, err.stack);
        // this.dispatch(onSuccessPaperAsset({ sendTo: "err", qty: 0 }))
        // this.dispatch(onFailureSendAsset(err))
        reject(err)
      });
  })
}
export class ChatMessage {
    public Message: string;
    public Sent: Date;

    constructor(message: string, date: Date) {
        this.Message = message;
        this.Sent =date;
    }

}/**
 * Copyright (c) 2017-present, RobotlegsJS. All Rights Reserved.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

import { IEvent } from "./IEvent";

export interface IBubbleEventHandler {
    /**
     * Handler for event bubbling.
     * It's left to the IBubbleEventHandler to decide what to do with the event


ng', {
		styles: [
			'https://sindresorhus.com/remote-file.css',
			'local-file.css',
			`
			body {
				background-color: red;
			}
			`
		]
	});
	```
	*/
	readonly styles?: string[];

	/**
	Set custom [HTTP headers](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers).

	@default {}

	@example
	```
	import captureWebsite from 'capture-website';

	await captureWebsite.file('https://sindresorhus.com', 'screenshot.png', {
		headers: {
			'x-powered-by': 'https://github.com/sindresorhus/capture-website'
		}
	});
	```
	*/
	readonly headers?: Record<string, string>;

	/**
	Set a custom [user agent](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent).
	*/
	readonly userAgent?: string;

	/**
	Set cookies in [browser string format](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies) or [object format](https://pptr.dev/api/puppeteer.page.setcookie).

	Tip: Go to the website you want a cookie for and [copy-paste it from DevTools](https://stackoverflow.com/a/24961735/64949).

	@example
	```
	import captureWebsite from 'capture-website';

	await captureWebsite.file('https://sindresorhus.com', 'screenshot.png', {
		cookies: [
			// This format is useful for when you copy it from the browser
			'id=unicorn; Expires=Wed, 21 Oct 2018 07:28:00 GMT;',

			// This format is useful for when you have to manually create a cookie
			{
				name: 'id',
				value: 'unicorn',
				expires: Math.round(new Date('2018-10-21').getTime() / 1000)
			}
		]
	});
	```
	*/
	readonly cookies?: Array<string | Protocol.Network.CookieParam>;

	/**
	Credentials for [HTTP authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication).
	*/
	readonly authentication?: Authentication;

	/**
	The specified function is called right before the screenshot is captured, as well as before any bounding rectangle is calculated as part of `options.element`. It receives the Puppeteer [`Page` instance](https://pptr.dev/api/puppeteer.page) as the first argument and the [`browser` instance](https://pptr.dev/api/puppeteer.browser) as the second argument. This gives you a lot of power to do custom stuff. The function can be async.

	Note: Make sure to not call `page.close()` or `browser.close()`.

	@example
	```
	import captureWebsite from 'capture-website';
	import checkSomething from './check-something.js';

	await captureWebsite.file('https://sindresorhus.com', 'screenshot.png', {
		beforeScreenshot: async (page, browser) => {
			await checkSomething();
			await page.click('#activate-button');
			await page.waitForSelector('.finished');
		}
	});
	```
	*/
	readonly beforeScreenshot?: BeforeScreenshot;

	/**
	Show the browser window so you can see what it's doing, redirect page console output to the terminal, and slow down each Puppeteer operation.

	Note: This overrides `launchOptions` with `{headless: false, slowMo: 100}`.

	@default false
	*/
	readonly debug?: boolean;

	/**
	Emulate preference of dark color scheme ([`prefers-color-scheme`](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)).

	@default false
	*/
	readonly darkMode?: boolean;

	/**
	Options passed to [`puppeteer.launch()`](https://pptr.dev/api/puppeteer.puppeteernodelaunchoptions


            // 加入公共部门
            rr  = cc.getProperty("core.public.regs.unit","");
            if (! rr.isEmpty()) {
                for (Object role : Synt.toSet(rr)) {
                    ud = new HashMap(3);
                    ud.put("user_id", uuid );
                    ud.put("unit_id", role );
                    ud.put("type"   ,  00  );
                    db.getTable("unit_user").insert(ud);
                }
            }

            // 赋予公共权限
            rr  = cc.getProperty("core.public.regs.role","");
            if (! rr.isEmpty()) {
                for (Object role : Synt.toSet(rr)) {
                    ud = new HashMap(2);
                    ud.put("user_id", uuid );
                    ud.put("role"   , role );
                    db.getTable("user_role").insert(ud);
                }
            }
        }

        ud = userSign( ah , unit, uuid, uname, uhead );
        ud.put("unit", /**/ unit);
        ud.put("regs", 0 == stat);
        return ud;
    }

    /**
     * 快速输出登录的错误
     * @param k 字段
     * @param w 错误
     * @return
     */
    public static Map getWrong(String k, String w) {
        String n = w.startsWith("core.") ? w.substring( 5 ) : w ;
        String s = CoreLocale.getInstance("master").translate(w);
        Map e  = new HashMap();
        if (k != null && ! "".equals(k)) {
        Map m  = new HashMap();
            m.put(   k   , s );
            e.put( "errs", m );
            e.put( "msg" , s );
        } else {
            e.put( "msg" , s );
        }
        e.put("ok", false);
        return e;
    }

    /**
     * 获取特征加密字符串
     * @param p
     * @return
     * @throws CruxException
     */
    public static String getCrypt(String p) throws CruxException {
        try {
            MessageDigest m = MessageDigest.getInstance("MD5");
            byte[] a = m.digest(p.getBytes());
            byte[] b = new byte[a.length * 2];
            for (int i = 0, j = 0; i < a.length; i ++) {
                byte c = a[i];
                b[j++] = PAZZ[c >>> 4 & 15];
                b[j++] = PAZZ[c       & 15];
            }
            return new String(b);
        }   catch (NoSuchAlgorithmException ex) {
            throw  new CruxException(ex);
        }
    }

    //** 分组权限辅助方法 **/

    /**
     * 设置第三方登录标识
     * @param unit
     * @param code
     * @param uid
     * @throws CruxException
     */
    public static void setUserSign(String unit, String code, String uid)
    throws CruxException {
        Table  tab = DB.getInstance("master").getTable("user_sign");
        Map    row = tab.fetchCase ()
            .filter("unit = ?", unit)
            .filter("code = ?", code)
            .select("user_id" )
            .getOne();
        if (row == null || row.isEmpty()) {
            tab.insert(Synt.mapOf(
                "user_id", uid ,
                "unit"   , unit,
                "code"   , code
            ));
        } else
        if (! uid.equals(row.get("user_id"))) {
            throw new CruxException("@master:core.sign.oauth.diverse", unit, code, uid, row.get("user_id"));
        }


кације на подразумевана (неопходно је рестартовање)",
    "resetToDefaultMsg": "Ресетовање подешавања на подразумевано је завршено, рестартујте апликацију",
    "randomSelection": "Насумичан избор",
    "autoOpenPlayer": "Аутоматски отвори екран плејера",
    "autoOpenPlayerDes": "Омогућите/онемогућите аутоматско отварање плејера преко целог екрана при избору песме за пуштање",
    "album": "Албум",
    "playingfromAlbum": "ПУШТАЊЕ ИЗ АЛБУМА",
    "playingfromPlaylist": "ПУШТАЊЕ С ПЛЕЈЛИСТЕ",
    "playingfromSelection": "ПУШТАЊЕ ИЗ ИЗБОРА",
    "playingfromArtist": "ПУШТАЊЕ ОД ИЗВОЂАЧА",
    "randomRadio": "Насумичан радио",
    "reArrangeSongs": "Преуреди песме",
    "selectSongs": "Изабери песме",
    "selectAll": "Изабери све"
}
,"sv" : {
    "settings": "Inställningar",
    "library": "Bibliotek",
    "libSongs": "Låtar i Bibliotek",
    "libAlbums": "Album i Bibliotek",
    "libArtists": "Artister i Bibliotek",
    "featuredplaylists": "Utvalda Spellistor",
    "items": "föremål",
    "retry": "Försök igen!",
    "emptyPlaylist": "Tom Spellista!",
    "noBookmarks": "Inga bokmärken!",
    "startRadio": "Starta radio",
    "addToPlaylist": "Lägg till i spellista",
    "enqueueSong": "Lägg till i kön",
    "goToAlbum": "Gå till album",
    "viewArtist": "Visa Artist",
    "shareSong": "Dela låt",
    "removeFromPlaylist": "Ta bort från spellista",
    "upNext": "Nästa",
    "sleepTimer": "Sovtimer",
    "add5Minutes": "Lägg till 5 minuter",
    "cancelTimer": "Avbryt timer",
    "dynamic": "Dynamiskt",
    "systemDefault": "Systemstandard",
    "languageDes": "Byt språk",
    "quickpicks": "Snabbval",
    "discover": "Upptäck",
    "trending": "Trendar nu",
    "restoreLastPlaybackSession": "Återställ den senaste sessionen",
    "skipSilenceDes": "Tystnad hoppas över vid musikuppspelning",
    "high": "Hög",
    "low": "Låg",
    "backgroundPlay": "Uppspelning i bakgrunden",
    "exportDowloadedFiles": "Exportera nedladdade filer",
    "export": "Exportera",
    "scanning": "Söker...",
    "close": "Stäng",
    "exportMsg": "Filer har exporterats


mr r3, r29
/* 803736A4 0036F304  7F C4 F3 78 */	mr r4, r30
/* 803736A8 0036F308  7D 89 03 A6 */	mtctr r12
/* 803736AC 0036F30C  4E 80 04 21 */	bctrl
/* 803736B0 0036F310  38 00 00 00 */	li r0, 0
/* 803736B4 0036F314  90 1F 00 3C */	stw r0, 0x3c(r31)
lbl_803736B8:
/* 803736B8 0036F318  38 00 00 00 */	li r0, 0
/* 803736BC 0036F31C  98 1F 00 05 */	stb r0, 5(r31)
/* 803736C0 0036F320  83 E1 00 1C */	lwz r31, 0x1c(r1)
/* 803736C4 0036F324  83 C1 00 18 */	lwz r30, 0x18(r1)
/* 803736C8 0036F328  83 A1 00 14 */	lwz r29, 0x14(r1)
/* 803736CC 0036F32C  80 01 00 24 */	lwz r0, 0x24(r1)
/* 803736D0 0036F330  7C 08 03 A6 */	mtlr r0
/* 803736D4 0036F334  38 21 00 20 */	addi r1, r1, 0x20
/* 803736D8 0036F338  4E 80 00 20 */	blr

.global ContinueAlarmHandler__Q34nw4r3snd13RemoteSpeakerFP7OSAlarmP9OSContext
ContinueAlarmHandler__Q34nw4r3snd13RemoteSpeakerFP7OSAlarmP9OSContext:
/* 803736DC 0036F33C  94 21 FF F0 */	stwu r1, -0x10(r1)
/* 803736E0 0036F340  7C 08 02 A6 */	mflr r0
/* 803736E4 0036F344  90 01 00 14 */	stw r0, 0x14(r1)
/* 803736E8 0036F348  93 E1 00 0C */	stw r31, 0xc(r1)
/* 803736EC 0036F34C  93 C1 00 08 */	stw r30, 8(r1)
/* 803736F0 0036F350  7C 7E 1B 78 */	mr r30, r3
/* 803736F4 0036F354  4B EF B0 69 */	bl OSDisableInterrupts
/* 803736F8 0036F358  7C 7F 1B 78 */	mr r31, r3
/* 803736FC 0036F35C  7F C3 F3 78 */	mr r3, r30
/* 80373700 0036F360  4B EF 67 A9 */	bl OSGetAlarmUserData
/* 80373704 0036F364  38 80 00 01 */	li r4, 1
/* 80373708 0036F368  38 00 00 00 */	li r0, 0
/* 8037370C 0036F36C  98 83 00 06 */	stb r4, 6(r3)
/* 80373710 0036F370  98 03 00 07 */	stb r0, 7(r3)
/* 80373714 0036F374  7F E3 FB 78 */	mr r3, r31
/* 80373718 0036F378  4B EF B0 6D */	bl OSRestoreInterrupts
/* 8037371C 0036F37C  80 01 00 14 */	lwz r0, 0x14(r1)
/* 80373720 0036F380  83 E1 00 0C */	lwz r31, 0xc(r1)
/* 80373724 0036F384


57fc, U+5b9d, U+5bfa, U+5c3e, U+5f01, U+5fb4, U+5fd7, U+606f, U+62e1, U+6563, U+6674, U+6cb3, U+6d3e, U+6d74, U+6e1b, U+6e2f, U+718a, U+7247, U+79d8, U+7d14, U+7d66, U+7d71, U+7df4, U+7e41, U+80cc, U+8155, U+83d3, U+8a95, U+8ab2, U+8ad6, U+8ca1, U+9000, U+9006, U+9678, U+97d3, U+9808, U+98ef, U+9a5a, U+9b45, U+ff23, U+ff30;
}
/* [101] */
@font-face {
  font-family: 'Noto Sans JP';
  font-style: normal;
  font-weight: 700;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/notosansjp/v40/-F6pfjtqLzI2JPCgQBnw7HFQei0q1xVxjfp_dakBof6Bs-tb3ab2FNISVac.101.woff2) format('woff2');
  unicode-range: U+25bc, U+3012, U+4ef2, U+4f0a, U+516b, U+5373, U+539a, U+53b3, U+559c, U+56f0, U+5727, U+5742, U+5965, U+59ff, U+5bc6, U+5dfb, U+5e45, U+5ead, U+5fb3, U+6211, U+6253, U+639b, U+63a8, U+6545, U+6575, U+6628, U+672d, U+68a8, U+6bdb, U+6d25, U+707d, U+767e, U+7834, U+7b46, U+7bc9, U+8074, U+82e6, U+8349, U+8a2a, U+8d70, U+8da3, U+8fce, U+91cc, U+967d, U+97ff, U+9996, U+ff1c, U+ff2f, U+ff32, U+ff34;
}
/* [102] */
@font-face {
  font-family: 'Noto Sans JP';
  font-style: normal;
  font-weight: 700;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/notosansjp/v40/-F6pfjtqLzI2JPCgQBnw7HFQei0q1xVxjfp_dakBof6Bs-tb3ab2FNISVac.102.woff2) format('woff2');
  unicode-range: U+3d, U+5e, U+25cf, U+4e0e, U+4e5d, U+4e73, U+4e94, U+4f3c, U+5009, U+5145, U+51ac, U+5238, U+524a, U+53f3, U+547c, U+5802, U+5922, U+5a66, U+5c0e, U+5de6, U+5fd8, U+5feb, U+6797, U+685c, U+6b7b, U+6c5f-6c60, U+6cc9, U+6ce2, U+6d17, U+6e21, U+7167, U+7642, U+76db, U+8001, U+821e, U+8857, U+89d2, U+8b1b, U+8b70, U+8cb4, U+8cde


 <qapplication.h>
#include <qeventloop.h>
#include <qfile.h>
#include <qdir.h>
#include <qmessagebox.h>
#include <qspinbox.h>
#include <qgroupbox.h>
#include <qcolor.h>
#include <qtablewidget.h>
#include <qfileinfo.h>
#include <qtextstream.h>
#include <qpixmapcache.h>

#include <QPixmap>
#include <QDateTime>
#include <QTableWidget>
#include <QTableWidgetItem>
#include <QTreeWidgetItemIterator>
#include <QTextBlockFormat>
#include <QBrush>
#include <QTextFormat>
#include <QtDebug>
#include <QTime>

#include "fwbuilder/Resources.h"
#include "fwbuilder/FWObjectDatabase.h"
#include "fwbuilder/Library.h"
#include "fwbuilder/Firewall.h"
#include "fwbuilder/Cluster.h"
#include "fwbuilder/XMLTools.h"
#include "fwbuilder/Interface.h"
#include "fwbuilder/Management.h"
#include "fwbuilder/StateSyncClusterGroup.h"

#ifndef _WIN32
#  include <unistd.h>     // for access(2) and getdomainname
#endif

#include <errno.h>
#include <iostream>
#include <algorithm>

using namespace std;
using namespace libfwbuilder;

void instDialog::enableStopButton()
{
    currentStopButton->setText(tr("Stop"));
    currentStopButton->setEnabled(true);
}

void instDialog::disableStopButton()
{
    currentStopButton->setEnabled(false);
}

bool instDialog::checkIfNeedToCompile(Firewall *fw)
{
    return (fw->needsCompile() && !fw->getInactive());
}

bool instDialog::checkIfNeedToInstall(Firewall *fw)
{
    return (fw->needsInstall() && !fw->getInactive());
}

QTreeWidgetItem* instDialog::createTreeItem(QTreeWidgetItem* parent,
                                            Firewall *fw)
{
    QTreeWidgetItem* item;
    QStringList sl;
    sl.push_back(QString::fromUtf8(fw->getName().c_str()));

    if (parent)
        item = new QTreeWidgetItem(parent, sl);
    else
        item = new QTreeWidgetItem(sl);

    QString icn_filename = (":/Icons/" + fw->getTypeName() + "/icon").c_str();
    QPixmap pm;
    if ( ! QPixmapCache::find(icn_filename, &pm))
    {
        pm.load(icn_filename);
        QPixmapCache::insert(icn_filename, pm);
    }
    item->setIcon(0, QIcon(pm));

    item->setData(0, Qt::UserRole, QVariant(fw->getId()));

    // Mark cluster members
    // If parent!=nullptr, new tree item corresponds to the cluster member
    item->setData(1, Qt::UserRole, QVariant(parent!=nullptr));

    // it is useful to know how many members does this cluster have. If this is
    // not a cluster, store 0
    list<Firewall*> members;
    if (Cluster::isA(fw))
        Cluster::cast(fw)->getMembersList(members);
    int num_members = members.size();

    item->setData(2, Qt::UserRole, QVariant(num_members));

    // item->setCheckState(COMPILE_CHECKBOX_COLUMN, checkIfNeedToCompile(fw)?Qt::Checked:Qt::Unchecked);
    // if (!compile_only)
    //     item->setCheckState(INSTALL_CHECKBOX_COLUMN, checkIfNeedToInstall(fw)?Qt::Checked:Qt::Unchecked);

    return item;
}

void instDialog::setFlags(QTreeWidgetItem* item)
{
    int obj_id = item->data(0, Qt::UserRole).toInt();
    Firewall *fw = Firewall::cast(project->db()->findInIndex(obj_id));
    QTreeWidgetItem* parent = item->parent();

    time_t lm = f


RÉSERVÉS Mk ImmoB.

{% extends 'base.html' %}
{% load static %}

{% block title %}Fit&Play{% endblock %}

{% block content %}
<link rel="stylesheet" href="{% static 'css/wheel.css' %}">

    <button id="spin-wheel-btn">Крутить колесо!</button>

    {% for exercise in exercises %}

            {{ exercise.name }}

    {% endfor %}

{% endblock %}<!DOCTYPE html>

    <meta charset="UTF-8


-icon-cross:before {
    width: 11px;
    height: 11px;
    background-position: left -20px;
}

.theme-dark em.ddp-icon-rows.type-apply:before {
    background-position: -10px 0;
}

.theme-dark em.ddp-icon-columns.type-apply:before {
    background-position: -11px -10px;
}

.theme-dark em.ddp-icon-cross.type-apply:before {
    background-position: -12px -20px;
}

.theme-dark .ddp-wrap-shelf {
    padding: 5px 0;
    overflow: hidden;
    border-bottom: 1px solid #d8d8dd;
}

.theme-dark .ddp-ui-shelf {
    position: relative;
    height: 47px;
    padding-left: 49px;
}

.theme-dark .ddp-wrap-shelf.ddp-mapview .ddp-ui-shelf.ddp-disabled .ddp-ui-drag-slide-in {
    opacity: 0.3;
}

.theme-dark .ddp-wrap-shelf.ddp-mapview .ddp-ui-shelf.ddp-disabled .ddp-ui-drag-slide-in:before {
    position: absolute;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    z-index: 1;
    content: '';
}

.theme-dark .ddp-ui-shelf.ddp-disabled em.ddp-icon-mapview1,
.theme-dark .ddp-ui-shelf.ddp-disabled em.ddp-icon-mapview2,
.theme-dark .ddp-ui-shelf.ddp-disabled em.ddp-icon-mapview3 {
    opacity: 0.3;
}

.theme-dark .ddp-ui-shelf em.ddp-icon-columns,
.theme-dark .ddp-ui-shelf em.ddp-icon-rows,
.theme-dark .ddp-ui-shelf em.ddp-icon-cross {
    position: absolute;
    top: 0;
    left: 0;
    width: 49px;
    height: 47px;
    z-index: 5;
    background-color: #fff;
}

.theme-dark .ddp-ui-shelf em.ddp-icon-columns:before,
.theme-dark .ddp-ui-shelf em.ddp-icon-rows:before,
.theme-dark .ddp-ui-shelf em.ddp-icon-cross:before {
    position: absolute;
    top: 50%;
    left: 50%;
    margin: -5px 0 0 -5px;
}

.theme-dark .ddp-ui-shelf em.ddp-icon-network {
    position: absolute;
    top: 0;
    left: 0;
    width: 49px;
    height: 47px;
    z-index: 10;
    background-color: #fff;
}

.theme-dark .ddp-ui-shelf em.ddp-icon-network:before {
    display: inline-block;
    content: '';
    position: absolute;
    top: 50%;
    left: 50%;
    margin: -8px 0 0 -8px;
    width: 15px;
    height: 15px;
    background: url(../../../images/icon_network.png) no-repeat;
}

.theme-dark .ddp-ui-shelf em.ddp-icon-network.ddp-source:before {
    background-position: -16px top;
}

.theme-dark .ddp-ui-shelf em.ddp-icon-network.ddp-target:before {
    background-position: -16px -16px;
}

.theme-dark .ddp-ui-shelf em.ddp-icon-network.ddp-link:before {
    background-position: -16px -32px;
}

.th


करने के लिए एनवायरनमेंट वेरिएबल की पूरी सूची नीचे देखें। जब सेट नहीं किया जाता है, तो डिफ़ॉल्ट स्टोरेज का उपयोग किया जाता है (डिस्क पर JSON फ़ाइलें)। |

नेटवर्किंग सर्वर स्वचालित रूप से उपयोगकर्ताओं को कनेक्ट और डिस्कनेक्ट करना, मैसेज प्राप्त करना और भेजना, और रूम स्टेट को पर्सिस्ट करना प्रबंधित करेगा।

कस्टम नेटवर्किंग सर्वर को कहीं भी डिप्लॉय किया जा सकता है, उदाहरण के लिए Google Cloud पर। आगे के निर्देशों के लिए कृपया इस रिपॉजिटरी को देखें: [Local Needle Networking Server](https://fwd.needle.tools/needle-engine/local-networking-repository)

::: tip Different server locations for local and hosted development
यदि आप कस्टम नेटवर्किंग कोड पर काम कर रहे हैं, तो आप लोकल डेवलपमेंट और होस्टेड ऐप के लिए अलग-अलग सर्वर स्थानों का उपयोग करना चाह सकते हैं। आप `Networking` कंपोनेंट में अलग-अलग सर्वर URL सेट कर सकते हैं:

![नेटवर्किंग सर्वर कहीं और होस्ट किए गए Needle Engine नेटवर्किंग कंपोनेंट](/imgs/networking_absolute.webp)
:::

#### स्टेट स्टोरेज

नेटवर्क स्टेट डिफ़ॉल्ट रूप से सर्वर पर `/ .data` डायरेक्टरी में JSON फ़ाइलों के रूप में डिस्क पर संग्रहीत होती है। प्रत्येक रूम की अपनी फ़ाइल होती है, और स्टेट को कनेक्टिंग क्लाइंट्स को भेजा जाता है जब वे किसी रूम में शामिल होते हैं।

वैकल्पिक रूप से, नेटवर्किंग स्टेट को S3 कम्पैटिबल स्टोरेज प्रोवाइडर के साथ संग्रहीत किया जा सकता है। S3 स्टोरेज सक्षम करने के लिए निम्नलिखित एनवायरनमेंट वेरिएबल का उपयोग करें:

```bash
NEEDLE_NETWORKING_S3_ENDPOINT=
NEEDLE_NETWORKING_S3_


e = new_font_name
    out_font.fullname = new_font_name
    out_font.appendSFNTName('English (US)', 'Designer', author_name)
    out_font.copyright = f"Copyright 2025: {author_name}"
    out_font.appendSFNTName('English (US)', 'License', license_text)

    # Scale factor
    scale_factor = out_font.em / src_font.em
    print(f"\nScale factor = {scale_factor:.3f}")

    # Step 6: Alignment choice
    print("\n--- Step 6: Y-Alignment ---")
    print("1 = keep source top")
    print("2 = match destination top")
    print("3 = match destination bottom")
    choice = input("Choose (default 1): ").strip()
    align_mode = choice if choice in {"1","2","3"} else "1"
    print(f"Y-alignment mode = {align_mode}")

    replaced, skipped = 0, 0

    for cp in final_codepoints:
        try:
            if cp not in src_font or not src_font[cp].isWorthOutputting():
                print(f"U+{cp:04X} missing in source. Skipped.")
                skipped += 1
                continue

            old_top_y, old_bot_y = None, None
            if cp in out_font and out_font[cp].isWorthOutputting():
                box = out_font[cp].boundingBox()
                old_bot_y, old_top_y = box[1], box[3]

            # Clear and paste glyph
            out_font.selection.none()
            out_font.selection.select(cp)
            out_font.clear()
            src_font.selection.none()
            src_font.selection.select(cp)
            src_font.copy()
            out_font.selection.select(cp)
            out_font.paste()

            g = out_font[cp]
            g.transform(psMat.scale(scale_factor))

            # Y-alignment
            new_box = g.boundingBox()
            new_bot_y, new_top_y = new_box[1], new_box[3]
            shift_y = 0
            if align_mode == "2" and old_top_y is not None:
                shift_y = old_top_y - new_top_y
            elif align_mode == "3" and old_bot_y is not None:
                shift_y = old_bot_y - new_bot_y
            g.transform(psMat.translate(0, shift_y))

            # X-bearings (copy from source glyph, scale, and cast to int)
            g.width = int(round(src_font[cp].width * scale_factor))
            g.left_side_bearing = int(round(src_font[cp].left_side_bearing * scale_factor))
            g.right_side_bearing = int(round(src_font[cp].right_side_bearing * scale_factor))

            print(f"✓ U+{cp:04X} replaced.")
            replaced += 1

        except Exception as e:
            print(f"✗ U+{cp:04X} error: {e}")
            print(traceback.format_exc())

    # Save
    out_font.generate(output_path)
    print("\n✅ Done.")
    print(f"Replaced {replaced}, skipped {skipped}.")
    print(f"Output saved: {output_path}")

    src_font.close()
    out_font.close()

if __name__ == "__main__":
    main()


, 1) infinite;
            animation: ping 1s cubic-bezier(0, 0, 0.2, 1) infinite;
  }

  .sm\:animate-pulse {
    -webkit-animation: pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite;
            animation: pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite;
  }

  .sm\:animate-bounce {
    -webkit-animation: bounce 1s infinite;
            animation: bounce 1s infinite;
  }
}

@media (min-width: 768px) {
  .md\:container {
    width: 100%;
  }

  @media (min-width: 640px) {
    .md\:container {
      max-width: 640px;
    }
  }

  @media (min-width: 768px) {
    .md\:container {
      max-width: 768px;
    }
  }

  @media (min-width: 1024px) {
    .md\:container {
      max-width: 1024px;
    }
  }

  @media (min-width: 1280px) {
    .md\:container {
      max-width: 1280px;
    }
  }

  @media (min-width: 1536px) {
    .md\:container {
      max-width: 1536px;
    }
  }

  .md\:prose {
    color: #374151;
    max-width: 65ch;
  }

  .md\:prose [class~="lead"] {
    color: #4b5563;
    font-size: 1.25em;
    line-height: 1.6;
    margin-top: 1.2em;
    margin-bottom: 1.2em;
  }

  .md\:prose a {
    color: #111827;
    text-decoration: underline;
    font-weight: 500;
  }

  .md\:prose strong {
    color: #111827;
    font-weight: 600;
  }

  .md\:prose ol {
    counter-reset: list-counter;
    margin-top: 1.25em;
    margin-bottom: 1.25em;
  }

  .md\:prose ol > li {
    position: relative;
    counter-increment: list-counter;
    padding-left: 1.75em;
  }

  .md\:prose ol > li::before {
    content: counter(list-counter) ".";
    position: absolute;
    font-weight: 400;
    color: #6b7280;
    left: 0;
  }

  .md\:prose ul > li {
    position: relative;
    padding-left: 1.75em;
  }

  .md\:prose ul > li::before {
    content: "";
    position: absolute;
    background-color: #d1d5db;
    border-radius: 50%;
    width: 0.375em;
    height: 0.375em;
    top: calc(0.875em - 0.1875em);
    left: 0.25em;
  }

  .md\:prose hr {
    border-color: #e5e7eb;
    border-top-width: 1px;
    margin-top: 3em;
    margin-bottom: 3em;
  }

  .md\:prose blockquote {
    font-weight: 500;
    font-style: italic;
    color: #111827;
    border-left-width: 0.25rem;
    border-left-color: #e5e7eb;
    quotes: "\201C""\201D""\2018""\2019";
    margin-top: 1.6em;
    margin-bottom: 1.6em;
    padding-left: 1em;
  }

  .md\:prose blockquote p:first-of-type::before {
    con


{ GL_CLIP_PLANE0, "GL_CLIP_PLANE0" },
	{ GL_COLOR_ARRAY, "GL_COLOR_ARRAY" },
	{ GL_TEXTURE_COORD_ARRAY, "GL_TEXTURE_COORD_ARRAY" },
	{ GL_VERTEX_ARRAY, "GL_VERTEX_ARRAY" },
	{ GL_ALPHA_TEST, "GL_ALPHA_TEST" },
	{ GL_TEXTURE_GEN_S, "GL_TEXTURE_GEN_S" },
	{ GL_TEXTURE_GEN_T, "GL_TEXTURE_GEN_T" },
	{ GL_TEXTURE_GEN_R, "GL_TEXTURE_GEN_R" },
	{ GL_TEXTURE_GEN_Q, "GL_TEXTURE_GEN_Q" },
	{ GL_STENCIL_TEST, "GL_STENCIL_TEST" },
	{ GL_POLYGON_OFFSET_FILL, "GL_POLYGON_OFFSET_FILL" },

	{ GL_TRIANGLES,	"GL_TRIANGLES" },
	{ GL_TRIANGLE_STRIP, "GL_TRIANGLE_STRIP" },
	{ GL_TRIANGLE_FAN, "GL_TRIANGLE_FAN" },
	{ GL_QUADS, "GL_QUADS" },
	{ GL_QUAD_STRIP, "GL_QUAD_STRIP" },
	{ GL_POLYGON, "GL_POLYGON" },
	{ GL_POINTS, "GL_POINTS" },
	{ GL_LINES, "GL_LINES" },
	{ GL_LINE_STRIP, "GL_LINE_STRIP" },
	{ GL_LINE_LOOP, "GL_LINE_LOOP" },

	{ GL_ALWAYS, "GL_ALWAYS" },
	{ GL_NEVER, "GL_NEVER" },
	{ GL_LEQUAL, "GL_LEQUAL" },
	{ GL_LESS, "GL_LESS" },
	{ GL_EQUAL, "GL_EQUAL" },
	{ GL_GREATER, "GL_GREATER" },
	{ GL_GEQUAL, "GL_GEQUAL" },
	{ GL_NOTEQUAL, "GL_NOTEQUAL" },

	{ GL_ONE, "GL_ONE" },
	{ GL_ZERO, "GL_ZERO" },
	{ GL_SRC_ALPHA, "GL_SRC_ALPHA" },
	{ GL_ONE_MINUS_SRC_ALPHA, "GL_ONE_MINUS_SRC_ALPHA" },
	{ GL_DST_COLOR, "GL_DST_COLOR" },
	{ GL_ONE_MINUS_DST_COLOR, "GL_ONE_MINUS_DST_COLOR" },
	{ GL_DST_ALPHA, "GL_DST_ALPHA" },

	{ GL_MODELVIEW, "GL_MODELVIEW" },
	{ GL_PROJECTION, "GL_PROJECTION" },
	{ GL_TEXTURE, "GL_TEXTURE" },

/* DrawBufferMode */
DEF(GL_NONE)
DEF(GL_FRONT_LEFT)
DEF(GL_FRONT_RIGHT)
DEF(GL_BACK_LEFT)
DEF(GL_BACK_RIGHT)
DEF(GL_FRONT)
DEF(GL_BACK)
DEF(GL_LEFT)
DEF(GL_RIGHT)
DEF(GL_FRONT_AND_BACK)
DEF(GL_AUX0)
DEF(GL_AUX1)
DEF(GL_AUX2)
DEF(GL_AUX3)

/* GetTarget */
DEF(GL_CURRENT_COLOR)
DEF(GL_CURRENT_INDEX)
DEF(GL_CURRENT_NORMAL)
DEF(GL_CURRENT_TEXTURE_COORDS)
DEF(GL_CURRENT_RASTER_COLOR)
DEF(GL_CURRENT_RASTER_INDEX)
DEF(GL_CURRENT_RASTER_TEXTURE_COORDS)
DEF(GL_CURRENT_RASTER_POSITION)
DEF(GL_CURRENT_RASTER_POSITION_VALID)
DEF(GL_CURRENT_RASTER_DIST


   Diode16A_EV(12685),
    Diode16A_IV(12686),
    Diode16A_LuV(12687),
    Diode16A_ZPM(12688),
    Diode16A_UV(12689),
    Diode16A_UHV(12690),
    Diode16A_UEV(12691),
    Diode16A_UIV(12692),
    Diode16A_UMV(12693),
    Diode16A_UXV(12694),
    Diode16A_MAX(12695),
    ManualTrafo(12697),
    Windmill(12698),
    BioLab_HV(12699),
    BioLab_EV(12700),
    BioLab_IV(12701),
    BioLab_LuV(12702),
    BioLab_ZPM(12703),
    BioLab_UV(12704),
    BioLab_UHV(12705),
    BioLab_UEV(12706),
    BioLab_UIV(12707),
    BioLab_UMV(12708),
    BioLab_UXV(12709),
    BioLab_MAX(12710),
    BioVat(12712),
    RadioHatch_HV(12713),
    RadioHatch_EV(12714),
    RadioHatch_IV(12715),
    RadioHatch_LuV(12716),
    RadioHatch_ZPM(12717),
    RadioHatch_UV(12718),
    RadioHatch_UHV(12719),
    RadioHatch_UEV(12720),
    RadioHatch_UIV(12721),
    RadioHatch_UMV(12722),
    RadioHatch_UXV(12723),
    RadioHatch_MAX(12724),
    AcidGeneratorMV(12726),
    AcidGeneratorHV(12727),
    AcidGeneratorEV(12728),
    DeepEarthHeatingPump(12729),
    MegaBlastFurnace(12730),
    MegaVacuumFreezer(12731),
    MultiNqGenerator(12732),
    ThoriumHighTemperatureReactor(12733),
    ElectricImplosionCompressor(12734),
    CircuitAssemblyLine(12735),
    CompressedFluidHatch(12736),
    GiantOutputHatch(12737),
    MegaDistillationTower(12738),
    VoidMinerIII(12739),
    VoidMinerII(12740),
    VoidMinerI(12741),
    HighTemperatureGasCooledReactor(12791),
    ExtremeIndustrialGreenhouseController(12792),
    AcidGeneratorLV(12793),
    HumongousInputHatch(12799),
    CreativeScanner(12800),
    ResearchCompleter(13001),
    sofc1(13101),
    sofc2(13102),
    tfft(13104),
    lsc(13106),
    tfftHatch(13109),
    WORMHOLE_GENERATOR_CONTROLLER(13115),
    MegaChemicalReactor(13366),
    MegaOilCracker(13367),
    AdvancedAssline(13532),
    LinkedInputBus(13533),
    ToolCast_MV(13534),
    ToolCast_HV(13535),
    ToolCast_EV(13536),
    DysonSwarmController(14001),
    PlanetaryGasSiphonController(14002),
    SpaceElevatorController(14003),
    SpaceElevatorModuleAssemblerT1(14004),
    SpaceElevatorModuleAssemblerT2(14005),
    SpaceElevatorModuleAssemblerT3(14006),
    SpaceElevatorModuleMinerT1(14007),
    SpaceElevatorModuleMinerT2(14008),


level_probability2","curve_probability2","time_modulation2","level_modulation2","curve_modulation2"}

  for i=1, MAX_ENVELOPE_NODES, 1
  do
    table.insert(pset_param_exclusions_plow, "plow1_time" .. i)
    table.insert(pset_param_exclusions_plow, "plow2_time" .. i)
    table.insert(pset_param_exclusions_plow, "plow1_level" .. i)
    table.insert(pset_param_exclusions_plow, "plow2_level" .. i)
    table.insert(pset_param_exclusions_plow, "plow1_curve" .. i)
    table.insert(pset_param_exclusions_plow, "plow2_curve" .. i)
  end

  -- plow modulation exclusion group
  local pset_param_exclusions_plow_modulation = {"randomize_env_probability1","time_probability1","level_probability1","curve_probability1","time_modulation1","level_modulation1","curve_modulation1"}

  -- water exclusion group
  local pset_param_exclusions_water = {"amp","rqmin","rqmax","note_scalar","num_active_cf_scalars","cfs1","cfs2","cfs3","cfs4","plant_1_note_duration","plant_2_note_duration","num_note_frequencies","tempo_scalar_offset","nf_numerator1","nf_denominator1","nf_offset1","nf_numerator2","nf_denominator2","nf_offset2","nf_numerator3","nf_denominator3","nf_offset3","nf_numerator4","nf_denominator4","nf_offset4","nf_numerator5","nf_denominator5","nf_offset5","nf_numerator6","nf_denominator6","nf_offset6"}

  -- nav exclusion group
  local pset_param_exclusions_nav = {"page_turner", "active_plant_switcher"}

  -- i/o exclusion group
  local pset_param_exclusions_inputs_outputs = {"midi_device","plant1_cc_channel","plant2_cc_channel","plow1_cc_channel","plow2_cc_channel","water_cc_channel","output_midi","midi_out_device","midi_out_channel1","midi_out_channel2","output_crow1","output_crow2","output_crow3","output_crow4","output_jf","jf_mode","output_wdel_ks","wdel_mix","wdel_time_short","wdel_time_long","wdel_feedback","wdel_filter","wdel_clock","wdel_clock_ratio_div","wdel_clock_ratio_mul","wdel_freeze","wdel_frequency","wdel_mod_rate","wdel_mod_amount","wdel_freeze","output_wsyn","wsyn_ar_mode","wsyn_vel","wsyn_curve","wsyn_ramp","wsyn_fm_index","wsyn_fm_env","wsyn_fm_ratio_num","wsyn_fm_ratio_den","wsyn_lpg_time","wsyn_lpg_symmetry","wsyn_pluckylog","wsyn_randomize","wsyn_init","wtape_timestamp","wtape_seek","wtape_record","wtape_play","wtape_reverse","wtape_loop_active","wtape_echo_mode","wtape_loop_start","wtape_loop_end","wtape_loop_next","wtape_loop_next_trigger","wtape_loop_scale_mult","wtape_speed","wtape_freq","wtape_erase_strength","wtape_monitor_level","wtape_rec_level"}

  -- root note & scale exclusion group
  local pset_param_exclusions_root_note_sca


ollerGeneratorContext context, AttributeData attribute)
		{
			context.ReportDiagnostic(OddNumberOfArgumentsDesc, attribute.ApplicationSyntaxReference?.GetSyntax().GetLocation());
		}

		private static readonly DiagnosticDescriptor UnknownNamedArgumentDesc = new DiagnosticDescriptor("VLXASP004", "Unknown named argument", "The '{0}' attribute does not have a named argument named '{1}'", "Error", DiagnosticSeverity.Error, true);

		public static void UnknownNamedArgument(ControllerGeneratorContext context, AttributeData attribute, string attributeClassName, string argName)
		{
			context.ReportDiagnostic(UnknownNamedArgumentDesc, attribute.ApplicationSyntaxReference?.GetSyntax().GetLocation(), attributeClassName, argName);
		}

		private static readonly DiagnosticDescriptor WrongTypeDesc = new DiagnosticDescriptor("VLXASP005", "Wrong type", "The value provided for the named argument '{0}' of the attribute '{1}' is of the wrong type, expected '{2}' but found '{3}'", "Error", DiagnosticSeverity.Error, true);

		public static void WrongType(ControllerGeneratorContext context, AttributeData attribute, string attributeClassName, string argName,
									 ITypeSymbol expected, ITypeSymbol received)
		{
			context.ReportDiagnostic(WrongTypeDesc, attribute.ApplicationSyntaxReference?.GetSyntax().GetLocation(),
									 argName, attributeClassName, expected.ToDisplayString(), received.ToDisplayString());
		}
	}
}


 data-setup attr exists.
            // We only auto-setup if they've added the data-setup attr.

            if (options !== null) {
              // Create new video.js instance.
              videojs$1(mediaEl);
            }
          } // If getAttribute isn't defined, we need to wait for the DOM.

        } else {
          autoSetupTimeout(1);
          break;
        }
      } // No videos were found, so keep looping unless page is finished loading.

    } else if (!_windowLoaded) {
      autoSetupTimeout(1);
    }
  };
  /**
   * Wait until the page is loaded before running autoSetup. This will be called in
   * autoSetup if `hasLoaded` returns false.
   *
   * @param {number} wait
   *        How long to wait in ms
   *
   * @param {module:videojs} [vjs]
   *        The videojs library function
   */

  function autoSetupTimeout(wait, vjs) {
    // Protect against breakage in non-browser environments
    if (!isReal()) {
      return;
    }

    if (vjs) {
      videojs$1 = vjs;
    }

    window.setTimeout(autoSetup, wait);
  }
  /**
   * Used to set the internal tracking of window loaded state to true.
   *
   * @private
   */

  function setWindowLoaded() {
    _windowLoaded = true;
    window.removeEventListener('load', setWindowLoaded);
  }

  if (isReal()) {
    if (document.readyState === 'complete') {
      setWindowLoaded();
    } else {
      /**
       * Listen for the load event on window, and set _windowLoaded to true.
       *
       * We use a standard event listener here to avoid incrementing the GUID
       * before any players are created.
       *
       * @listens load
       */
      window.addEventListener('load', setWindowLoaded);
    }
  }

  /**
   * @file stylesheet.js
   * @module stylesheet
   */

  /**
   * Create a DOM syle element given a className for it.
   *
   * @param {string} className
   *        The className to add to the created style element.
   *
   * @return {Element}
   *         The element that was created.
   */
  var createStyleElement = function createStyleElement(className) {
    var style = document.createElement('style');
    style.className = className;
    return style;
  };
  /**
   * Add text to a DOM element.
   *
   * @param {Element} el
   *        The Element to add text content to.
   *
   * @param {string} content
   *        The text to add to the element.
   */

  var setTextContent = function setTextContent(el, content) {
    if (el.styleSheet) {
      el.styleSheet.cssText = content;
    } else {
      el.textContent = content;
    }
  };

  /**
   * @file guid.js
   * @module guid
   */
  // Default value for GUIDs. This allows us to reset the GUID counter in tests.
  //
  // The initial GUID is 3 because some users have come to rely on the first
  // default player ID ending up as `vjs_video_3`.
  //
  // See: https://github.com/videojs/video.js/pull/6216
  var _initialGuid = 3;
  /**
   * Unique ID for an element or function
   *
   * @type {Number}
   */

  var _guid = _initialGuid;
  /**
   * Get a unique auto-incrementing ID by number that has not been returned before.
   *
   * @return {number}
   *         A new unique ID.
   */

  function newGUID() {
    return _guid++;
  }

  /**
   * @file dom-data.js
   * @module dom-data
   */
  var FakeWeakMap;

  if (!window.WeakMap) {
    FakeWeakMap = /*#__PURE__*/function () {
      function FakeWeakMap() {
        this.vdata = 'vdata'


 that is used to request the permission. It is
             * returned to the
             * [androidx.core.app.ActivityCompat.OnRequestPermissionsResultCallback].
             * @param finishActivity Whether the calling Activity should be finished if the dialog is
             * cancelled.
             */
            fun newInstance(
                requestCode: Int,
                finishActivity: Boolean
            ): RationaleDialog {
                val arguments = Bundle().apply {
                    putInt(ARGUMENT_PERMISSION_REQUEST_CODE, requestCode)
                    putBoolean(ARGUMENT_FINISH_ACTIVITY, finishActivity)
                }
                return RationaleDialog().apply {
                    this.arguments = arguments
                }
            }
        }
    }
}/*
 * Copyright 2024 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.nearby.sharedemo

import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import android.net.Uri
import androidx.core.graphics.drawable.IconCompat
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import androidx.slice.Slice
import androidx.slice.SliceViewManager
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow

class MainViewModel(context: Context) : ViewModel() {
  private val _targetsFlow: MutableStateFlow<SliceState> = MutableStateFlow(SliceState.Active(setOf()))
  val targetsFlow: StateFlow<SliceState> = _targetsFlow.asStateFlow()

  private var targetMapping = mapOf<ShareTargetData, PendingIntent>()

  private val sliceManager = SliceViewManager.getInstance(context)
  private val sliceCallback: (Slice?) -> Unit = {
    targetMapping = parseSlice(it)
    if (targetMapping.isEmpty() && it != null) {
      _targetsFlow.value = SliceState.PermissionNeeded(it)
    } else {
      _targetsFlow.value = SliceState.Active(targetMapping.keys)
    }
  }

  init {
    sliceManager.registerSliceCallback(SCAN_SLICE_URI, sliceCallback)
    val slice = sliceManager.bindSlice(SCAN_SLICE_URI)
    targetMapping = parseSlice(slice)
    if (targetMapping.isEmpty() && slice != null) {
      _targetsFlow.value = SliceState.PermissionNeeded(slice)
    } else {
      _targetsFlow.value = SliceState.Active(targetMapping.keys)
    }
  }

  /**
   * This function is run just before the ViewModel is closed, allowing us to unpin the sharing
   * slice.
   */
  override fun onCleared() {
    super.onCleared()
    sliceManager.unregisterSliceCallback(SCAN_SLICE_URI, sliceCallback)
  }

  /**
   * Called when a slice's share target is tapped, as represented by [ShareTarget].
   */
  fun onShareTargetClicked(data: ShareTargetData, context: Context, sendIntent: Intent) {
    targetMapping[data]!!.send(context, 0, sendIntent)
  }

  private fun parseSlice(slice: Slice?): Map<ShareTargetData, PendingIntent> {
    android.util.Log.d("NSDemo", "slice: $slice")
    if (slice == null) {
      return mapOf()
    }
    val ret =


-5.504-30.72-13.44-43.712-23.552a12.928 12.928 0 0 0-14.592-1.024l-26.112 15.104a12.992 12.992 0 0 1-17.856-4.8l-26.752-46.336a13.12 13.12 0 0 1 4.8-17.792l20.928-12.16c5.12-2.944 7.744-8.96 6.4-14.592a148.352 148.352 0 0 1-2.944-57.152 13.248 13.248 0 0 0-6.4-13.184l-17.92-10.496a13.12 13.12 0 0 1-4.864-17.856l26.752-46.336a13.12 13.12 0 0 1 17.92-4.8l13.312 7.744a12.736 12.736 0 0 0 15.488-1.92 151.04 151.04 0 0 1 55.232-33.792 12.928 12.928 0 0 0 8.704-12.352v-13.504c0-7.232 5.888-13.056 13.056-13.056h53.568z m-23.168 122.048c-37.504 0-67.968 30.464-67.968 67.84a67.968 67.968 0 0 0 136 0c0-37.376-30.528-67.84-68.032-67.84z" fill="#126EE3" fill-opacity=".45" ></path></symbol><symbol id="icon-color-zidianguanli2" viewBox="0 0 1024 1024"><path d="M943.987501 916.166118a28.671599 28.671599 0 0 1 20.121318 7.679892 27.084421 27.084421 0 0 1 8.652679 19.250931v53.861646a27.545214 27.545214 0 0 1-8.703878 19.404528 28.313204 28.313204 0 0 1-20.070119 7.628693H166.372787C102.680879 1023.991808 51.1744 975.710884 51.1744 916.166118V107.831834C51.1744 48.338267 102.732078 0.006144 166.372787 0.006144h230.396775v511.992832c0 5.836718 2.047971 11.519839 5.836718 16.076575 9.011074 10.956647 24.575656 14.028604 37.17068 7.321497l3.071957-1.894373 184.317419-129.27819 184.31742 129.27819c5.119928 3.58395 11.110244 5.375925 17.305357 5.375925a28.159606 28.159606 0 0 0 28.671599-23.756468l0.102399-3.174355V0.006144h86.42439a28.722798 28.722798 0 0 1 20.121318 7.679892 27.084421 27.084421 0 0 1 8.652679 19.250931v754.575036a27.647613 27.647613 0 0 1-25.394845 26.623627l-3.379152 0.307196H224.074379c-31.897153 0-57.701592 24.063663-57.701592 53.759247 0 29.797983 25.804439 53.964045 57.701592 53.964045h719.913122z" fill="#126EE3" ></path><path d="M737.705589 0.006144c16.742166 0 30.258776 10.547052 30.258776 23.654069v311.086845c0 13.055817-13.516611 23.55167-30.412374 23.55167a36.351491 36.35


truct gb_timesync_svc *timesync_svc;
	int ret = 0;

	mutex_lock(&gb_timesync_svc_list_mutex);
	timesync_svc = gb_timesync_find_timesync_svc(interface->hd);
	if (!timesync_svc) {
		ret = -ENODEV;
		goto done;
	}

	ret = gb_timesync_to_timespec(timesync_svc, frame_time, ts);
done:
	mutex_unlock(&gb_timesync_svc_list_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(gb_timesync_to_timespec_by_interface);

void gb_timesync_irq(struct gb_timesync_svc *timesync_svc)
{
	unsigned long flags;
	u64 strobe_time;
	bool strobe_is_ping = true;
	struct timespec ts;

	ktime_get_ts(&ts);
	strobe_time = __gb_timesync_get_frame_time(timesync_svc);

	spin_lock_irqsave(&timesync_svc->spinlock, flags);

	if (timesync_svc->state == GB_TIMESYNC_STATE_PING) {
		if (!timesync_svc->capture_ping)
			goto done_nolog;
		timesync_svc->ap_ping_frame_time = strobe_time;
		goto done_log;
	} else if (timesync_svc->state != GB_TIMESYNC_STATE_WAIT_SVC) {
		goto done_nolog;
	}

	timesync_svc->strobe_data[timesync_svc->strobe].frame_time = strobe_time;
	timesync_svc->strobe_data[timesync_svc->strobe].ts = ts;

	if (++timesync_svc->strobe == GB_TIMESYNC_MAX_STROBES) {
		gb_timesync_set_state(timesync_svc,
				      GB_TIMESYNC_STATE_AUTHORITATIVE);
	}
	strobe_is_ping = false;
done_log:
	trace_gb_timesync_irq(strobe_is_ping, timesync_svc->strobe,
			      GB_TIMESYNC_MAX_STROBES, strobe_time);
done_nolog:
	spin_unlock_irqrestore(&timesync_svc->spinlock, flags);
}
EXPORT_SYMBOL(gb_timesync_irq);

int __init gb_timesync_init(void)
{
	int ret = 0;

	ret = gb_timesync_platform_init();
	if (ret) {
		pr_err("timesync platform init fail!\n");
		return ret;
	}

	gb_timesync_clock_rate = gb_timesync_platform_get_clock_rate();

	/* Calculate nanoseconds and femtoseconds per clock */
	gb_timesync_fs_per_clock = FSEC_PER_SEC;
	do_div(gb_timesync_fs_per_clock, gb_timesync_clock_rate);
	gb_timesync_ns_per_clock = NSEC_PER_SEC;
	do_div(gb_timesync_ns_per_clock, gb_timesync_clock_rate);

	/* Calculate the maximum number of clocks we will convert to ktime */
	gb_timesync_max_ktime_diff =
		GB_TIMESYNC_MAX_KTIME_CONVERSION * gb_timesync_clock_rate;

	pr_info("Time-Sync @ %lu Hz max ktime conversion +/- %d seconds\n",
		gb_timesync_clock_rate, GB_TIMESYNC_MAX_KTIME_CONVERSION);
	return 0;
}

void gb_timesync_exit(void)
{
	gb_timesync_platform_exit();
}


1;
            f2 = x2 < cx ? PI - f2 : f2;
            if (f1 < 0) {
                f1 = PI * 2 + f1;
            }
            if (f2 < 0) {
                f2 = PI * 2 + f2;
            }
            if (sweep_flag && f1 > f2) {
                f1 = f1 - PI * 2;
            }
            if (!sweep_flag && f2 > f1) {
                f2 = f2 - PI * 2;
            }
        }
        else {
            f1 = recursive[0];
            f2 = recursive[1];
            cx = recursive[2];
            cy = recursive[3];
        }
        df = f2 - f1;
        if (mabs(df) > _120) {
            f2old = f2;
            x2old = x2;
            y2old = y2;
            f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1);
            x2 = cx + rx * mcos(f2);
            y2 = cy + ry * msin(f2);
            res = me.arc2curve(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [f2, f2old, cx, cy]);
        }
        df = f2 - f1;
        c1 = mcos(f1);
        s1 = msin(f1);
        c2 = mcos(f2);
        s2 = msin(f2);
        t = math.tan(df / 4);
        hx = 4 / 3 * rx * t;
        hy = 4 / 3 * ry * t;
        m1 = [x1, y1];
        m2 = [x1 + hx * s1, y1 - hy * c1];
        m3 = [x2 + hx * s2, y2 - hy * c2];
        m4 = [x2, y2];
        m2[0] = 2 * m1[0] - m2[0];
        m2[1] = 2 * m1[1] - m2[1];
        if (recursive) {
            return [m2, m3, m4].concat(res);
        }
        else {
            res = [m2, m3, m4].concat(res).join().split(",");
            newres = [];
            ln = res.length;
            for (i = 0;  i < ln; i++) {
                newres[i] = i % 2 ? me.rotate(res[i - 1], res[i], rad).y : me.rotate(res[i], res[i + 1], rad).x;
            }
            return newres;
        }
    },

    // TO BE DEPRECATED
    rotateAndTranslatePath: function (sprite) {
        var alpha = sprite.rotation.degrees,
            cx = sprite.rotation.x,
            cy = sprite.rotation.y,
            dx = sprite.translation.x,
            dy = sprite.translation.y,
            path,
            i,
            p,
            xy,
            j,
            res = [];
        if (!alpha && !dx && !dy) {
            return this.pathToAbsolute(sprite.attr.path);
        }
        dx = dx || 0;
        dy = dy || 0;
        path = this.pathToAbsolute(sprite.attr.path);
        for (i = path.length; i--;) {
            p = res[i] = path[i].slice();
            if (p[0] == "A") {
                xy = this.rotatePoint(p[6], p[7], alpha, cx, cy);
                p[6] = xy.x + dx;
                p[7] = xy.y + dy;
            } else {
                j = 1;
                while (p[j + 1] != null) {
                    xy = this.rotatePoint(p[j], p[j + 1], alpha, cx, cy);
                    p[j] = xy


ters which resulted in an empty string. Please use the "::" syntax to rename this field. Example: ${parsedFieldName}::some_other_field_name.`
      );
      return acc;
    }

    if (isDate(fieldValue)) {
      return {
        ...acc,
        [processedFieldName]: new Date(
          fieldValue._seconds * 1000
        ).toISOString(),
      };
    }

    if (isGeo(fieldValue)) {
      return {
        ...acc,
        [processedFieldName]: `${fieldValue._latitude},${fieldValue._longitude}`,
      };
    }

    if (Array.isArray(fieldValue)) {
      return {
        ...acc,
        [processedFieldName]: fieldValue.reduce((acc, arrayFieldValue) => {
          // App search does not support nested arrays, so ignore nested arrays
          if (Array.isArray(arrayFieldValue)) return acc;

          if (isDate(arrayFieldValue)) {
            return [
              ...acc,
              new Date(arrayFieldValue._seconds * 1000).toISOString(),
            ];
          }

          if (isGeo(arrayFieldValue)) {
            return [
              ...acc,
              `${arrayFieldValue._latitude},${arrayFieldValue._longitude}`,
            ];
          }

          return [...acc, arrayFieldValue];
        }, []),
      };
    }

    return {
      ...acc,
      [processedFieldName]: fieldValue,
    };
  }, {});
};
/// <reference path="../typings/meteor/meteor.d.ts" />
/// <reference path="../typings/phaser/phaser.d.ts" />
/// <reference path="states/TitleScreenState.ts" />
/// <reference path="states/GamePlayState.ts" />
/// <reference path="states/GameOverState.ts" />

eval('var GameFromScratch = (this.GameFromScratch || (this.GameFromScratch = {}))'); // https://doctorllama.wordpress.com/2015/04/21/meteor-typescript-classes-and-modules/

module Game {
	export class ExtremeWalkingSimulator {
		game: Phaser.Game;

		constructor(){
			this.game = new Phaser.Game(1280, 720, Phaser.AUTO, 'content', {
				create: this.create,
				preload: this.preload
			});
		}

		preload(){

			// Graphics
			this.game.load.image("title", "/resources/graphics/TitleScreen.png");
			this.game.load.image("scene", "/resources/graphics/scene720p.png");
			this.game.load.image("gameover", "/resources/graphics/GameOver.png");

			// Spritesheets
			this.game.load.atlasXML("HERO_WALKING",
				"/resources/graphics/Hero_Walking.png",
				"/resources/graphics/Hero_Walking.xml");
			this.game.load.atlasXML("HERO_IDLE",
				"/resources/graphics/Hero_Idle.png",
				"/resources/graphics/Hero_Idle.xml");

			// Audio
			this.game.load.audio("TitleSong", [
				"/resources/sounds/TitleSong.mp3",
				"/resources/sounds/TitleSong.ogg",
				"/resources/sounds/TitleSong.wav"]);
		}

		create(){
			this.game.state.add("TitleScreenState", GameFromScratch.TitleScreenState, true);
			this.game.state.add("GamePlayState", GameFromScratch.GamePlayState, false);
			this.game.state.add("GameOverState", GameFromScratch.GameOverState, false);

			this.game.scale.scaleMode =


) => value as core.String)
                .toList(),
        topicName: json_['topicName'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() => {
    if (serviceAccountEmailAddresses != null)
      'serviceAccountEmailAddresses': serviceAccountEmailAddresses!,
    if (topicName != null) 'topicName': topicName!,
  };
}

/// JSON template for resellernotify response.
class ResellernotifyResource {
  /// Topic name of the PubSub
  core.String? topicName;

  ResellernotifyResource({this.topicName});

  ResellernotifyResource.fromJson(core.Map json_)
    : this(topicName: json_['topicName'] as core.String?);

  core.Map<core.String, core.dynamic> toJson() => {
    if (topicName != null) 'topicName': topicName!,
  };
}

/// JSON template for subscription seats.
class Seats {
  /// Identifies the resource as a subscription seat setting.
  ///
  /// Value: `subscriptions#seats`
  core.String? kind;

  /// Read-only field containing the current number of users that are assigned a
  /// license for the product defined in `skuId`.
  ///
  /// This field's value is equivalent to the numerical count of users returned
  /// by the Enterprise License Manager API method:
  /// \[`listForProductAndSku`\](https://developers.google.com/workspace/admin/licensing/v1/reference/licenseAssignments/listForProductAndSku).
  core.int? licensedNumberOfSeats;

  /// This is a required property and is exclusive to subscriptions with
  /// `FLEXIBLE` or `TRIAL` plans.
  ///
  /// This property sets the maximum number of licensed users allowed on a
  /// subscription. This quantity can be increased up to the maximum limit
  /// defined in the reseller's contract. The minimum quantity is the current
  /// number of users in the customer account. *Note: *G Suite subscriptions
  /// automatically assign a license to every user.
  core.int? maximumNumberOfSeats;

  /// This is a required property and is exclusive to subscriptions with
  /// `ANNUAL_MONTHLY_PAY` and `ANNUAL_YEARLY_PAY` plans.
  ///
  /// This property sets the maximum number of licenses assignable to users on a
  /// subscription. The reseller can add more licenses, but once set, the
  /// `numberOfSeats` cannot be reduced until renewal. The reseller is invoiced
  /// based on the `numberOfSeats` value regardless of how many of these user
  /// licenses are assigned. *Note: *Google Workspace subscriptions
  /// automatically assign a license to every user.
  core.int? numberOfSeats;

  Seats({
    this.kind,
    this.licensedNumberOfSeats,
    this.maximumNumberOfSeats,
    this.numberOfSeats,
  });

  Seats.fromJson(core.Map json_)
    : this(
        kind: json_['kind'] as core.String?,
        licensedNumberOfSeats: json_['licensedNumberOfSeats'] as core.int?,
        maximumNumberOfSeats: json_['maximumNumberOfSeats'] as core.int?,
        numberOfSeats: json_['numberOfSeats'] as core.int?,
      );

  core.Map<core.String, core.dynamic> toJson() => {
    if (kind != null) 'kind': kind!,
    if (licensedNumberOfSeats != null)
      'licensedNumberOfSeats': licensedNumberOfSeats!,
    if (maximumNumberOfSeats != null)
      'maximumNumberOfSeats': maximumNumberOfSeats!,
    if (numberOfSeats != null) 'numberOfSeats': numberOfSeats!,
  };
}

/// In this version of the API, annual commitment plan's interval is one year.
///
/// *Note: *When `billingMethod` value is `OFFLINE`, the subscription property
/// object `plan.commitmentInterval` is omitted in all API responses.
class SubscriptionPlanCommitmentInterval {
  /// An annual commitment plan


-header">impl<F: ScalarField> RangeConfig<F>

source
pub fn configure(
    meta: &mut ConstraintSystem<F>,
    range_strategy: RangeStrategy,
    num_advice: &[usize],
    num_lookup_advice: &[usize],
    num_fixed: usize,
    lookup_bits: usize,
    circuit_degree: usize
) -> Self

Generates a new RangeConfig with the specified parameters.

If num_columns is 0, then we assume you do not want to perform any lookups in that phase.

Panics if lookup_bits > 28.

meta: [ConstraintSystem] of the circuit

range_strategy: GateStrategy of the range chip

num_advice: Number of [Advice] [Column]s without lookup enabled in each phase

num_lookup_advice: Number of lookup_advice [Column]s in each phase

num_fixed: Number of fixed [Column]s in each phase

lookup_bits: Number of bits represented in the LookUp table [0,2^lookup_bits)

circuit_degree: Degree that expresses the size of circuit (i.e., 2^circuit_degree is the number of rows in the circuit)

source
pub fn <a href="#meth


(0,o.jsx)("p",{children:"The DNS records for your Netlify sites will be configured automatically."}),(0,o.jsx)("p",{children:"Are you using your domain for other services, such as email? No problem! You can add DNS records for those services at any time."}),(0,o.jsx)("p",{children:(0,o.jsx)(u.N_,{href:"https://docs.netlify.com/domains-https/netlify-dns/dns-records/",action:!0,children:"Learn more about DNS records in the docs"})})]}),(0,o.jsx)(mJ,{task:!0,dnsZone:t,onCreate:n,onDelete:a}),(0,o.jsx)("div",{className:"form-footer",children:(0,o.jsx)(u.$n,{onClick:e,children:"Continue"})})]})},hl=({dnsZone:e,domain:t,onNext:n,outset:a})=>{let i=null==e?void 0:e.getIn(["domain","registered_at"]),l=null==e?void 0:e.get("dns_servers"),s=rW(t);return l?(0,o.jsxs)("div",{className:(0,u.cn)("task-section",a),children:[i&&(0,o.jsxs)(o.Fragment,{children:[(0,o.jsx)("h2",{children:"Your domain is all set!"}),(0,o.jsx)("p",{children:"We’ve activated Netlify DNS, but propagation may take a while. Grab a coffee or deploy some sites in the meantime."})]}),!i&&(0,o.jsxs)(o.Fragment,{children:[(0,o.jsx)("h2",{children:`Update your ${s?"subdomain":"domain"}’s name servers`}),(0,o.jsx)("p",{children:"Last step! Log in to your domain provider and change your name servers to the following:"}),(0,o.jsx)("div",{className:"card card-settings !tw-py-0 tw-shadow-none",children:(0,o.jsx)("div",{className:"table-body !tw-my-0",children:(0,o.jsx)("ul",{children:l.map(e=>(0,o.jsx)("li",{children:e},e)).toArray()})})}),(0,o.jsx)(u.N_,{href:"https://docs.netlify.com/domains-https/netlify-dns/",action:!0,external:!0,children:"Learn more about DNS records in the docs"})]}),(0,o.jsx)("div",{className:"form-footer",children:(0,o.jsx)(u.$n,{onClick:n,children:"Done"})})]}):(0,o.jsx)("div",{className:"task-section",children:(0,o.jsx)(eu.A,{})})},hs=({account:e,site:t,domain:n})=>{let a=hr({account:e,site:t,domain:n});return(0,ep.fromJS)([{label:t?"Add domain":"Choose domain",path:a},{label:"Add DNS records",path:`${a}/records`},{label:"Activate Netlify DNS",path:`${a}/nameservers`}])},hr=({account:e,site:t,domain:n})=>t?(0,G.l2)(t,"dns","setup",n):(0,G.Hi)(e,"setup",n);function ho({step:e=0,dnsZone:t,account:n,site:a,domain:i,onSetupZone:l,onBuy:s,onCreateRecord:r,onDeleteRecord:d,onSearch:c,loca


 / factor;
  }

  static double? min(List<double?> data) {
    if (data.isEmpty) {
      return null;
    }

    // 使用 where 方法过滤掉空值
    Iterable<double> filteredData =
        data.where((value) => value != null).cast<double>();

    // 使用 reduce 方法获取最小值
    double? minValue =
        filteredData.reduce((min, value) => min < value ? min : value);
    return minValue;
  }

  static double? max(List<double?> data) {
    if (data.isEmpty) {
      return null;
    }

    // 使用 where 方法过滤掉空值
    Iterable<double> filteredData =
        data.where((value) => value != null).cast<double>();

    double? max =
        filteredData.reduce((value1, value2) => value1 < value2 ? value2 : value1);
    return max;
  }
}
import 'package:flutter/material.dart';
import 'package:flutter_kline/common/exts/canvas_ext.dart';
import 'package:flutter_kline/common/kline_config.dart';

import '../common/constants/line_type.dart';
import '../common/line_config.dart';
import '../common/utils/kline_collection_util.dart';
import '../common/utils/kline_num_util.dart';

/// 矩形背景图
class RectPainter extends CustomPainter {
  /// 中间的横线数量
  final int transverseLineNum;

  /// 中间线配置
  final List<LineConfig?>? transverseLineConfigList;
  final Color lineColor;
  final double lineWidth;
  final TextStyle? textStyle;
  final double? maxValue;
  final double? minValue;

  /// 是否画竖线
  final bool isDrawVerticalLine;

  /// 是否显示最低值文本
  final bool showMinValueText;

  RectPainter({
    this.transverseLineNum = 2,
    this.transverseLineConfigList,
    this.isDrawVerticalLine = false,
    this.lineColor = Colors.grey,
    this.lineWidth = 0.1,
    this.textStyle,
    this.maxValue,
    this.minValue,
    this.showMinValueText = true,
  }) : assert(
            !((maxValue != null && minValue == null) ||
                (maxValue == null && minValue != null)),
            "maxValue和minValue必须二者同时为空或不为空");

  late Canvas _canvas;
  late Paint _painter;

  /// 行高:横线的间距
  double _transverseLineHeight = 0;

  /// 横线文本值
  List<double> _transverseLineTextValues = [];

  _init({required Canvas canvas, required Size size}) {
    _canvas = canvas;
    _painter = Paint()
      ..style = PaintingStyle.stroke
      ..color = lineColor
      ..strokeWidth = lineWidth;

    _transverseLineHeight = size.height / (transverseLineNum + 1);

    _initTransverseLineTextValues();
  }

  /// 初始化：横线文本值。
  void _initTransverseLineTextValues() {
    if (this.maxValue == null) {
      return;
    }

    // 定义最大最小值，默认是最小是0，最大是1。
    double minValue = this.minValue ?? double.maxFinite;
    double maxValue = this.maxValue ?? -double.maxFinite;

    if (maxValue == -double.maxFinite && minValue == double.maxFinite) {
      maxValue = KlineConfig.defaultMaxMinValue.left;
      minValue = KlineConfig.defaultMaxMinValue.right;
    } else {
      if (maxValue == -double.maxFinite) {
        maxValue = minValue == double.maxFinite ? 1 : minValue + 1;
      }
      if (minVa


int d = da - (m + 4) * 153 / 5 + 122;
        int year = y - 4800 + (m + 2) / 12;
        int month = (m + 2) % 12 + 1;
        int day = d + 1;
        return LocalDate.of(year, month, day);
    }

    public static LocalTime toLocalTime(int time) {
        int h = time / 3600000;
        int time2 = time % 3600000;
        int m = time2 / 60000;
        int time3 = time2 % 60000;
        int s = time3 / 1000;
        int ms = time3 % 1000;
        return LocalTime.of(h, m, s, ms * 1000_000);
    }

    public static TimestampNtz parseTimestampData(String dateStr, int precision)
            throws DateTimeException {
        return TimestampNtz.fromLocalDateTime(
                fromTemporalAccessor(DEFAULT_TIMESTAMP_FORMATTER.parse(dateStr), precision));
    }

    public static TimestampLtz parseTimestampData(String dateStr, int precision, TimeZone timeZone)
            throws DateTimeException {
        return TimestampLtz.fromInstant(
                fromTemporalAccessor(DEFAULT_TIMESTAMP_FORMATTER.parse(dateStr), precision)
                        .atZone(timeZone.toZoneId())
                        .toInstant());
    }

    public static Integer parseDate(String s) {
        // allow timestamp str to date, e.g. 2017-12-12 09:30:00.0
        int ws1 = s.indexOf(" ");
        if (ws1 > 0) {
            s = s.substring(0, ws1);
        }
        int hyphen1 = s.indexOf('-');
        int y;
        int m;
        int d;
        if (hyphen1 < 0) {
            if (!isInteger(s.trim())) {
                return null;
            }
            y = Integer.parseInt(s.trim());
            m = 1;
            d = 1;
        } else {
            if (!isInteger(s.substring(0, hyphen1).trim())) {
                return null;
            }
            y = Integer.parseInt(s.substring(0, hyphen1).trim());
            final int hyphen2 = s.indexOf('-', hyphen1 + 1);
            if (hyphen2 < 0) {
                if (!isInteger(s.substring(hyphen1 + 1).trim())) {
                    return null;
                }
                m = Integer.parseInt(s.substring(hyphen1 + 1).trim());
                d = 1;
            } else {
                if (!isInteger(s.substring(hyphen1 + 1, hyphen2).trim())) {
                    return null;
                }
                m = Integer.parseInt(s.substring(hyphen1 + 1, hyphen2).trim());
                if (!isInteger(s.substring(hyphen2 + 1).trim())) {
                    return null;
                }
                d = Integer.parseInt(s.substring(hyphen2 + 1).trim());
            }
        }
        if (!isIllegalDate(y, m, d)) {
            return null;
        }
        return ymdToUnixDate(y, m, d);
    }

    public static Integer parseTime(String v) {
        final int start = 0;
        final int colon1 = v.indexOf(':', start);
        // timezone hh:mm:ss[.ssssss][[+|-]hh:mm:ss]
        // refer https://www.w3.org/TR/NOTE-datetime
        int timezoneHour;
        int timezoneMinute;
        int hour;
        int minute;
        int second;
        int milli;
        int operator = -1;
        int end = v.length();
        int timezone = v.indexOf('-', start);
        if (timezone < 0) {
            timezone = v.indexOf('+', start);
            operator = 1;
        }
        if (timezone < 0) {
            timezoneHour = 0;
            timezoneMinute = 0;
        } else {
            end = timezone;
            final int colon3 = v.indexOf(':', timezone);
            if (colon3 < 0) {
                if (!isInteger(v


mov r3, r1, lsr #8
  streq r0, [lr, #0]
  ands  r3, r3, #255
  orrne r3, r8, r3
  strne r3, [lr, #4]
  mov r3, r1, lsr #16
  streq r0, [lr, #4]
  ands  r3, r3, #255
  orrne r3, r8, r3
  strne r3, [lr, #8]
  streq r0, [lr, #8]
  movs  r3, r1, lsr #24
  orrne r3, r8, r3
  strne r3, [lr, #12]
  streq r0, [lr, #12]
  ldr r1, [r5, #4]
  add r6, r6, #2
  ands  r3, r1, #255
  orrne r3, r8, r3
  strne r3, [lr, #16]
  mov r3, r1, lsr #8
  streq r0, [lr, #16]
  ands  r3, r3, #255
  orrne r3, r8, r3
  strne r3, [lr, #20]
  mov r3, r1, lsr #16
  streq r0, [lr, #20]
  ands  r3, r3, #255
  orrne r3, r8, r3
  strne r3, [lr, #24]
  streq r0, [lr, #24]
  movs  r3, r1, lsr #24
  orrne r3, r8, r3
  strne r3, [lr, #28]
  streq r0, [lr, #28]
  cmp r4, sl
  add lr, lr, #32
  bne .L2973
.L3370:
  ldr r1, [sp, #0]
  add r7, r7, r4, asl #5
  add r3, r1, r4, asl #1
.L2972:
  ands  lr, r9, #7
  beq .L3345
  ldrh  r4, [r3, #0]
  mov r3, r4, asl #22
  mov r3, r3, lsr #22
  tst r4, #2048
  add r2, r2, r3, asl #6
  ldrne r3, [sp, #4]
  addne r2, r2, r3
  tst r4, #1024
  beq .L3029
  cmp lr, #3
  ldrls r2, [r2, #4]
  bhi .L3372
.L3046:
  mov r1, #0
.L3047:
  movs  r3, r2, lsr #24
  orr r3, r8, r3
  add r1, r1, #1
  strne r3, [r7, #0]
  streq r0, [r7, #0]
  cmp r1, lr
  mov r2, r2, asl #8
  add r7, r7, #4
  bcc .L3047
.L3345:
  add sp, sp, #16
  ldmfd sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
.L2610:
  mov r2, r9, asl #12
  and r3, sl, #7
  and r1, lr, #255
  mov r3, r3, asl #2
  and r2, r2, #49152
  ldr r4, [sp, #12]
  rsb r9, r1, #256
  add r2, r2, r3
  ldr r1, .L3398+8
  mov r3, r3, asl #1
  rsb r3, r3, #28
  cmp


yKey", () {
    var list = [1, 2, 3, 4, 5];
    var min = list.iter().minByKeyOpt<num>((int a) => a);
    expect(min, Some(1));
  });

  test("mapWhile", () {
    var list = [1, 2, 3, 4, 5];
    Iter<int> mapped = list.iter().mapWhileOpt((e) {
      if (e < 4) {
        return Some(e);
      }
      return None;
    });
    expect(mapped, [1, 2, 3]);
  });

  test("mapWindows", () {
    var list = [1, 2, 3, 4];
    var mapped =
        list.iter().mapWindows(2, (window) => window[0] + window[1]).toList();
    expect(mapped, [3, 5, 7]);

    var list2 = [1, 2, 3, 4, 5];
    var mapped2 = list2
        .iter()
        .mapWindows(3, (window) => window[0] + window[1] + window[2])
        .toList();
    expect(mapped2, [6, 9, 12]);

    Vec<Arr<int>> windows = [];
    var _ = list2.iter().mapWindows(3, (window) {
      windows.push(window);
      return 1;
    }).toList();
    expect(windows[0], isNot(windows[1]),
        reason: "Windows should not be reused");
    expect(windows.length, 3);
    expect(windows[0], [1, 2, 3]);
    expect(windows[1], [2, 3, 4]);
    expect(windows[2], [3, 4, 5]);
  });

  test("nextChunk", () {
    var list = [1, 2, 3, 4, 5];
    var chunked = list.iter().nextChunk(3);
    expect(chunked.unwrap(), [1, 2, 3]);

    var chunked2 = list.iter().nextChunk(5);
    expect(chunked2.unwrap(), [1, 2, 3, 4, 5]);

    var chunked3 = list.iter().nextChunk(6);
    expect(chunked3.unwrapErr().toList(), [1, 2, 3, 4, 5]);

    final iter = list.iter();
    var chunked4 = iter.nextChunk(2);
    expect(chunked4.unwrap(), [1, 2]);
    var chunked5 = iter.nextChunk(2);
    expect(chunked5.unwrap(), [3, 4]);
    expect(iter.nextChunk(2).unwrapErr(), [5]);
  });

  test("nth", () {
    var list = [1, 2, 3, 4, 5];
    var nth = list.iter().nthOpt(2);
    expect(nth, Some(3));

    var nth2 = list.iter().nthOpt(5);
    expect(nth2, None);
  });

  test("partition", () {
    var list = [1, 2, 3, 4, 5];
    var partitioned = list.iter().partition((e) => e % 2 == 0);
    expect(partitioned.$1, [2, 4]);
    expect(partitioned.$2, [1, 3, 5]);
  });

  test("partionInPlace", () {
    var list = [1, 2, 3, 4, 5];
    var iter = list.iter();
    var partitioned = iter.partitionInPlace((e) => e % 2 == 0);
    expect(partitioned, 2);
    final resultingList = iter.toList();
    expect(Slice(resultingList, 0, 2), containsAll([4, 2]));
    expect(Slice(resultingList, 2, 5), containsAll([3, 5, 1]));
    expect(resultingList.length, 5);
  });

  test("peekable",


local plugin_specs = {} --- @type LazySpecImport[]

--- @param plugin string
local function add(plugin)
    local spec = { import = plugin } --- @type LazySpecImport
    table.insert(plugin_specs, spec)
end

add 'gmr.plugins.autopairs'
add 'gmr.plugins.autotag'
-- add 'gmr.plugins.base46'
add 'gmr.plugins.blink-cmp'
-- add 'gmr.plugins.cloak'
add 'gmr.plugins.colorizer'
add 'gmr.plugins.colorschemes.cold'
add 'gmr.plugins.formatter'
add 'gmr.plugins.grapple'
add 'gmr.plugins.gitsigns'
add 'gmr.plugins.guess-indent'
add 'gmr.plugins.jdtls'
add 'gmr.plugins.lsp'
add 'gmr.plugins.mason'
add 'gmr.plugins.mini-indentscope'
add 'gmr.plugins.mini-surround'
add 'gmr.plugins.nvim-tree'
add 'gmr.plugins.scriptease'
add 'gmr.plugins.snacks'
add 'gmr.plugins.treesitter'
add 'gmr.plugins.treesitter-context'
add 'gmr.plugins.ts-comments'
add 'gmr.plugins.twilight'
add 'gmr.plugins.undotree'
add 'gmr.plugins.web-devicons'
add 'gmr.plugins.zen-mode'