file.endsWith('.tgz')) {
      // Special-cased to avoid binary differences being annoying
      expect({ [TARBALL]: relativeFile }).toMatchSnapshot(snapshotName);
    } else {
      expect({
        [FILE]: fs.readFileSync(file, { encoding: 'utf-8' }),
      }).toMatchSnapshot(snapshotName);
    }
    return path.basename(file);
  }

  return fs
    .readdirSync(file)
    .map((entry) => ({
      entry,
      subtree: checkTree(path.join(file, entry), { root, excludes }),
    }))
    .reduce((tree, { entry, subtree }) => {
      if (subtree != null) {
        tree[entry] = subtree;
      }
      return tree;
    }, {} as { [name: string]: TreeStructure });

  function tryStat(at: string) {
    try {
      return fs.statSync(at);
    } catch (e: any) {
      if (e.code !== os.constants.errno.ENOENT) {
        throw e;
      }
      return undefined;
    }
  }
}

async function runPacmak(
  root: string,
  targetName: TargetName,
  outdir: string,
): Promise<void> {
  return expect(
    pacmak({
      codeOnly: true,
      fingerprint: false,
      inputDirectories: [root],
      outputDirectory: outdir,
      targets: [targetName],
    }),
  ).resolves.not.toThrowError();
}

async function runMypy(pythonRoot: string): Promise<void> {
  const venvRoot = path.join(__dirname, '.venv');
  const venvBin = path.join(
    venvRoot,
    process.platform === 'win32' ? 'Scripts' : 'bin',
  );
  const venvPython = path.join(
    venvBin,
    process.platform === 'win32' ? 'python.exe' : 'python',
  );

  const env = {
    ...process.env,
    PATH: `${venvBin}:${process.env.PATH}`,
    VIRTUAL_ENV: venvRoot,
  };

  // Create a Python virtual environment
  await expect(
    // On Windows, there is usually no python3.exe (the GitHub action workers will have a python3
    // shim, but using this actually results in a WinError with Python 3.7 and 3.8 where venv will
    // fail to copy the python binary if it's not invoked as python.exe). More on this particular
    // issue can be read here: https://bugs.python.org/issue43749
    shell(process.platform === 'win32' ? 'python' : 'python3', [
      '-m',
      'venv',
      '--system-site-packages', // Allow using globally installed packages (saves time & disk space)
      JSON.stringify(venvRoot),
    ]),
  ).resolves.not.toThrowError();
  // Install mypy and the jsii runtime in there as needed
  await expect(
    shell(
      venvPython,
      [
        '-m',
        'pip',
        'install',
        '--no-input',
        '-r',
        path.resolve(__dirname, 'requirements-dev.txt'),
        // Note: this resolution is a little ugly, but it's there to avoid creating a dependency cycle
        JSON.stringify(
          path.resolve(
            require.resolve('@jsii/python-runtime/package.json'),
            '..',
          ),
        ),
      ],
      { env, retry: { maxAttempts: 5 } },
    ),
  ).resolves.not.toThrowError();
  // Now run mypy on the Python code
  return expect(
    shell(
      venvPython,
      [
        '-m',
        'mypy',
        // We may not have the package's dependencies in scope. Let's just ignore that for now.


# Copyright (c) ONNX Project Contributors

# SPDX-License-Identifier: Apache-2.0

import numpy as np

from onnx.reference.ops._op import OpRunBinary

class Xor(OpRunBinary):
    def _run(self, x, y):  # type: ignore
        return (np.logical_xor(x, y),)


ox = this.create({ tag: 'input', type: 'checkbox' });
		(checkbox as HTMLInputElement).checked = params.checked;
		this.inputs[params.id] = checkbox;
		const label = this.create({
			tag: 'label',
			text: params.label,
			id: params.id
		})
		this.target.appendChild(this.create({
			tag: 'div',
			className: 'labeled-checkbox',
			children: [
				{
					tag: 'div',
					className: 'labeled-input-grid',
					children: [label, checkbox]
				}
			]
		}));
		return this
	}
	number(params: InputParams.NumberParams) {
		const input = this.create({
			tag: "input",
			type: "number",
			id: params.id
		});
		params.value && ((input as HTMLInputElement).value = String(params.value));
		params.min && ((input as HTMLInputElement).min = String(params.min));
		params.max && ((input as HTMLInputElement).max = String(params.max));
		params.step && ((input as HTMLInputElement).step = String(params.step));

		this.inputs[params.id] = input;
		const label = this.create({
			tag: 'label',
			text: params.label||"#######"
		})
		this.target.appendChild(this.create({
			tag: 'div',
			className: 'labeled-input',
			children: [
				{
					tag: 'div',
					className: 'labeled-input-grid',
					children: [label, input]
				}
			]
		}));
		// if (params.scaleFunction) {
		// 	input.addEventListener('mousewheel', e => {
		// 		(e.target as HTMLInputElement).value = String(params.scaleFunction((e.target as HTMLInputElement).valueAsNumber))
		// 	})
		// }
		return this;
	}
	textbox(params: InputParams.TextboxParams) {
		const input = this.create({
			tag: 'input',
			type: 'text',
			id: params.id
		});
		(input as HTMLInputElement).value = params.value;
		this.inputs[params.id] = input;
		const label = this.create({
			tag: 'label',
			text: params.label
		})
		this.target.appendChild(this.create({
			tag: 'div',
			className: 'labeled-input',
			children: [
				{
					tag: 'div',
					className: 'labeled-input-grid',
					children: [label, input]
				}
			]
		}));
		return this;
	}
	vec3(params: InputParams.Vec3Params) {
		const inputx = this.create({
			tag: 'input',
			type: 'number'
		});
		const inputy = this.create({
			tag: 'input',
			type: 'number'
		});
		const inputz = this.create({
			tag: 'input',
			type: 'number'
		});
		(inputx as HTMLInputElement).value = String(params.value.x);
		(inputy as HTMLInputElement).value = String(params.value.y);
		(inputz as HTMLInputElement).value = String(params.value.z);
		this.inputs[`${params.id}.x`] = inputx;
		this.inputs[`${params.id}.y`] = inputy;
		this.inputs[`${params.id}.z`] = inputz;
		this.target.appendChild(this.create({
			tag: 'div',
			className: 'labeled-input-row-container',
			children: [
				{
					tag: 'label',
					className: 'labeled-input-row-label',
					text: params.label
				},
				{
					tag: 'div',
					className: ['labeled-input-row,section-indent-1'],
					children: [
						{
							tag: 'div',
							className: ['labeled-input,labeled-input-vec3'],


"Y"&&f.setValue("DocumentNo","<"+h.get("currentnext")+">"),l=t.getValueOfString(h.get("docbasetype")),r.setContext(u,"DocBaseType",l),l.startsWith("AP")?f.setValue("PaymentRule","S"):l.endsWith("C")&&f.setValue("PaymentRule","P"));h.close()}catch(v){return this.setCalloutActive(!1),h!=null&&h.close(),this.log.log(i.SEVERE,a,v),v.message}return r=u=f=e=o=s=null,""};u.prototype.BPartner=function(r,u,f,e,o,s){var l,a,k,h,y,p,w,b,g,nt;if(o==null||o.toString()=="")return"";try{if(l=t.getValueOfInt(o),l==null||l==0)return"";var tt="SELECT p.AD_Language,p.C_PaymentTerm_ID, COALESCE(p.M_PriceList_ID,g.M_PriceList_ID) AS M_PriceList_ID, p.PaymentRule,p.POReference, p.SO_Description,p.IsDiscountPrinted, p.SO_CreditLimit, p.SO_CreditLimit-p.SO_CreditUsed AS CreditAvailable, l.C_BPartner_Location_ID,c.AD_User_ID, COALESCE(p.PO_PriceList_ID,g.PO_PriceList_ID) AS PO_PriceList_ID, p.PaymentRulePO,p.PO_PaymentTerm_ID FROM C_BPartner p INNER JOIN C_BP_Group g ON (p.C_BP_Group_ID=g.C_BP_Group_ID) LEFT OUTER JOIN C_BPartner_Location l ON (p.C_BPartner_ID=l.C_BPartner_ID AND l.IsBillTo='Y' AND l.IsActive='Y') LEFT OUTER JOIN AD_User c ON (p.C_BPartner_ID=c.C_BPartner_ID) WHERE p.C_BPartner_ID="+l+" AND p.IsActive='Y'",v=r.isSOTrx(),c=null;try{c=n.DB.executeReader(tt,null,null);c.read()&&(a=t.getValueOfInt(c.get(v?"m_pricelist_id":"po_pricelist_id")),a>0?f.setValue("M_PriceList_ID",a):(k=r.getContextAsInt("#M_PriceList_ID"),k!=0&&f.setValue("M_PriceList_ID",k)),h=t.getValueOfString(c.get(v?"paymentrule":"paymentrulepo")),h!=null&&h.length!=0&&(r.getContext("DocBaseType").toString().endsWith("C")?h="P":v&&(h.toString().equals("S")||h.toString().equals("U"))&&(h="P"),f.setValue("PaymentRule",h)),a=t.getValueOfInt(c.get(v?"c_paymentterm_id":"po_paymentterm_id")),a>0&&f.setValue("C_PaymentTerm_ID",a),y=t.getValueOfInt(c.get("c_bpartner_location_id")),l.toString().equals(r.getContext("C_BPartner_ID"))&&(p=r.getContext("C_BPartner_Location_ID"),p&&p.toString().length>0&&(y=parseInt(p))),y==0?f.setValue("C_BPartner_Location_ID",null):f.setValue("C_BPartner_Location_ID",y),w=t.getValueOfInt(c.get("ad_user_id")),l.toString().equals(r.getContext("C_BPartner_ID"))&&(b=r.getContext("AD_User_ID"),b&&b.toString().length>0&&(w=parseInt(b))),w==0?f.setValue("AD_User_ID",null):f.setValue("AD_User_ID",w),v&&(g=t.getValueOfDouble(c.get("so_creditlim


-of-work (PoW) na pagmimina, ang pangunahing paraan ng pagse-secure ng mga cryptocurrency network ngayon.[ X230X]\n\n
Habang ang isang natatanging mining algorithm tulad ng RandomX ay napakahalaga sa layuning ito dahil nakakatulong ito upang matiyak na ang sinumang may computer ay makakapag-ambag ng patas na halaga sa seguridad ng network, hindi malulutas ng RandomX ang mga isyu na maaaring mangyari dahil sa pagmimina ng pool. Ang pool mining ay sa ngayon ang pinakakaraniwang paraan upang magmina ng mga cryptocurrencies ngayon, kabilang ang Monero, ngunit sa kabutihang palad ang paglitaw ng p2pool mining ay mabilis na nagbabago nito.
';

  @override
  String get knowledge250Sbp2pool250Sb1250Sbtext => '
Ang pool mining ay isang paraan para ibahagi ng mga minero ang gawain ng pagtatangkang lutasin ang isang block sa network at pagkatapos ay ibahagi ang mga reward nang pantay-pantay para sa lahat ng block na mahahanap ng pool. Bagama\'t nakakatulong ito nang husto upang mapantayan ang dalas ng pagbabayad sa mga minero kumpara sa pagmimina ng Monero lamang, hindi ito walang seryosong isyu sa sentralisasyon.
\n\n
Habang ang bawat minero ay nag-aambag ng trabaho sa pool, ibinibigay nila ang kontrol sa anumang trabaho na kanilang ginagawa at hinaharangan ang makikita nila sa pool mismo, na nagtitiwala na ang pool ay tapat at patas na magbabahagi ng mga reward sa lahat ng mga minero batay sa halaga ng gawain ng bawat isa. Kung magiging maayos ang lahat, kinokolekta ng pool operator ang trabaho mula sa lahat ng mga minero, isusumite ito sa network, at pantay na ibinabahagi ang mga reward.
';

  @override
  String get knowledge250Sbp2pool250Sb1250Sbtitle => 'Ano ang pool mining?';

  @override
  String get knowledge250Sbp2pool250Sb2250Sbtext => '
Sa kasamaang-palad, ganap itong umaasa sa tiwala at nagbibigay-daan sa operator ng pool na gumawa ng mga kasuklam-suklam na bagay sa gawaing ginagawa ng mga minero. Maaaring gamitin ng operator ng pool ang gawaing ginagawa para atakehin ang network, subukang doblehin ang paggastos ng mga pondo (kung sapat ang pool), o gamitin lang ang trabahong ginagawa ng mga minero para bayaran ang kanilang mga sarili at hindi kailanman gantimpalaan ng maayos ang mga minero para sa kanilang trabaho .
\n\n
Ang pinakamalaking panganib sa network ay ang isang pool (o maraming pool na nagtutulungan) na mayroong higit sa 51% ng mga network na hashrate sa ilalim ng kanilang kontrol, dahil magagamit nila ito upang manloko at gumastos ng mga pondo nang dalawang beses (isang dobleng paggastos pag-atake) o subukang baguhin ang mga panuntunan ng network.
';

  @override
  String get knowledge250Sbp2pool250Sb2250Sbtitle => 'Ano ang problema sa pagmimina ng pool?';

  @override
  String get knowledge250Sbp2pool250Sb3250S


/******************************************************************************
 * Spine Runtimes License Agreement
 * Last updated July 28, 2023. Replaces all prior versions.
 *
 * Copyright (c) 2013-2023, Esoteric Software LLC
 *
 * Integration of the Spine Runtimes into software or otherwise creating
 * derivative works of the Spine Runtimes is permitted under the terms and
 * conditions of Section 2 of the Spine Editor License Agreement:
 * http://esotericsoftware.com/spine-editor-license
 *
 * Otherwise, it is permitted to integrate the Spine Runtimes into software or
 * otherwise create derivative works of the Spine Runtimes (collectively,
 * "Products"), provided that each user of the Products must obtain their own
 * Spine Editor license and redistribution of the Products in any form must
 * include this license and copyright notice.
 *
 * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
 * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/

#ifndef SPINE_DEBUG_LOG_H
#define SPINE_DEBUG_LOG_H

#include <spine/spine.h>

namespace spine {
	SP_API void spDebug_printSkeletonData(SkeletonData *skeletonData);

	SP_API void spDebug_printAnimation(Animation *animation);

	SP_API void spDebug_printTimeline(Timeline *timeline);

	SP_API void spDebug_printBoneDatas(Vector<BoneData *> &boneDatas);

	SP_API void spDebug_printBoneData(BoneData *boneData);

	SP_API void spDebug_printSkeleton(Skeleton *skeleton);

	SP_API void spDebug_printBones(Vector<Bone *> &bones);

	SP_API void spDebug_printBone(Bone *bone);

	SP_API void spDebug_printFloats(float *values, int numFloats);

	SP_API void spDebug_printFloats(Vector<float> &values);
}

#endif


// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef GUS_NET_MESSAGES_H
#define GUS_NET_MESSAGES_H

//-----------------------------------------------------------------------------
// includes
//-----------------------------------------------------------------------------

#include "nel/misc/smart_ptr.h"
#include "nel/misc/sstring.h"

#include "gus_net.h"

//-----------------------------------------------------------------------------
// MACROS for message names
//-----------------------------------------------------------------------------

// messages from connections to hub
#define REGISTER_MODULE_TO_HUB		"REGISTER_MODULE_TO_HUB"
#define UNREGISTER_MODULE_TO_HUB	"UNREGISTER_MODULE_TO_HUB"

// messages from hubs to connections
#define REGISTER_MODULE_FROM_HUB	"REGISTER_MODULE_FROM_HUB"
#define UNREGISTER_MODULE_FROM_HUB	"UNREGISTER_MODULE_FROM_HUB"

// messages from connections to connectinos via hubs
#define BROADCAST_MSG				"BROADCAST_MSG"
#define MODULE_MSG					"MODULE_MSG"

//-----------------------------------------------------------------------------
// GUSNET namespace
//-----------------------------------------------------------------------------

namespace GUSNET
{
	//-----------------------------------------------------------------------------
	// class CMsgRegisterModule
	//-----------------------------------------------------------------------------

	class CMsgRegisterModule
	{
	public:
		// ctor
		CMsgRegisterModule();

		// serial
		void serial(NLMISC::IStream& stream);

		// setting up properties
		void setup(uint32 moduleId,const NLMISC::CSString& name,const NLMISC::CSString& parameters);

		// read accessors
		uint32 getModuleId() const;
		const NLMISC::CSString& getModuleName() const;
		const NLMISC::CSString& getParameters() const;

	private:
		uint32 _ModuleId;
		NLMISC::CSString _ModuleName;
		NLMISC::CSString _Parameters;
	};

	//-----------------------------------------------------------------------------
	// class CMsgUnregisterModule
	//-----------------------------------------------------------------------------

	class CMsgUnregisterModule
	{
	public:
		// ctor
		CMsgUnregisterModule();

		// serial
		void serial(NLMISC::IStream& stream);

		// setting up properties
		void setup(uint32 moduleId);

		// read accessors
		uint32 getModuleId() const;

	private:
		uint32 _ModuleId;
	};
}

//-----------------------------------------------------------------------------
#endif


orl	8(%si), %eax		/* LBA_lo */
	je	readonly_fakewrite	/* deny the write and end */

1:
	movb	%cs:1(%bp), %dl	/* Let DL access TO instead of FROM */
2:
	/* might map to itself, i.e., actually not mapped */

	movl	%cs:(int13_old_eax - int13_handler), %eax
	movl	%cs:(int13_old_ebp - int13_handler), %ebp  /* BP changed!! */

	call	backup_int13

	pushw	%cs:(int13_old_flags - int13_handler)
	popfw

	int	$0x13

	/* save the returned CF flag to int13_old_flags */

	jnc	1f
	orb	$1, %cs:(int13_old_flags - int13_handler)
	jmp	2f
1:
	andb	$0xFE, %cs:(int13_old_flags - int13_handler)
2:
	call	restore_int13

	/* restore BP!! */
	movw	%cs:(int13_new_bp - int13_handler), %bp
	xchgw	%ax, %cs:(int13_old_eax - int13_handler)
				/* old AX changed!! */

	/* check int13/AH=4Bh for cdrom */
	testw	$0x4000, %cs:4(%bp)	/* TO_C bit 14=(TO is cdrom) */
	jz	1f			/* not cdrom */
	testw	$0x2000, %cs:4(%bp)	/* TO_C bit 13=(FROM is cdrom) */
	jz	1f			/* not cdrom */
	cmpb	$0x4B, %ah
	jne	1f
	cmpb	$0x01, %al
	ja	1f
	/* this is int13 function 0x4B00 or 0x4B01 */
	/* restore DS:SI, just in case they were changed by buggy int13 */
	movw	%cs:(int13_old_esi - int13_handler), %si
	movw	%cs:(int13_old_ds - int13_handler), %ds
	cmpb	$0x13, (%si)		/* packet size */
	jne	1f
	testb	$0x0F, 1(%si)		/* boot type(0=no emu) */
	jne	1f
	movb	%cs:1(%bp), %dl		/* just in case DL was changed by a buggy int13 */
	cmpb	%dl, 2(%si)
	jne	1f
	movb	%cs:(%bp), %dl		/* restore DL back to the FROM drive */
	movb	%dl, 2(%si)
	jmp	3f			/* return */
1:

#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

	pushw	%cs:(int13_old_flags - int13_handler)
	popfw

	/* check if should restore(reversely map) the drive number */
	jc	1f		/* restore DL on error */

	/* alter MBR after read */

	testb	$0x80, %cs:7(%bp)	/* TO_S */
	jz	2f

	cmpb	$0x02, %ah
	je	4f		/* alter MBR */
	cmpb	$0x42, %ah
	je	4f		/* alter MBR */
2:
	cmpb	$0x08, %ah	/* int13 AH=08h, read drive parameters */
	jne	2f

	/* DL==number of drives, should not restore */
	xorw	%ax, %ax
	movw	%ax, %ds
	movb	0x475, %dl	/* DL=number of hard drives */
	testb	$0x80, %cs:(int13_old_edx - int13_handler) /* harddrive? */
	jnz	3f		/* yes, jump */
	//movw	$0x10, %bx	/* f


        : base(serial)
        {
        }

        TextDefinition ICommodity.Description { get { return LabelNumber; } }
        bool ICommodity.IsDeedable { get { return true; } }

        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);
            writer.Write((int)0); // version
        }

        public override void Deserialize(GenericReader reader)
        {
            base.Deserialize(reader);
            int version = reader.ReadInt();
        }
    }
}


/*
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2014 Blender Foundation.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): Lukas Toenne
 *
 * ***** END GPL LICENSE BLOCK *****
 */

/** \file blender/nodes/composite/nodes/node_composite_sunbeams.c
 *  \ingroup cmpnodes
 */

#include "node_composite_util.h"

static bNodeSocketTemplate inputs[] = {
	{	SOCK_RGBA, 1, N_("Image"),			1.0f, 1.0f, 1.0f, 1.0f},
	{	-1, 0, ""	}
};
static bNodeSocketTemplate outputs[] = {
	{	SOCK_RGBA, 0, N_("Image")},
	{	-1, 0, ""	}
};

static void init(bNodeTree *UNUSED(ntree), bNode *node)
{
	NodeSunBeams *data = MEM_callocN(sizeof(NodeSunBeams), "sun beams node");

	data->source[0] = 0.5f;
	data->source[1] = 0.5f;

	node->storage = data;
}

void register_node_type_cmp_sunbeams(void)
{
	static bNodeType ntype;

	cmp_node_type_base(&ntype, CMP_NODE_SUNBEAMS, "Sun Beams", NODE_CLASS_OP_FILTER, 0);
	node_type_socket_templates(&ntype, inputs, outputs);
	node_type_init(&ntype, init);
	node_type_storage(&ntype, "NodeSunBeams", node_free_standard_storage, node_copy_standard_storage);

	nodeRegisterType(&ntype);
}


л топорик. Я потерял сознание...","Очнулся уже в Менетиле, но меня волнует судьба остальных солдат. Надежда умирает последней... Может быть, Длинная Коса тоже спасся! Иди в Дун Модр и отыщи его, <раса>!"}, {"Отыщите Грима Длинную Косу возле Дун Модра."}},
[473] = {"Доклад капитану Крепкому Кулаку", {"<имя>. Орки из клана Драконьей Пасти совсем озверели. Им уже мало одного Альгаза. Капитан Крепкий Кулак просил направлять к нему всех, кто готов оказать нам содействие в войне против орков. Он сейчас в крепости, в зале Войны."}, {"Найдите капитана Крепкого Кулака и поговорите с ним."}},
[474] = {"Убить Нек'роша", {"Катапульты сожжены. Теперь найди и убей вождя Нек'роша."}, {"Убейте вождя Нек'роша.","Принесите голову Нек'роша капитану Крепкому Кулаку."}},
[475] = {"Ветер тревоги", {"Ветер тревоги веет над лесом.","Гэролас Талветрен служит Великим смотрителем за спящими друидами-воронами в обители Бен'этиль. Его долг – обеспечивать их безопасность, дабы их уговор с Изерой оставался в силе.","Но вести от Гэроласа что-то задерживаются, и я начинаю волноваться. Отправляйся на восток в Деревню Звездного Ветра – мне нужен отчет Гэроласа, дабы я был спокоен, узнав, что мои братья и сестры спят спокойно."}, {"Найдите Гароласа Талветрена в Деревне Звездного Ветра."}},
[476] = {"Порча Кривой Сосны", {"Племя Кривой Сосны поражено порчей!","Эти некогда мирные фурболги обратились против покровителей леса. Они подстерегли меня в засаде, когда я выходил из обители Бен'этиль и разграбили Деревню Звездного Ветра. Их вождь, Урсал Изверг, затмевает их разум при помощи мха Скверны.","Я слишком изранен, чтобы донести до Атридаса эти страшные вести. Теперь это придется сделать тебе, <юный/юная:c> <класс>. Остается только надеяться, что безумные фурболги Кривой Сосны еще не уничтожили Бен'этиль!"}, {"Вернитесь к Атридасу Медвежьей Шкуре в Доланаар."}},
[477] = {"Перес


ampoline)
                    .cast(),
                _ObjCBlock30_registerClosure(fn)),
            lib);
  void call(ffi.Pointer<ObjCObject> arg0) {
    return _id.ref.invoke
        .cast<
            ffi.NativeFunction<
                ffi.Void Function(ffi.Pointer<_ObjCBlock> block,
                    ffi.Pointer<ObjCObject> arg0)>>()
        .asFunction<
            void Function(ffi.Pointer<_ObjCBlock> block,
                ffi.Pointer<ObjCObject> arg0)>()(_id, arg0);
  }

  ffi.Pointer<_ObjCBlock> get pointer => _id;
}

class NSIndexPath extends NSObject {
  NSIndexPath._(ffi.Pointer<ObjCObject> id, AVFAudio lib,
      {bool retain = false, bool release = false})
      : super._(id, lib, retain: retain, release: release);

  /// Returns a [NSIndexPath] that points to the same underlying object as [other].
  static NSIndexPath castFrom<T extends _ObjCWrapper>(T other) {
    return NSIndexPath._(other._id, other._lib, retain: true, release: true);
  }

  /// Returns a [NSIndexPath] that wraps the given raw object pointer.
  static NSIndexPath castFromPointer(
      AVFAudio lib, ffi.Pointer<ObjCObject> other,
      {bool retain = false, bool release = false}) {
    return NSIndexPath._(other, lib, retain: retain, release: release);
  }

  /// Returns whether [obj] is an instance of [NSIndexPath].
  static bool isInstance(_ObjCWrapper obj) {
    return obj._lib._objc_msgSend_0(
        obj._id, obj._lib._sel_isKindOfClass_1, obj._lib._class_NSIndexPath1);
  }

  static NSIndexPath indexPathWithIndex_(AVFAudio _lib, int index) {
    final _ret = _lib._objc_msgSend_60(
        _lib._class_NSIndexPath1, _lib._sel_indexPathWithIndex_1, index);
    return NSIndexPath._(_ret, _lib, retain: true, release: true);
  }

  static NSIndexPath indexPathWithIndexes_length_(
      AVFAudio _lib, ffi.Pointer<NSUInteger> indexes, int length) {
    final _ret = _lib._objc_msgSend_768(_lib._class_NSIndexPath1,
        _lib._sel_indexPathWithIndexes_length_1, indexes, length);
    return NSIndexPath._(_ret, _lib, retain: true, release: true);
  }

  NSIndexPath initWithIndexes_length_(
      ffi.Pointer<NSUInteger> indexes, int length) {
    final _ret = _lib._objc_msgSend_768(
        _id, _lib._sel_initWithIndexes_length_1, indexes, length);
    return NSIndexPath._(_ret, _lib, retain: true, release: true);
  }

  NSIndexPath initWithIndex_(int index) {
    final _ret = _lib._objc_msgSend_60(_id, _lib._sel_initWithIndex_1, index);
    return NSIndexPath._(_ret, _lib, retain: true, release: true);
  }

  NSIndexPath indexPathByAddingIndex_(int index) {
    final _ret =
        _lib._objc_msgSend_769(_id, _lib._sel_indexPathByAddingIndex_1, index);
    return NSIndexPath._(_ret, _lib, retain: true, release: true);
  }

  NSIndexPath indexPathByRemovingLastIndex() {
    final _ret =
        _lib._objc_msgSend_770(_id, _lib._sel_indexPathByRemovingLastIndex1);
    return NSIndexPath._(_ret, _lib, retain: true, release: true);
  }

  int indexAtPosition_(int position) {
    return _lib._objc_msgSend_86(_id, _lib._sel_indexAtPosition_


e> is called or new color settings are set.

If there was a problem setting the color settings, then an error is
returned.

source
fn reset(&mut self) -> Result<()>

Reset the current color settings to their original settings.

If there was a problem resetting the color settings, then an error is
returned.

Note that this does not reset hyperlinks. Those need to be
reset on their own, e.g., by calling set_hyperlink with
[HyperlinkSpec::none].

Provided Methods§

source
fn is_synchronous(&self) -> bool

Returns true if and only if the underlying writer must synchronously
interact with an end user’s device in order to control colors. By
default, this always returns false.

In practice, this should return true if the underlying writer is
manipulating colors using the Windows console APIs.

This is useful for writing generic code (such as a buffered writer)
that can perform certain optimizations when the underlying writer
doesn’t rely on synchronous APIs. For example, ANSI escape sequences
can be passed through to the end user’s device as is.

source
fn set_hyperlink(&mut self, _link: &HyperlinkSpec<'_>) -> Result<()>

Set the current hyperlink of the writer.

The typical way to use this is to first call it with a
<a href="struct.HyperlinkSpec.html#method.open" title="associated function termcolor::Hyperlink


BSD-3-clause`
- `BSD-like-with-advertising-clause`
- `GPL-2`
- `GPL-2+`
- `expat`
- `libpng`
- `libpng OR Apache-2.0 OR BSD-3-clause`

Source:

```console
$ apt-get source -qq --print-uris libpng1.6=1.6.48-1
'http://deb.debian.org/debian/pool/main/libp/libpng1.6/libpng1.6_1.6.48-1.dsc' libpng1.6_1.6.48-1.dsc 2254 SHA256:dd8742533bd0201d64c94e019460ddf28141f369fc78f52c19028d58530f87f0
'http://deb.debian.org/debian/pool/main/libp/libpng1.6/libpng1.6_1.6.48.orig.tar.gz' libpng1.6_1.6.48.orig.tar.gz 1572923 SHA256:b17e99026055727e8cba99160c3a9a7f9af788e9f786daeadded5a42243f1dd0
'http://deb.debian.org/debian/pool/main/libp/libpng1.6/libpng1.6_1.6.48-1.debian.tar.xz' libpng1.6_1.6.48-1.debian.tar.xz 33240 SHA256:647c6b09cdb628200e2213b75f6ab3fe0a4fe18f21fe78c6821ecb15e154e7d2
```

Other potentially useful URLs:

- https://sources.debian.net/src/libpng1.6/1.6.48-1/ (for browsing the source)
- https://sources.debian.net/src/libpng1.6/1.6.48-1/debian/copyright/ (for direct copyright/license information)
- http://snapshot.debian.org/package/libpng1.6/1.6.48-1/ (for access to the source package after it no longer exists in the archive)

### `dpkg` source package: `libpsl=0.21.2-1.1`

Binary Packages:

- `libpsl-dev:amd64=0.21.2-1.1+b1`
- `libpsl5t64:amd64=0.21.2-1.1+b1`

Licenses: (parsed from: `/usr/share/doc/libpsl-dev/copyright`, `/usr/share/doc/libpsl5t64/copyright`)

- `Chromium`
- `MIT`
- `gnulib`

Source:

```console
$ apt-get source -qq --print-uris libpsl=0.21.2-1.1
'http://deb.debian.org/debian/pool/main/libp/libpsl/libpsl_0.21.2-1.1.dsc' libpsl_0.21.2-1.1.dsc 2285 SHA256:b9b5496ca2bffb827cb0b2d997469908a2b7a7475c20a11c02f9dcd1ed2a0cc9
'http://deb.debian.org/debian/pool/main/libp/libpsl/libpsl_0.21.2.orig.tar.xz' libpsl_0.21.2.orig.tar.xz 1870352 SHA256:11e34380f2c81d6e72c710464aae3b680df4ddcc1007826c630fb03c7ca6aa54
'http://deb.debian.org/debian/pool/main/libp/libpsl/libpsl_0.21.2-1.1.debian.tar.xz' libpsl_0.21.2-1.1.debian.tar.xz 12120 SHA256:0eccab147b6dfbfb7f5ad40fb5bd9f888d72a0fe44e7d1801811c34a9acad1a7
```

Other potentially useful URLs:

- https://sources.


e_Content_0x8103_Parameter;

import ai.sangmado.gbprotocol.jt808.protocol.IVersionedSpecificationContext;
import ai.sangmado.gbprotocol.jt808.protocol.serialization.IJT808MessageBufferReader;
import ai.sangmado.gbprotocol.jt808.protocol.serialization.IJT808MessageBufferWriter;
import ai.sangmado.gbprotocol.jt808.protocol.message.content.JT808_Message_Content_0x8103_Parameter.JT808_Message_Content_0x8103_ParameterItem;
import ai.sangmado.gbprotocol.jt808.protocol.message.content.JT808_Message_Content_0x8103_Parameter.JT808_Message_Content_0x8103_ParameterItemId;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

/**
 * 平台设置终端参数 - 参数项 - 变道决策辅助功能参数
 */
@NoArgsConstructor
public class JT808DB32T3610_Message_Content_0x8103_PI_0xF367 extends JT808_Message_Content_0x8103_ParameterItem {
    public static final JT808_Message_Content_0x8103_ParameterItemId PARAMETER_ITEM_ID =
            JT808DB32T3610_Message_Content_0x8103_ParameterItemId.JT808DB32T3610_0x8103_0xF367;

    @Override
    public JT808_Message_Content_0x8103_ParameterItemId getParameterItemId() {
        return PARAMETER_ITEM_ID;
    }

    @Override
    public Integer getParameterItemLength() {
        return 4;
    }

    /**
     * xxx
     */
    @Getter
    @Setter
    private Integer xxx;

    @Override
    public void serialize(IVersionedSpecificationContext ctx, IJT808MessageBufferWriter writer) {

    }

    @Override
    public void deserialize(IVersionedSpecificationContext ctx, IJT808MessageBufferReader reader) {

    }

    public static JT808DB32T3610_Message_Content_0x8103_PI_0xF367 decode(IVersionedSpecificationContext ctx, IJT808MessageBufferReader reader) {
        JT808DB32T3610_Message_Content_0x8103_PI_0xF367 content = new JT808DB32T3610_Message_Content_0x8103_PI_0xF367();
        content.deserialize(ctx, reader);
        return content;
    }
}
package ai.sangmado.gbprotocol.jt808db32t3610.protocol.message.content.JT808DB32T3610_Message_Content_0x8103_Parameter;

import ai.sangmado.gbprotocol.jt808.protocol.IVersionedSpecificationContext;
import ai.sangmado.gbprotocol.jt808.protocol.message.content.JT808_Message_Content_0x8103_Parameter.JT808_Message_Content_0x8103_ParameterItem;
import ai.sangmado.gbprotocol.jt808.protocol.message.content.JT808_Message_Content_0x8103_Parameter.JT808_Message_Content_0x8103_ParameterItemId;
import ai.sangmado.gbprotocol.jt808.protocol.serialization.IJT808MessageBufferReader;
import ai.sangmado.gbprotocol.jt808.protocol.serialization.IJT808MessageBufferWriter;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;


gdGC 30916
IEJpbg== 30917
IGdyYWNpYXM= 30918
4buDbg== 30919
IHBpcA== 30920
w61zdGljYQ== 30921
IGVxdWl0eQ== 30922
15HXmded 30923
IENyZWF0aXZl 30924
0LfQvdCw0Yc= 30925
IFNub3c= 30926
Lk9L 30927
IHN1cmVseQ== 30928
0ZbRjw== 30929
bXlz 30930
IG9yZGVyaW5n 30931
aXRpYWxpemU= 30932
IG7Emw== 30933
MzE5 30934
UHJlZmVycmVk 30935
aHTDqw== 30936
IHNpbXVsYXRpb24= 30937
IHN0YWlubGVzcw== 30938
IHNvY2s= 30939
16LXqg== 30940
TUFORA== 30941
Q2E= 30942
4Z+H 30943
IOaIkQ== 30944
IGluY2x1c28= 30945
57qq 30946
aWNhbmE= 30947
LnBkZg== 30948
4KS/4KSP4KSV4KWL 30949
eHh4eA== 30950
IHRlbGFo 30951
KGAkew== 30952
IEJleQ== 30953
IGV4Y2VsbA== 30954
w61jaWE= 30955
Um91dGVz 30956
IGVsZWN0ZWQ= 30957
IHByb3hpbQ== 30958
dmVsb2NpdHk= 30959
IGltYQ== 30960
4KWt 30961
IFRFWFQ= 30962
U2V4 30963
IOCqueCqpOCriw== 30964
INC/0LDRgNCw 30965
RGVjb3JhdGlvbg== 30966
IHBhcnRpZG8= 30967
4KqV4KuN4Kq3 30968
IGzDpQ== 30969
bm9ybQ== 30970
INC+0Yg= 30971
5LyR 30972
SW5mb3Jt 30973
IG91dHJh 30974
4KuL4Kqc 30975
SG91cnM= 30976
IOCqueCri+Cqrw== 30977
VVNE 30978
IHJlbGVhc2Vz 30979
4oCZeQ== 30980
INC40LfQvNC10L0= 30981
IENyZWVr 30982
LnNjcm9sbA== 30983
cmVjaHQ= 30984
IEFuc3dlcg== 30985
IOCkq+Ckv+Cksg== 30986
LWJhcg== 30987
IGZhbnRhc3k= 30988
INmF2K3Zhdiv 30989
IGNiZA== 30990
w7JuZw== 30991
aW5kaWNlcw== 30992
IEVr 30993
X25vcm1hbA== 30994
IHZldGVyYW4= 30995
dmVyc2F0aW9u 30996
IGzDtg== 30997
Mjc0 30998
1ao= 30999
0YDQsNCx 31000
IOiH 31001
0LTQtg== 31002
IGNvbm9jZXI= 31003
b2dl 31004
IGFtb25nc3Q= 31005
IEhlbHBlcg== 31006
MzI0 31007
IEphaw== 31008
c3RhZw== 31009
INmI2KU= 31010
cG9zaXRvcmllcw== 31011
IG3Emw== 31012
1aHVr9aB 31013
IOC5hg== 31014
5Lq/5YWD 31015
IHNhaQ== 31016
VGFw 31017
INGC0YDQsNC9 31018
IHByZWNpc2E= 31019
IEhvbGw= 31020
X


DeepHole_DeathMountain
	[1305.00, 62.28 + 105, 2396.66], //5901788378855460870 - DeepHole_Firone
	[-452.50, 67.28 + 105, 1992.98], //15905392722740304 - DeepHole_FirstLandEast
	[-664.93, 49.49 + 105, 1509.75], //1435983989598451303 - DeepHole_FirstLandNorth
	[-932.83, 163.54 + 105, 2317.51], //5328634591570328090 - DeepHole_FirstLandSouth
	[-1431.69, 225.82 + 105, 1992.55], //12664920886408899240 - DeepHole_FirstLandWest
	[-1794.92, 44.36 + 105, 3461.76], //397255910733783029 - DeepHole_GerudoMaze
	[-4203.36, 643.08 + 105, 637.66], //6383879160737498330 - DeepHole_GerudoSummit
	[4029.55, -96.18 + 105, -2180.88], //10687953805007878473 - DeepHole_Higakkare
	[2513.71, 131.29 + 105, 2380.70], //8270027616370949329 - DeepHole_HimeidaMt
	[-254.00, -210.00 + 105, -1012.17], //18137312076250302730 - DeepHole_HyruleCastle
	[169.99, -48.18 + 105, -882.16], //12644792830451791701 - DeepHole_HyruleCastleEast
	[-922.61, -9.48 + 105, -666.79], //3643485269032630633 - DeepHole_HyruleCastleWest
	[-332.00, -51.82 + 105, 2598.02], //13929777954014421303 - DeepHole_HyruleLake
	[-255.03, -1.53 + 105, 299.58], //12420116610575098418 - DeepHole_HyrulePlains
	[-456.88, 169.39 + 105, -1722.35], //12232431606697414475 - DeepHole_ImeruMt
	[1974.49, 115.51 + 105, 846.13], //5810770272691429369 - DeepHole_Kakariko_EastHill
	[1059.43, 149.87 + 105, -1668.10], //4789371614404322252 - DeepHole_KiyanbaTrees
	[4655.00, 26.50 + 105, -3697.47], //1595756749757738282 - DeepHole_LomeiIsland
	[3296.86, 124.95 + 105, -1286.69], //4734326941896126368 - DeepHole_Minakkare
	[-71.04, 126.93 + 105, -2983.78], //2258222317531786547 - DeepHole_RirimukuMt
	[-3573.46, 119.04 + 105, -1801.97], //17183754997239633264 - DeepHole_Rito
	[4507.12, -17.06 + 105, 3459.30], //11336577741930217675 - DeepHole_Saihateno
	[221.94, -2.12 + 105, 2118.77], //11031454923833399536 - DeepHole_SanaePlateau
	[-814.48, 220.20 + 105, -3534.70], //16896066116062008519 - DeepHole_TabantaMaze
	[3604.59, 118.14 + 105, 1343.98], //7545616274530289895 - DeepHole_YuaSnow
	[-127.97, -31.99 + 105, 1657.81], //141747455


-48(%edx,%ecx,1),%xmm0
	movdqu	(%esi),%xmm2
	movdqu	16(%esi),%xmm3
	movdqu	32(%esi),%xmm4
	movdqu	48(%esi),%xmm5
	movdqu	64(%esi),%xmm6
	movdqu	80(%esi),%xmm7
	leal	96(%esi),%esi
	movdqa	%xmm1,96(%esp)
	pxor	%xmm0,%xmm2
	pxor	%xmm0,%xmm3
	pxor	%xmm0,%xmm4
	pxor	%xmm0,%xmm5
	pxor	%xmm0,%xmm6
	pxor	%xmm0,%xmm7
	movups	-32(%edx,%ecx,1),%xmm1
	pxor	(%esp),%xmm2
	pxor	16(%esp),%xmm3
	pxor	32(%esp),%xmm4
	pxor	48(%esp),%xmm5
	pxor	64(%esp),%xmm6
	pxor	80(%esp),%xmm7
	movups	-16(%edx,%ecx,1),%xmm0
.byte	102,15,56,222,209
.byte	102,15,56,222,217
.byte	102,15,56,222,225
.byte	102,15,56,222,233
.byte	102,15,56,222,241
.byte	102,15,56,222,249
	movl	120(%esp),%edi
	movl	124(%esp),%eax
	call	L_aesni_decrypt6_enter
	movdqa	80(%esp),%xmm0
	pxor	(%esp),%xmm2
	movdqa	96(%esp),%xmm1
	pxor	16(%esp),%xmm3
	pxor	32(%esp),%xmm4
	pxor	48(%esp),%xmm5
	pxor	64(%esp),%xmm6
	pxor	%xmm0,%xmm7
	pxor	%xmm2,%xmm1
	movdqu	%xmm2,-96(%edi,%esi,1)
	pxor	%xmm3,%xmm1
	movdqu	%xmm3,-80(%edi,%esi,1)
	pxor	%xmm4,%xmm1
	movdqu	%xmm4,-64(%edi,%esi,1)
	pxor	%xmm5,%xmm1
	movdqu	%xmm5,-48(%edi,%esi,1)
	pxor	%xmm6,%xmm1
	movdqu	%xmm6,-32(%edi,%esi,1)
	pxor	%xmm7,%xmm1
	movdqu	%xmm7,-16(%edi,%esi,1)
	cmpl	%eax,%esi
	jb	L087grandloop
L086short:
	addl	$96,%eax
	subl	%esi,%eax
	jz	L088done
	cmpl	$32,%eax
	jb	L089one
	je	L090two
	cmpl	$64,%eax
	jb	L091three
	je	L092four
	leal	1(%ebp),%ecx
	leal	3(%ebp),%eax
	bsfl	%ecx,%ecx
	bsfl	%eax,%eax
	shll	$4,%ecx
	shll	$4,%eax
	movdqu	(%ebx),%xmm2
	movdqu	(%ebx,%ecx,1),%xmm3
	movl	116(%esp),%ecx
	movdqa	%xmm2,%xmm4
	movdqu	(%ebx,%eax,1),%xmm5
	movdqa	%xmm2,%xmm6
	pxor	%xmm0,%xmm2
	pxor	%xmm2,%xmm3
	movdqa	%xmm2,(%esp)
	pxor	%xmm3,%xmm4
	movdqa	%xmm3,16(%esp)
	pxor	%xmm4,%xmm5
	movdqa	%xmm4,32


               return false;
            }

            return true;
        }

        public void addToInputBox(int month, string count)
        {
            txtCount.Text = count;
            cboMonth.SelectedIndex = month - 1;
        }

        //  ----------------------  form action ------------------------

        private void btnSelect_Click(object sender, EventArgs e)
        {
            if (_validate())
            {
                this.Hide();
                if (_isAdd)
                {
                    RentService._applianceList.rentServiceInput = new RentServiceInputValue(cboMonth.SelectedIndex + 1, txtCount.Text);
                }
                else {
                    RentServiceAppliance.rentServiceInput = new RentServiceInputValue(cboMonth.SelectedIndex + 1, txtCount.Text);
                }

                //return new RentServiceInputValue(cboMonth.SelectedIndex, txtCount.Text);
            }

        }

    }

    public class RentServiceInputValue
    {
        public int month;
        public string count;

        public RentServiceInputValue(int _month, string _count)
        {
            month = _month;
            count = _count;
        }
    }
}


D)\*$/;

    constructor(cmd:string, readonly lineNo?:number) {
        let match = LPCommand.matchExp.exec(cmd);
        if (!match) {
            throw new GerberParseException(`Invalid LP command format ${cmd}`);
        }
        this.polarity = (match[1] == "C") ? ObjectPolarity.LIGHT : ObjectPolarity.DARK;
    }

    formatOutput():string {
        return "LP" + ((this.polarity == ObjectPolarity.LIGHT) ? "C" : "D") + "*";
    }

    execute(ctx:GerberState) {
        ctx.objectPolarity = this.polarity;
    }
}

export class LMCommand implements GerberCommand {
    readonly name = "LM";
    readonly isAdvanced = true;
    readonly miroring:ObjectMirroring;
    private static matchExp = /^LM(N|X|Y|XY)\*$/;

    constructor(cmd:string, readonly lineNo?:number) {
        let match = LMCommand.matchExp.exec(cmd);
        if (!match) {
            throw new GerberParseException(`Invalid LM command format ${cmd}`);
        }
        let code = match[1];
        if (code == "N") {
            this.miroring = ObjectMirroring.NONE;
        } else if (code == "X") {
            this.miroring = ObjectMirroring.X_AXIS;
        } else if (code == "Y") {
            this.miroring = ObjectMirroring.Y_AXIS;
        } else if (code == "XY") {
            this.miroring = ObjectMirroring.XY_AXIS;
        }
    }

    formatOutput():string {
        let result = "LM";
        switch (this.miroring) {
            case ObjectMirroring.NONE: result += "N";break;
            case ObjectMirroring.X_AXIS: result += "X";break;
            case ObjectMirroring.Y_AXIS: result += "Y";break;
            case ObjectMirroring.XY_AXIS: result += "XY";break;
        }
        result += "*";
        return result;
    }

    execute(ctx:GerberState) {
        ctx.objectMirroring = this.miroring;
    }
}

export class LRCommand implements GerberCommand {
    readonly name = "LR";
    readonly isAdvanced = true;
    readonly rotation:number;
    private static matchExp = /^LR([\+\-]?(?:\d*\.\d+|\d+))\*$/;

    constructor(cmd:string, readonly lineNo?:number) {
        let match = LRCommand.matchExp.exec(cmd);
        if (!match) {
            throw new GerberParseException(`Invalid LR command format ${cmd}`);
        }
        this.rotation = Number.parseFloat(match[1]);
    }

    formatOutput():string {
        return "LR" + this.rotation + "*";
    }

    execute(ctx:GerberState) {
        ctx.objectRotation = this.rotation;
    }
}

export class LSCommand implements GerberCommand {
    readonly name = "LS";
    readonly isAdvanced = true;
    readonly scale:number;
    private static matchExp = /^LS([\+\-]?(?:\d*\.\d+|\d+))\*$/;

    constructor(cmd:string, readonly lineNo?:number) {
        let match = LSCommand.matchExp.exec(cmd);
        if (!match) {
            throw new GerberParseException(`Invalid LS command format ${cmd}`);
        }
        this.scale = Number.parseFloat(match[1]);
    }

    formatOutput():string {
        return "LS" + this.scale + "*";
    }

    execute(ctx:GerberState) {
        ctx.objectScaling = this.scale;
    }
}

export class G36Command extends BaseGCodeCommand implements GerberCommand {
    readonly name = "G36";
    constructor(cmd:string, lineNo?:number) {
        super(cmd, 36, lineNo);
    }

    execute(ctx:GerberState) {


umArtist == id) return true; // 如果专辑艺术家与ID相同，返回true
          throw Exception('Metadata albumArtist does not match ID');
        } catch (e) {}
      } else {
        try {
          Tag? t = await tagger.getAllTags(filePath);
          if (t?.composer == id) return true; // 如果作曲家与ID相同，返回true
          throw Exception('Metadata composer does not match ID');
        } catch (e) {}
      }
    }
    return false;
  }

  Future<void> saveMetadataToCache(String id, String filePath) async {
    if (saveMetadataToCacheWorkingIds.contains(id)) return;
    saveMetadataToCacheWorkingIds.add(id);
    if (is_windows) {
      if (_firstCheck) {
        _firstCheck = false;
        await isFFmpegOk();
      }
      if (isFFmpegOkWithoutCheck) {
        Track? track = Get.find<PlayController>().getTrackById(id);
        if (track == null) return;
        try {
          String outPath = await getDownloadNamedPath(track);
          if (!{'.m4s', '.flv'}.any((ext) => filePath.endsWith(ext))) {
            outPath =
                outPath.replaceAll('.m4a', '') + '.' + filePath.split('.').last;
          }

          // 尝试使用FFmpeg转换格式
          // ffmpeg -i .\138077118_u2-1-30280.m4s -vn -acodec copy output.m4a
          var result = await Process.run(ffmpegPathWindows, [
            '-i',
            filePath,
            '-vn',
            '-acodec',
            'copy',
            outPath,
          ], runInShell: true);

          if (result.exitCode == 0) {
            if (basename(filePath) != basename(outPath)) {
              _toDelFiles.add(filePath);
            }
            _localCacheList[id] = outPath.split('/').last.split('\\').last;
            File? cover = await getCachedImageFile(track.img_url ?? '');
            String? mimeType = cover != null
                ? lookupMimeType(cover.path)
                : null;
            bool needToDel = false;
            if (mimeType == null) {
              try {
                await Dio().download(track.img_url ?? '', '$outPath.cover');
                cover = File('$outPath.cover');
                mimeType = lookupMimeType(
                  cover.path,
                  headerBytes: cover.readAsBytesSync(),
                );
                needToDel = true;
              } catch (e) {
                debugPrint('下载封面失败: $e');
              }
            }
            if (is_windows) {
              Metadata toSaveMetadata = mimeType != null
                  ? Metadata(
                      title: track.title,
                      artist: track.artist,
                      album: track.album,
                      albumArtist: id,
                      picture: Picture(
                        data: await cover!.readAsBytes(),
                        mimeType: mimeType,
                      ),
                    )
                  : Metadata(
                      title: track.title,
                      artist: track.artist,
                      album: track.album,
                      albumArtist: id,
                    );
              if (needToDel) {
                try {
                  cover!.deleteSync();
                } catch (e) {
                  debugPrint('删除临时封面失败: $e');
                }
              }


			outputStream.Write(HTMLElements.m_quoteString);
				outputStream.Write(HTMLElements.m_title);
				outputStream.Write(AltText);
				outputStream.Write(HTMLElements.m_quoteString);
			}
			outputStream.Write(HTMLElements.m_openStyle);
			if (Size != null)
			{
				Size.Render(outputStream);
			}
			if (Opacity.HasValue)
			{
				outputStream.Write(HTMLElements.m_space);
				outputStream.Write(HTMLElements.m_opacity);
				outputStream.Write(Opacity.ToString());
			}
			outputStream.Write(HTMLElements.m_quoteString);
			if (CustomAttributes != null)
			{
				foreach (KeyValuePair<string, string> customAttribute in CustomAttributes)
				{
					outputStream.Write(HTMLElements.m_space);
					outputStream.Write(customAttribute.Key);
					outputStream.Write(HTMLElements.m_equal);
					outputStream.Write(HTMLElements.m_quoteString);
					outputStream.Write(customAttribute.Value);
					outputStream.Write(HTMLElements.m_quoteString);
				}
			}
			outputStream.Write(HTMLElements.m_src);
			if (Image != null)
			{
				outputStream.Write(Image);
			}
			outputStream.Write(HTMLElements.m_quoteString);
			outputStream.Write(HTMLElements.m_space);
			outputStream.Write(HTMLElements.m_closeSingleTag);
		}
	}
}


8-byte Spill
	mov	qword ptr [rsp + 160], r15      # 8-byte Spill
	mov	qword ptr [rsp + 240], r10      # 8-byte Spill
	sub	r10, r8
	mov	qword ptr [rsp + 208], r10      # 8-byte Spill
	.p2align	4, 0x90
.LBB5_185:                              # =>This Inner Loop Header: Depth=1
	ucomiss	xmm0, dword ptr [rbx]
	setp	al
	setne	cl
	or	cl, al
	mov	r13d, ecx
	ucomiss	xmm0, dword ptr [rbx + 4]
	setp	al
	setne	dl
	or	dl, al
	ucomiss	xmm0, dword ptr [rbx + 8]
	setp	al
	setne	cl
	or	cl, al
	mov	byte ptr [rsp + 24], cl         # 1-byte Spill
	ucomiss	xmm0, dword ptr [rbx + 12]
	setp	al
	setne	cl
	or	cl, al
	mov	byte ptr [rsp + 32], cl         # 1-byte Spill
	ucomiss	xmm0, dword ptr [rbx + 16]
	setp	al
	setne	cl
	or	cl, al
	mov	byte ptr [rsp + 64], cl         # 1-byte Spill
	ucomiss	xmm0, dword ptr [rbx + 20]
	setp	al
	setne	cl
	or	cl, al
	mov	byte ptr [rsp + 56], cl         # 1-byte Spill
	ucomiss	xmm0, dword ptr [rbx + 24]
	setp	al
	setne	cl
	or	cl, al
	mov	byte ptr [rsp + 48], cl         # 1-byte Spill
	ucomiss	xmm0, dword ptr [rbx + 28]
	setp	al
	setne	cl
	or	cl, al
	mov	byte ptr [rsp + 8], cl          # 1-byte Spill
	ucomiss	xmm0, dword ptr [rbx + 32]
	setp	al
	setne	cl
	or	cl, al
	mov	byte ptr [rsp + 40], cl         # 1-byte Spill
	ucomiss	xmm0, dword ptr [rbx + 36]
	setp	al
	setne	cl
	or	cl, al
	mov	byte ptr [rsp + 80], cl         # 1-byte Spill
	ucomiss	xmm0, dword ptr [rbx + 40]
	setp	al
	setne	cl
	or	cl, al
	mov	byte ptr [rsp + 72], cl         # 1-byte Spill
	ucomiss	xmm0, dword ptr [rbx + 44]
	setp	al
	setne	cl
	or	cl, al
	mov	byte ptr [rsp + 104], cl        # 1-byte Spill
	ucomiss	xmm0, dword ptr [rbx + 48]
	setp	al
	setne	cl
	or	cl, al
	mov	byte ptr [rsp + 96], cl         # 1-byte Spill
	ucomiss	xmm0, dword ptr [rbx + 52]
	setp	al
	setne	cl
	or	cl, al
	mov	byte ptr [rsp + 128], cl        # 1-byte Spill
	ucomiss	xmm0, dword ptr [rbx + 56]
	setp	al
	setne	cl
	or	cl, al
	mov	byte ptr [rsp + 112], cl        # 1-byte Spill
	ucomiss	xmm0, dword ptr


}

.post-navigation a {
	color: #1a1a1a;
	display: block;
	padding: 1.75em 0;
}

.post-navigation span {
	display: block;
}

.post-navigation .meta-nav {
	color: #686868;
	font-size: 13px;
	font-size: 0.8125rem;
	letter-spacing: 0.076923077em;
	line-height: 1.6153846154;
	margin-bottom: 0.5384615385em;
	text-transform: uppercase;
}

.post-navigation .post-title {
	display: inline;
	font-family: Montserrat, "Helvetica Neue", sans-serif;
	font-size: 23px;
	font-size: 1.4375rem;
	font-weight: 700;
	line-height: 1.2173913043;
	text-rendering: optimizeLegibility;
}

.post-navigation a:hover .post-title,
.post-navigation a:focus .post-title {
	color: #007acc;
}

.post-navigation div + div {
	border-top: 4px solid #1a1a1a;
}

.pagination {
	border-top: 4px solid #1a1a1a;
	font-family: Montserrat, "Helvetica Neue", sans-serif;
	font-size: 19px;
	font-size: 1.1875rem;
	margin: 0 7.6923% 2.947368421em;
	min-height: 56px;
	position: relative;
}

.pagination:before,
.pagination:after {
	background-color: #1a1a1a;
	content: "";
	height: 52px;
	position: absolute;
	top:0;
	width: 52px;
	z-index: 0;
}

.pagination:before {
	right: 0;
}

.pagination:after {
	right: 54px;
}

.pagination a:hover,
.pagination a:focus {
	color: #1a1a1a;
}

.pagination .nav-links {
	padding-right: 106px;
	position: relative;
}

.pagination .nav-links:before,
.pagination .nav-links:after {
	color: #fff;
	font-size: 32px;
	line-height: 51px;
	opacity: 0.3;
	position: absolute;
	width: 52px;
	z-index: 1;
}

.pagination .nav-links:before {
	content: "\f429";
	right: -1px;
}

.pagination .nav-links:after {
	content: "\f430";
	right: 55px;
}

/* reset screen-reader-text */
.pagination .current .screen-reader-text {
	position: static !important;
}

.pagination .page-numbers {
	display: none;
	letter-spacing: 0.013157895em;
	line-height: 1;
	margin: 0 0.7368421053em 0 -0.7368421053em;
	padding: 0.8157894737em 0.7368421053em 0.3947368421em;
	text-transform: uppercase;
}

.pagination .current {
	display: inline-block;
	font-weight: 700;
}

.pagination .prev,
.pagination .next {
	background-color: #1a1a1a;
	color: #fff;
	display: inline-block;
	height: 52px;
	margin: 0;
	overflow: hidden;
	padding: 0;
	position: absolute;
	top: 0;
	width: 52px;
	z-index: 2;
}

.pagination .prev:before,
.pagination .next:before {
	font-size: 32px;
	height: 53px;
	line-height: 52px;
	position: relative;
	width: 53px;
}

.paginat


nFlags;
		fn->FunctionFlags |= 0x00000400;
		UObject::ProcessEvent(fn, &params);
		fn->FunctionFlags = flags;

		return params.ReturnValue;
	}

	/**
	 * Function:
	 * 		RVA    -> 0x00BB5310
	 * 		Name   -> Function DreadGameUI.UI_LoginScreen_PS4.GetErrorDisplayInfo
	 * 		Flags  -> (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
	 * Parameters:
	 * 		EYTitleScreenError                                 screenError                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	 */
	struct FLoginScreenErrorPopupData UUI_LoginScreen_PS4::GetErrorDisplayInfo(EYTitleScreenError screenError)
	{
		static UFunction* fn = nullptr;
		if (!fn)
			fn = UObject::FindObject<UFunction>("Function DreadGameUI.UI_LoginScreen_PS4.GetErrorDisplayInfo");

		UUI_LoginScreen_PS4_GetErrorDisplayInfo_Params params {};
		params.screenError = screenError;

		auto flags = fn->FunctionFlags;
		fn->FunctionFlags |= 0x00000400;
		UObject::ProcessEvent(fn, &params);
		fn->FunctionFlags = flags;

		return params.ReturnValue;
	}

	/**
	 * Function:
	 * 		RVA    -> 0x00BB1300
	 * 		Name   -> Function DreadGameUI.UI_LoginScreen_PS4.AcceptLegalDocument
	 * 		Flags  -> (Final, Native, Public, BlueprintCallable)
	 * Parameters:
	 * 		class FString                                      documentType                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	 * 		int32_t                                            Version                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	 */
	void UUI_LoginScreen_PS4::AcceptLegalDocument(const class FString& documentType, int32_t Version)
	{
		static UFunction* fn = nullptr;
		if (!fn)
			fn = UObject::FindObject<UFunction>("Function DreadGameUI.UI_LoginScreen_PS4.AcceptLegalDocument");

		UUI_LoginScreen_PS4_AcceptLegalDocument_Params params {};
		params.documentType = documentType;
		params.Version = Version;

		auto flags = fn->FunctionFlags;
		fn->FunctionFlags |= 0x00000400;
		UObject::ProcessEvent(fn, &params);
		fn->FunctionFlags = flags;
	}

	/**
	 * Function:
	 * 		RVA    -> 0x00BB11A0
	 * 		Name   -> Function DreadGameUI.UI_LoginScreen_PS4.AcceptAllLegalDocuments
	 * 		Flags  -> (Final, Native, Public, BlueprintCallable)
	 * Parameters:
	 * 		TArray<struct FLegalDocumentData>                  documents                                                  (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
	 */
	void UUI_LoginScreen_PS4::AcceptAllLegalDocuments(TArray<struct FLegalDocumentData> documents)
	{
		static UFunction* fn = nullptr;
		if (!fn)
			fn = UObject::FindObject<UFunction>("Function DreadGameUI.UI_LoginScreen_PS4.AcceptAllLegalDocuments");

		UUI_LoginScreen_PS4_AcceptAllLegalDocuments_Params params {};
		params.documents = documents;

		auto flags = fn->FunctionFlags;
		fn->FunctionFlags |= 0x00000400;
		UObject::ProcessEvent(fn, &params);
		fn->FunctionFlags = flags;
	}

	/**
	 * Function:
	 * 		RVA    -> 0x00000000
	 * 		Name   -> PredefinedFunction UUI_LoginScreen_PS4.StaticClass
	 * 		Flags  -> (Predefined, Static)
	 */
	UClass* UUI_LoginScreen_PS4::StaticClass()
	{
		static UClass* ptr


: left;
	height: 1.75em;
	margin: .0625em;
	line-height: 1.65em;
}
.ui-flipswitch .ui-btn.ui-flipswitch-on {
	width: 1.75em;
	padding: 0;
	text-indent: -2.6em; /* Override this to center text if you use a label other than "on" */
	text-align: left;
	border-width: 1px;
	border-style: solid;
	-webkit-box-sizing: border-box;
	-moz-box-sizing: border-box;
	box-sizing: border-box;
	border-radius: inherit;
	overflow: visible;
	color: inherit;
	text-shadow: inherit;
}
.ui-flipswitch .ui-flipswitch-off {
	padding: 1px;
	text-indent: 1em; /* Override this to center text if you use a label other than "off" */
}
/* Override field container CSS to prevent the flipswitch from becomming full width */
html .ui-field-contain > label + .ui-flipswitch,
html .ui-popup .ui-field-contain > label + .ui-flipswitch {
	display: inline-block;
	width: 5.875em; /* If you override the width for .ui-flipswitch you should repeat the same value here */
	-webkit-box-sizing: content-box;
	-moz-box-sizing: content-box;
	box-sizing: content-box;
}
.ui-field-contain .ui-flipswitch.ui-flipswitch-active,
.ui-popup .ui-field-contain .ui-flipswitch.ui-flipswitch-active {
	width: 1.875em;
}
.ui-table {
	border: 0;
	border-collapse: collapse;
	padding: 0;
	width: 100%;
}
.ui-table th,
.ui-table td {
	line-height: 1.5em;
	text-align: left;
	padding: .4em .5em;
	vertical-align:top;
}
.ui-table th .ui-btn,
.ui-table td .ui-btn {
	line-height: normal;
}
.ui-table th {
	font-weight: bold;
}
.ui-table caption {
	text-align: left;
	margin-bottom: 1.4em;
	opacity: .5;
}
/*
 Styles for the table columntoggle mode
*/
.ui-table-columntoggle-btn {
	float: right;
	margin-bottom: .8em;
}
/* Remove top/bottom margins around the fieldcontain on check list */
.ui-table-columntoggle-popup fieldset {
	margin:0;
}
.ui-table-columntoggle {
	clear: both;
}
/* Hide all prioritized columns by default */
@media only all {
	th.ui-table-priority-6,
	td.ui-table-priority-6,
	th.ui-table-priority-5,
	td.ui-table-priority-5,
	th.ui-table-priority-4,
	td.ui-table-priority-4,
	th.ui-table-priority-3,
	td.ui-table-priority-3,
	th.ui-table-priority-2,
	td.ui-table-priority-2,
	th.ui-table-priority-1,
	td.ui-table-priority-1 {
		display: none;
	}
}
/* Preset breakpoints if ".ui-responsive" class added to table */
/* Show priority 1 at 320px (20em x 16px) */
@media screen and (min-width: 20em) {
	.ui-table-columntoggle.ui-responsive th.ui-table-priority-1,
	.ui-table-columntoggle.ui-responsive td.ui-table-priority-1 {
		display: table-cell;
	}
}
/* Show priority 2 at 480px (30em x 16px) */
@media screen and (min-width: 30em) {
	.ui-ta


 null = null;

  get error(): boolean {
    return this.status === StatusMarker.Red;
  }

  get success(): boolean {
    return this.status === StatusMarker.Green;
  }

  constructor(
    public readonly title: string,
    public readonly hint: string,
    private readonly action: () => Observable<HealthReport>
  ) {
    Assertion.notNull(title, 'title');
    Assertion.notNull(hint, 'hint');
    Assertion.notNull(action, 'action');
  }

  execute(): void {
    this.elapsed = null;
    const start = Date.now();
    this.status = StatusMarker.Yellow;

    this.action().subscribe(
      r => {
        this.elapsed = Date.now() - start;
        this.status = StatusMarker.Green;
      },
      e => {
        this.elapsed = Date.now() - start;
        this.status = StatusMarker.Red;
      }
    );
  }
}
import Work from '../model/work';
import Element from '../model/element';
import { createWork, getWorkInfo, updateWork } from '@/api/works';
import { ActionContext } from 'vuex';
import { ElMessage, ElMessageBox } from "element-plus";
export interface State {
  [propName: string]: any;
}
const state = {
  workMode: 'formal', //当前作品所处环境 editor formal
  work: {},//作品model
  editingPage: { elements: [] },//当前正在被编辑的页面
  editingPageProps: {},//当前页面的page属性
  editingElement: null, //当前正在编辑元素
  copyingElement: null,//copy中的元素

}

const getters = {}

const actions = {
  //创建作品
  async createWork({ commit }: ActionContext<State, any>, payload: any) {
    let work: any = new Work(payload);
    work.pages = encodeURIComponent(JSON.stringify(work.pages))
    let res = await createWork(work)
    if (res && res.code == 0) {
      ElMessageBox.confirm("作品已经创建成功，是否去编辑作品?", "成功提醒", {
        confirmButtonText: "去编辑",
        cancelButtonText: "留在原地",
        type: "success",
      })
        .then(() => {
          let url = "/editor/" + res.property.work_id;
          window.open(url, '_blank')
        })
        .catch(() => {
          //留在原地
        });
    } else {
      ElMessage.error(res.message)
    }
  },
  //获取作品详情
  async setWorkInfo({ commit }: ActionContext<State, any>, payload: any) {
    const res = await getWorkInfo({ work_id: payload.workId });
    if (res && res.code == 0) {
      let work = res.property;
      commit('setWorkInfo', work);
      commit('setWorkMode', 'editor')
      if (work && work.pages && work.pages.length > 0) {
        let editingPage: any = work?.pages[0];
        //设置当前编辑page
        commit('setEditingPage', editingPage);
        //设置当前page 背景相关属性
        let editPageEle: any = editingPage?.elements.find(
          (e: any) => e.name === "plug-page"
        );
        commit('setEditingPageProps', editPageEle.props);
      }
    } else {
      ElMessage.error(res.message);
    }
  },
  //保存作品
  async saveWork({ commit }: ActionContext<State, any>) {
    let work: any = JSON.parse(JSON.stringify(state.work));
    work.pages = encodeURIComponent(JSON.stringify(work.pages))


/*
 * Copyright (c) 2014-2025 GraphDefined GmbH <achim.friedland@graphdefined.com>
 * This file is part of WWCP WWCP <https://github.com/OpenChargingCloud/WWCP_WWCP>
 *
 * Licensed under the Affero GPL license, Version 3.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.gnu.org/licenses/agpl.html
 *
 * 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 t


6
	bls _02053A1C
	b _02053B30
_02053A1C:
	add r0, r0, r0
	add r0, pc
	ldrh r0, [r0, #0x6]
	lsl r0, r0, #0x10
	asr r0, r0, #0x10
	add pc, r0
_02053A28: ; jump table (using 16-bit offset)
	.short _02053A36 - _02053A28 - 2; case 0
	.short _02053A4E - _02053A28 - 2; case 1
	.short _02053A78 - _02053A28 - 2; case 2
	.short _02053AA0 - _02053A28 - 2; case 3
	.short _02053AE2 - _02053A28 - 2; case 4
	.short _02053B00 - _02053A28 - 2; case 5
	.short _02053B16 - _02053A28 - 2; case 6
_02053A36:
	ldr r0, [r4, #0x0]
	mov r1, #0x0
	ldr r0, [r0, #0x38]
	bl sub_0205537C
	mov r0, #0x6
	lsl r0, r0, #0x6
	ldr r1, [r4, r0]
	add sp, #0xc
	add r1, r1, #0x1
	str r1, [r4, r0]
	pop {r4-r5, pc}
_02053A4E:
	sub r1, #0x24
	add r0, r4, #0x0
	add r1, r4, r1
	mov r2, #0x3
	bl sub_02053F38
	mov r0, #0x63
	lsl r0, r0, #0x4
	bl PlaySE
	mov r0, #0x5f
	mov r1, #0x1
	lsl r0, r0, #0x2
	str r1, [r4, r0]
	add r1, r0, #0x4
	ldr r1, [r4, r1]
	add r0, r0, #0x4
	add r1, r1, #0x1
	add sp, #0xc
	str r1, [r4, r0]
	pop {r4-r5, pc}
_02053A78:
	add r0, r1, #0x4
	ldr r2, [r4, r0]
	sub r2, #0x20
	str r2, [r4, r0]
	ldr r1, [r4, r0]
	mov r0, #0xfe
	mvn r0, r0
	cmp r1, r0
	bge _02053B30
	mov r0, #0x1
	mov r1, #0x0
	bl GfGfx_EngineBTogglePlanes
	mov r0, #0x6
	lsl r0, r0, #0x6
	ldr r1, [r4, r0]
	add sp, #0xc
	add r1, r1, #0x1
	str r1, [r4, r0]
	pop {r4-r5, pc}
_02053AA0:
	add r0, r1, #0x0
	sub r1, #0x18
	sub r0, #0x24
	ldr r1, [r4, r1]
	add r0, r4, r0
	blx r1
	add r5, r0, #0x0
	cmp r5, #0x2
	bne _02053AD0
	mov r1, #0x61
	mov r0, #0x0
	lsl r1, r1, #0


      Err(Error::InvalidData("unsupported media type"))
        }
    }

    pub fn box_type(&self) -> Result<FourCC> {
        if self.trak.mdia.minf.stbl.stsd.avc1.is_some() {
            Ok(FourCC::from(BoxType::Avc1Box))
        } else if self.trak.mdia.minf.stbl.stsd.hev1.is_some() {
            Ok(FourCC::from(BoxType::Hev1Box))
        } else if self.trak.mdia.minf.stbl.stsd.vp09.is_some() {
            Ok(FourCC::from(BoxType::Vp09Box))
        } else if self.trak.mdia.minf.stbl.stsd.mp4a.is_some() {
            Ok(FourCC::from(BoxType::Mp4aBox))
        } else if self.trak.mdia.minf.stbl.stsd.tx3g.is_some() {
            Ok(FourCC::from(BoxType::Tx3gBox))
        } else {
            Err(Error::InvalidData("unsupported sample entry box"))
        }
    }

    pub fn width(&self) -> u16 {
        if let Some(ref avc1) = self.trak.mdia.minf.stbl.stsd.avc1 {
            avc1.width
        } else {
            self.trak.tkhd.width.value()
        }
    }

    pub fn height(&self) -> u16 {
        if let Some(ref avc1) = self.trak.mdia.minf.stbl.stsd.avc1 {
            avc1.height
        } else {
            self.trak.tkhd.height.value()
        }
    }

    pub fn frame_rate(&self) -> f64 {
        let dur_msec = self.duration().as_millis() as u64;
        if dur_msec > 0 {
            ((self.sample_count() as u64 * 1000) / dur_msec) as f64
        } else {
            0.0
        }
    }

    pub fn sample_freq_index(&self) -> Result<SampleFreqIndex> {
        if let Some(ref mp4a) = self.trak.mdia.minf.stbl.stsd.mp4a {
            if let Some(ref esds) = mp4a.esds {
                SampleFreqIndex::try_from(esds.es_desc.dec_config.dec_specific.freq_index)
            } else {
                Err(Error::BoxInStblNotFound(self.track_id(), BoxType::EsdsBox))
            }
        } else {
            Err(Error::BoxInStblNotFound(self.track_id(), BoxType::Mp4aBox))
        }
    }

    pub fn channel_config(&self) -> Result<ChannelConfig> {
        if let Some(ref mp4a) = self.trak.mdia.minf.stbl.stsd.mp4a {
            if let Some(ref esds) = mp4a.esds {
                ChannelConfig::try_from(esds.es_desc.dec_config.dec_specific.chan_conf)
            } else {
                Err(Error::BoxInStblNotFound(self.track_id(), BoxType::EsdsBox))
            }
        } else {
            Err(Error::BoxInStblNotFound(self.track_id(), BoxType::Mp4aBox))
        }
    }

    pub fn language(&self) -> &str {
        &self.trak.mdia.mdhd.language
    }

    pub fn timescale(&self) -> u32 {
        self.trak.mdia.mdhd.timescale
    }

    pub fn duration(&self) -> Duration {
        Duration::from_micros(
            self.trak.mdia.mdhd.duration * 1_000_000 / self.trak.mdia.mdhd.timescale as u64,
        )
    }

    pub fn bitrate(&self) -> u32 {
        if let Some(ref mp4a) = self.trak.mdia.minf.stbl.stsd.mp4


onsider = btn in ImportantOperation.CONSIDERED_KEYBOARD_SET.value
            is_temporarily_catch = btn in temp_keyboard.keys()

            if (not is_temporarily_catch) and is_consider and (not is_release):
                temp_keyboard[btn] = time_stamp  # 按下按键

            if is_temporarily_catch and is_consider and is_release:
                delta_time = time_stamp - temp_keyboard[btn]  # 释放按键, 时间差

                if delta_time > ImportantOperation.LONG_PRESS_THRESHOLD.value:  # 长按或断按
                    new_keyboard_flows.append(({'op_name': btn,  # 需结合状态判定最终状态
                                                'way': ImportantOperation.LONG_PRESS.value,
                                                'press': round(delta_time, 1)}))
                else:
                    new_keyboard_flows.append(({'op_name': btn,
                                                'way': ImportantOperation.SHORT_PRESS.value}))

                keyboard_timestamp.append(temp_keyboard[btn])

                temp_keyboard.pop(btn)

        return new_keyboard_flows, keyboard_timestamp

    def mouse_pre_process(self):
        # 鼠标按键预处理
        # 尽管两个方法类似还是重写一次,方便后面各自修改
        new_mouse_flows = []
        mouse_timestamp = []
        temp_mouse = {}
        for action in self.mouse_flows:
            time_stamp = action[0]
            btn_series = action[1].split('|')

            btn = btn_series[-1]  # 键位名称

            is_release = 'release' in btn_series
            is_consider = btn in ImportantOperation.CONSIDERED_MOUSE_SET.value
            is_temporarily_catch = btn in temp_mouse.keys()

            if (not is_temporarily_catch) and is_consider and (not is_release):
                temp_mouse[btn] = time_stamp  # 按下按键

            if is_temporarily_catch and is_consider and is_release:
                delta_time = time_stamp - temp_mouse[btn]  # 释放按键, 时间差

                if delta_time > ImportantOperation.LONG_PRESS_THRESHOLD.value:  # 长按或短按
                    new_mouse_flows.append(({'op_name': btn,  # 需结合状态判定最终状态
                                                'way': ImportantOperation.LONG_PRESS.value,
                                                'press': round(delta_time, 1)}))
                else:
                    new_mouse_flows.append(({'op_name': btn,
                                                'way': ImportantOperation.SHORT_PRESS.value}))

                mouse_timestamp.append(temp_mouse[btn])

                temp_mouse.pop(btn)

        return new_mouse_flows, mouse_timestamp

    def status_pre_process(self):
        # 状态预处理
        status_template = {'timestamp': 0,
                            '代理人顺序': [],
                            BattleStateEnum.STATUS_SPECIAL_READY.value: 0,
                            BattleStateEnum.STATUS_ULTIMATE_READY.value: 0,
                            BattleStateEnum.STATUS_QUICK_ASSIST_READY.value: 0,
                            BattleStateEnum.STATUS_CHAIN_READY.value: 0,
                            '闪避状态': 0}

        new_status_flows = []

        for status in self.status_flows:
            time_stamp = status[0]
            details = status[1]

            agent_info = details['代理人顺序']

            updated_status = status_template.copy()

            if agent_info is None: # 可能出现连携动作, 更新至上一次识别状态
                # 连携技
                if details[BattleStateEnum.STATUS_CHAIN_READY.value] is not None:
                    new_status_flows[-1][BattleStateEnum.STATUS_CHAIN_READY.value] = \
                        [agent[0].split('-')[-1] for agent in details[BattleStateEnum.STATUS_CHAIN_READY.value]]

            else:  # 正常更新
                updated_status['代理人顺序'] = [agent.split('-')[-1] for agent in agent_info[0]]

                # 特殊技能
                if details[BattleStateEnum.STATUS_SPECIAL_READY.value] is not None:
                    updated_status[BattleStateEnum.STATUS_SPECIAL_READY.value] = 1
                else:
                    updated_status[BattleStateEnum.STATUS_SPECIAL_READY.value] = 0

                # 终结技能
                if details[BattleStateEnum.STATUS_ULTIMATE_READY.value] is not None:
                    updated_status[BattleStateEnum.STATUS_ULTIMATE_READY.value] = 1
                else:
                    updated_status[BattleStateEnum.STATUS_ULTIMATE_READY.value] = 0

                # 快速支援
                if details[BattleStateEnum.STATUS_QUICK_ASSIST_READY.value] is not None:
                    updated_status[BattleStateEnum.STA


         const domNode = this._getDomNode(hexagon.cellCoordinates);
            if (relativeValueHexagon) {
                const domNode = this._getDomNode(hexagon.cellCoordinates);
                domNode.dataset.value = `${relativeValueHexagon.value}`;
            } else {
                domNode.dataset.value = '0';
            }
        });
    };

    updateHexagonsPosition = (
        hexagons: IValueCanvasHexagon[]
    ): Promise<unknown> => {
        this.valueHexagons = hexagons;
        return Promise.all(
            this.valueHexagons.map((hex) =>
                this.moveHexagon(hex, hex.cellCoordinates)
            )
        );
    };
}
import { Client, Message, Role, User } from "discord.js";
import { MiddlewareManager } from "../../middleware";
import { formatString, notEmpty } from "../../utils";
import { Stagiaire } from "../stagiaire";
import { Channel, PlantChannel, PotionChannel } from "./channels";
import { HelpMiddleware } from "./middlewares/help";
import { ListMiddleware } from "./middlewares/list";
import { RollMiddleware } from "./middlewares/roll";

export class MessageContext {
  static readonly middlewares = new MiddlewareManager<MessageContext>()
    .use(HelpMiddleware)
    .use(ListMiddleware)
    .use(RollMiddleware);

  private readonly _message: Message;
  readonly channel: Channel;
  get author() {
    return this._message.author;
  }
  get message() {
    return this._message.content;
  }

  constructor(
    readonly stagiaire: Stagiaire,
    readonly client: Client,
    readonly config: Stagiaire["config"],
    message: Message
  ) {
    this._message = message;
    const channel = this.getItemChannel();
    if (channel) this.channel = channel;
  }

  private getItemChannel() {
    switch (this._message.channel.id) {
      case this.config.triggers.plants.chanPlayers:
        return new PlantChannel(this);
      case this.config.triggers.potions.chanPlayers:
        return new PotionChannel(this);
    }
  }

  isBotMentioned() {
    const botIds = [
      this.client.users.cache.get(this.config.tagBotId),
      ...this.config.tagBotRoles.map((id) => this._message.guild?.roles.cache.get(id)),
    ].filter(notEmpty);
    const isMentioned = (data: User | Role) => this._message.mentions.has(data, { ignoreEveryone: true });
    return this.author.id !== this.config.tagBotId && botIds.some(isMentioned);
  }

  process() {
    if (!this.channel) {
      return this.writeError(
        formatString(this.config.messages.errors.wrongChannel, {
          plantChannel: this.stagiaire.getDiscordChannel("plants"),
          potionChannel: this.stagiaire.getDiscordChannel("potions"),
        })
      );
    }
    return MessageContext.middlewares.invoke(this, () => this.writeError(this.config.messages.errors.wrongSyntax));
  }

  sendBasic(content: string) {
    return this._message.channel.send(content);
  }

  async sendMessage(content: string, error: boolean, ping: boolean) {
    const finalContent = [content];
    if (ping) finalContent.push(`${this.author}`);
    await this.sendBasic(finalContent.join("\n"));
    await this._message.react(error ? "💩" : "👌");
  }

  writeError(errorMessage: string) {
    this.stagiaire.error(`Reply "${errorMessage}" to "${this.message}" from ${this.author.tag}`);
    return this.sendMessage(errorMessage, true, true);
  }
}
import { IncomingMessage, ServerResponse } from 'node:http'

export function readJson<T>(req: IncomingMessage): Promise<T> {
  return new Promise<T>((resolve, reject) => {
    let rawData = ''
    req.on('data', (chunk) => {
      rawData += chunk
    })


local QBCore = exports['qb-core']:GetCoreObject()

local function showCDU(data)
     if not data then return end
     local state = ''
     if data.metadata.state == true then
          state = 'Active'
     else
          state = 'inactive'
     end
     local header = "Crude oil distillation unit (" .. state .. ')'
     -- header
     local CDU_Temperature = data.metadata.temp
     local CDU_Gal = data.metadata.oil_storage
     local openMenu = {
          {
               header = header,
               isMenuHeader = true,
               icon = 'fa-solid fa-gear'
          }, {
               header = 'Temperature',
               icon = 'fa-solid fa-temperature-high',
               txt = "" .. CDU_Temperature .. " °C",
          },
          {
               header = 'Curde Oil inside CDU',
               icon = 'fa-solid fa-oil-can',
               txt = CDU_Gal .. " Gallons",
          },
          {
               header = 'Pump Curde Oil to CDU',
               icon = 'fa-solid fa-arrows-spin',
               params = {
                    event = "keep-oilrig:CDU_menu:pumpCrudeOil_to_CDU"
               }
          },
          {
               header = 'Change Temperature',
               icon = 'fa-solid fa-temperature-arrow-up',
               params = {
                    event = "keep-oilrig:CDU_menu:set_CDU_temp"
               }
          },
          {
               header = 'Toggle CDU',
               icon = 'fa-solid fa-sliders',
               params = {
                    event = "keep-oilrig:CDU_menu:switchPower_of_CDU"
               }
          },
          {
               header = 'leave',
               icon = 'fa-solid fa-circle-xmark',
               params = {
                    event = "qb-menu:closeMenu"
               }
          }
     }
     exports['qb-menu']:openMenu(openMenu)
end

AddEventHandler('keep-oilrig:CDU_menu:Sho


--DOC_HIDE_ALL
--DOC_GEN_IMAGE
local placement = require("awful.placement")
require("awful.tag").add("1", {screen=screen[1], selected=true}) --DOC_HIDE
screen[1]._resize {x= 50}
for _, pos in ipairs{
    "top_left", "top_right", "bottom_left", "bottom_right",
    "left", "right", "top", "bottom", "centered",
} do
local c1 = client.gen_fake {x = 80, y = 55, width=75, height=50}
c1:_hide_all()
placement.align(client.focus, {position = pos, honor_workarea=true})
c1:set_label(pos)
end

screen._add_screen {x = 70, y = 260  , width = 128, height = 96}
screen._add_screen {x = 210, y = 260  , width = 128, height = 96}
require("awful.tag").


ation.end(); itr++) {
                    if (itr->first != mostFrequentDuration) {
                        otherDuration = itr->first;
                        break;
                    }
                }
                m_ptsOffset = ptsOffsetMax + otherDuration;
            }
        } else {
            // ptsOffsetOrigが必要offsetの最小値(ptsOffsetMax)より大きく、そのずれが2フレーム以内ならそれを採用する
            // そうでなければ、ptsOffsetMaxに1フレーム分の時間を足した時刻にする
            m_ptsOffset = (m_firstPts < 0) ? 0 :
                ((ptsOffsetOrig - ptsOffsetMax > 0 && ptsOffsetOrig - ptsOffsetMax <= rational_rescale(2, m_encFps.inv(), m_outputTimebase))
                    ? ptsOffsetOrig : (ptsOffsetMax + rational_rescale(1, m_encFps.inv(), m_outputTimebase)));
        }
        m_encFrameOffset = (m_currentChunk > 0) ? m_maxEncFrameIdx + 1 : 0;
        m_inputFrameOffset = (m_currentChunk > 0) ? m_maxInputFrameIdx + 1 : 0;
        PrintMes(m_tsDebug ? RGY_LOG_ERROR : RGY_LOG_TRACE, _T("Switch to next file: pts offset %lld, frame offset %d.\n")
            _T("  firstKeyPts 0: % lld, %d : % lld.\n")
            _T("  ptsOffsetOrig: %lld, ptsOffsetMax: %lld, m_maxPts: %lld\n"),
            m_ptsOffset, m_encFrameOffset,
            m_firstPts, m_currentChunk, rational_rescale(m_parallelEnc->getVideofirstKeyPts(m_currentChunk), srcTimebase, m_outputTimebase),
            ptsOffsetOrig, ptsOffsetMax, m_maxPts);
        return RGY_ERR_NONE;
    }

    void updateAndSetHeaderProperties(RGYBitstream *bsOut, RGYOutputRawPEExtHeader *header) {
        header->pts += m_ptsOffset;
        header->dts += m_ptsOffset;
        header->encodeFrameIdx += m_encFrameOffset;
        header->inputFrameIdx += m_inputFrameOffset;
        bsOut->setPts(header->pts);
        bsOut->setDts(header->dts);
        bsOut->setDuration(header->duration);
        bsOut->setFrametype(header->frameType);
        bsOut->setPicstruct(header->picstruct);
        bsOut->setFrameIdx((int)header->encodeFrameIdx);
        bsOut->setDataflag((RGY_FRAME_FLAGS)header->flags);
    }

    RGY_ERR getBitstreamOneFrameFromQueue(RGYBitstream *bsOut, RGYOutputRawPEExtHeader& header) {
        RGYOutputRawPEExtHeader *packet = nullptr;
        auto err = m_parallelEnc->getNextPacket(m_currentChunk, &packet);
        if (err != RGY_ERR_NONE) {
            return err;
        }
        if (packet == nullptr) {
            return RGY_ERR_UNDEFINED_BEHAVIOR;
        }
        updateAndSetHeaderProperties(bsOut, packet);
        if (packet->size <= 0) {
            return RGY_ERR_UNDEFINED_BEHAVIOR;
        } else {
            bsOut->resize(packet->size);
            memcpy(&header, packet, sizeof(header));
            memcpy(bsOut->data(), (void *)(packet + 1), packet->size);
        }
        // メモリを使いまわすため、使い終わったパケットを回収する
        m_parallelEnc->putFreePacket(m_currentChunk, packet);
        PrintMes(RGY_LOG_TRACE, _T("Q: pts %08lld, dts %08lld, size %d.\n"), bsOut->pts(), bsOut->dts(), bsOut->size());
        return RGY_ERR_NONE;
    }

    RGY_ERR getBitstreamOneFrameFromFile(FILE *fp, RGYBitstream *bsOut, RGYOutputRawPEExtHeader& header) {
        if (fread(&header, 1, sizeof(header), fp) != sizeof(header)) {
            return RGY_ERR_MORE_BITSTREAM;
        }
        if (header.size <= 0) {
            return RGY_ERR_UNDEFINED_BEHAVIOR;
        }
        updateAndSetHeaderProperties(bsOut, &header);
        bsOut->resize(header.size);
        PrintMes(RGY_LOG_TRACE, _T("F: pts %08lld, dts %08lld, size %d.\n"), bsOut->pts(), bsOut->dts(), bsOut->size());

        if (fread(bsOut->data(), 1, bsOut->size(), fp) != bsOut->size()) {
            return RGY_ERR_UNDEFINED_BEHAVIOR;
        }
        return RGY_ERR_NONE;
    }

    RGY_ERR getBitstreamOneFrame(RGYBitstream *bsOut, RGYOutputRawPEExtHeader& header) {
        return (m_parallelEnc->cacheMode(m_currentChunk) == RGYParamParallelEncCache::File)
            ? getBitstreamOneFrameFromFile(m_fReader.get(), bsOut, header)
            : getBitstreamOneFrameFromQueue(bsOut, header);
    }

    virtual RGY_ERR getBitstream(RGYBitstream *bsOut, RGYOutputRawPEExtHeader& header) {
        if (m_currentChunk < 0) {
            if (auto err = openNextFile(); err != RGY_ERR_NONE) {
                return err;
            }
        } else if (m_currentChunk >= (int)m_parallelEnc->parallelCount()) {
            return RGY_ERR_MORE_BITSTREAM;
        }
        auto err = getBitstreamOneFrame(bsOut, header);
        if (err == RGY_ERR_MORE_BITSTREAM) {


ur browser, you were logged out of MetaMask— this is by design. Your device can fall into the wrong hands, but unless they know your password for MetaMask, your private key, or your mnemonic phrase, they can’t do anything. They can’t even get your private key or mnemonic phrase from MetaMask because they need your password!

But wait, there’s more! The only reason why you will ever need to use your private key or mnemonic phrase is if you’re importing accounts from other wallets. You don’t use it often like regular credentials and are encouraged to store it in some place like a safety deposit box, *(or entombed in concrete)*. In the meantime, here’s what your junk mailbox can get filled with.

![https://dev-to-uploads.s3.amazonaws.com/uploads/articles/srpl360r83f2craj9wrh.png](../../img/S04/../../../img/S04/persisting-connectivity-inbox.png)

*Benny Hill theme intensifies*
{target=\_blank}

By default, you’ll always be connected because you didn’t need to verify your identity for authentication. The mere fact that your account was generated from a number so large that it could not be manmade is proof enough that your account is authentic. The reason why you stay connected is that you granted this dApp permission to view your accounts, and your assets and suggest transactions on your behalf. Restarting your browser, clearing your session, and clearing your cookies and cache doesn’t disconnect you. Because MetaMask and other browser wallets act as this bridge between you and dApps, it supplies the functionality for dApps to check if you have granted permissions with your account with the Ethereum Provider API.

Malicious actors can then fork popular protocols and spin up their own versions and deceive you into thinking you might be interacting with the real protocol, but you’re greeted with a new user flow as if permissions only you could grant and revoke were automatically granted and revoked for you, without your explicit consent.

This is why connectivity and permissions in Web3.0 is a paradigm shift from traditional authentication flows in Web2.0.

## Showing your user’s connectivity

To display this persistent connectivity with React, we’ll need to make a few more tweaks. For this, we can use the [Effect](https://reactjs.org/docs/hooks-effect.html){target=\_blank} hook. React components are dynamic because of their ability to go through different [lifecycles](https://reactjs.org/docs/state-and-lifecycle.html#adding-lifecycle-methods-to-a-class){target=\_blank}. You'll commonly see the phrase "side effect" used in explanations for `useEffect`, so a side effect of the Ethereum Provider API being present in the `window` results in either the ‘Connect’ button or the ‘Address’ component being rendered.

In `App.js` you’ll see we’re already importing `useEffect` from React. Now we can define it right beneath our `useState` hook like this:

```jsx
useEffect(() => {
  // Callback function
}, []) // Dependency array
```

Logic can fire off in a component where we’re using `useEffect` and it can change state, and ultimately how our components and our app look. That array is where you have a variable that needs to change before the callback function can fire off. So perhaps we’re waiting on something to exist, like say… an Ethereum provider, we can then fire off a callback function in our `useEffect` to show the address that a user has connected with.

First, you’ll need to destructure the `window` object to unpack the `ethereum` property and define it as its own variable like this:

```jsx
const { ethereum } = window
```

And then let’s quickly change wherever we have `window.ethereum`  to `ethereum`, like in our connect function:

```jsx
const accounts = (
  await ethereum.request({ method: "eth_request


('BuildTool arguments: $args');
    }
    log.severe(kDoubleSeparator);
    exit(1);
  }
}
/// This is copied from Cargokit (which is the official way to use it currently)
/// Details: https://fzyzcjy.github.io/flutter_rust_bridge/manual/integrate/builtin

import 'dart:io';

extension on String {
  String resolveSymlink() => File(this).resolveSymbolicLinksSync();
}

class Environment {
  /// Current build configuration (debug or release).
  static String get configuration =>
      _getEnv("CARGOKIT_CONFIGURATION").toLowerCase();

  static bool get isDebug => configuration == 'debug';
  static bool get isRelease => configuration == 'release';

  /// Temporary directory where Rust build artifacts are placed.
  static String get targetTempDir => _getEnv("CARGOKIT_TARGET_TEMP_DIR");

  /// Final output directory where the build artifacts are placed.
  static String get outputDir => _getEnvPath('CARGOKIT_OUTPUT_DIR');

  /// Path to the crate manifest (containing Cargo.toml).
  static String get manifestDir => _getEnvPath('CARGOKIT_MANIFEST_DIR');

  /// Directory inside root project. Not necessarily root folder. Symlinks are
  /// not resolved on purpose.
  static String get rootProjectDir => _getEnv('CARGOKIT_ROOT_PROJECT_DIR');

  // Pod

  /// Platform name (macosx, iphoneos, iphonesimulator).
  static String get darwinPlatformName =>
      _getEnv("CARGOKIT_DARWIN_PLATFORM_NAME");

  /// List of architectures to build for (arm64, armv7, x86_64).
  static List<String> get darwinArchs =>
      _getEnv("CARGOKIT_DARWIN_ARCHS").split(' ');

  // Gradle
  static String get minSdkVersion => _getEnv("CARGOKIT_MIN_SDK_VERSION");
  static String get ndkVersion => _getEnv("CARGOKIT_NDK_VERSION");
  static String get sdkPath => _getEnvPath("CARGOKIT_SDK_DIR");
  static String get javaHome => _getEnvPath("CARGOKIT_JAVA_HOME");
  static List<String> get targetPlatforms =>
      _getEnv("CARGOKIT_TARGET_PLATFORMS").split(',');

  // CMAKE
  static String get targetPlatform => _getEnv("CARGOKIT_TARGET_PLATFORM");

  static String _getEnv(String key) {
    final res = Platform.environment[key];
    if (res == null) {
      throw Exception("Missing environment variable $key");
    }
    return res;
  }

  static String _getEnvPath(String key) {
    final res = _getEnv(key);
    if (Directory(res).existsSync()) {
      return res.resolveSymlink();
    } else {
      return res;
    }
  }
}
export 'package:commander_ui/src/application/components/ask.dart';
export 'package:commander_ui/src/application/components/checkbox.dart';
export 'package:commander_ui/src/application/components/screen.dart';
export 'package:commander_ui/src/application/components/select.dart';
export 'package:commander_ui/src/application/components/swap.dart';
export 'package:commander_ui/src/application/components/table.dart';
export 'package:commander_ui/src/application/components/task.dart';
export 'package:commander_ui/src/application/themes/default_ask_theme.dart';
export 'package:commander_ui/src/application/themes/default_checkbox_theme.dart';
export 'package:commander_ui/src/application/themes/default_select_theme.dart';
export 'package:commander_ui/src/application/themes/default_swap_theme.dart';
export 'package:co


icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg viewBox='0 0 20 20' xmlns='http://www.w3.org/2000/svg' fill='%23000'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1zm0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7z'/%3E%3Ccircle id='dot' cx='10' cy='10' r='2'/%3E%3Cpath id='stroke' d='M14 5l1 1-9 9-1-1 9-9z' display='none'/%3E%3C/svg%3E")}.mapboxgl-ctrl button.mapboxgl-ctrl-geolocate:disabled .mapboxgl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg viewBox='0 0 20 20' xmlns='http://www.w3.org/2000/svg' fill='%23666'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1zm0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7z'/%3E%3Ccircle id='dot' cx='10' cy='10' r='2'/%3E%3Cpath id='stroke' d='M14 5l1 1-9 9-1-1 9-9z' fill='%23f00'/%3E%3C/svg%3E")}}@keyframes mapboxgl-spin{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}a.mapboxgl-ctrl-logo{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' fill-rule='evenodd' viewBox='0 0 88 23'%3E%3Cdefs%3E%3Cpath id='logo' d='M11.5 2.25c5.105 0 9.25 4.145 9.25 9.25s-4.145 9.25-9.25 9.25-9.25-4.145-9.25-9.25 4.145-9.25 9.25-9.25zM6.997 15.983c-.051-.338-.828-5.802 2.233-8.873a4.395 4.395 0 013.13-1.28c1.27 0 2.49.51 3.39 1.42.91.9 1.42 2.12 1.42 3.39 0 1.18-.449 2.301-1.28 3.13C12.72 16.93 7 16 7 16l-.003-.017zM1


	{	fn fmt(&self, out: &mut std::fmt::Formatter) -> std::fmt::Result
				{	nop_json::DebugToJson::fmt(self, out)
				}
			}
		};
	}
	else
	{	// get generic parameters of this type (like struct<T> {...})
		let mut generics = mem::take(&mut ast.generics);
		let (impl_generics, ty_generics, where_clause) = get_generics_write_to_json(&mut generics);
		// impl WriteToJson
		code = quote!
		{	impl #impl_generics nop_json::WriteToJson<WriteToJsonPriv1> for #name #ty_generics #where_clause
			{	fn write_to_json(&self, out: &mut WriteToJsonPriv1) -> std::io::Result<()>
				{	#code
				}
			}
		};
	}
	// to see what i produced, uncomment the panic!() below, and try to compile your code with #[derive(DebugToJson)]
//panic!(code.to_string());
	// done
	Ok(code.into())
}

fn get_json_name(attrs: &Vec<Attribute>, what: &str) -> Result<Option<String>, String>
{	let mut result = parse_json_attr(attrs, 0, None)?;
	if result.0.is_some()
	{	return Err(format!("Cannot parse #[json(...)] for {}", what));
	}
	if result.1.len() > 1
	{	return Err(format!("#[json(...)] for {} must contain 1 field name", what));
	}
	Ok(result.1.pop())
}

fn get_json_name_for_enum_variant(attrs: &Vec<Attribute>, variant_name: &Ident, n_fields: usize) -> Result<(Option<String>, Vec<String>), String>
{	parse_json_attr(attrs, n_fields, Some(variant_name))
}

fn parse_json_attr(attrs: &Vec<Attribute>, n_fields: usize, variant_name: Option<&Ident>) -> Result<(Option<String>, Vec<String>), String>
{	parse_json_attr_sub(attrs, n_fields, variant_name.is_some()).map_err
	(	|e|
		if let Some(variant_name) = variant_name
		{	format!("Cannot parse #[json(...)] in enum variant {}{}{}", variant_name, if e.is_empty() {""} else {": "}, e)
		}
		else
		{	format!("Cannot parse #[json(...)]{}{}", if e.is_empty() {""} else {": "}, e)
		}
	)
}

fn parse_json_attr_sub(attrs: &Vec<Attribute>, n_fields: usize, is_enum: bool) -> Result<(Option<String>, Vec<String>), String>
{	let mut group_name = None;
	let mut json_names = Vec::new();
	let mut is_var_str = false;
	for a in attrs
	{	match a.parse_meta()
		{	Ok(Meta::List(list)) =>
			{	if list.path.is_ident("json")
				{	for a in list.nested
					{	match a
						{	NestedMeta::Lit(Lit::Str(s)) =>
							{	if group_name.is_some() && !is_var_str
								{	return Err("Couldn't interpret #[json] attribute".to_string());
								}
								json_names.push(s.value());
							},
							NestedMeta::Meta(Meta::Path(meta)) =>
							{	if group_name.is_some() && !is_var_str
								{	return Err("Couldn't interpret #[json] attribute".to_string());
								}
								if let Some(name) = meta.get_ident()
								{	json_names.push(name.to_string());
								}
							},
							NestedMeta::Meta(Meta::List(list)) =>
							{	if is_enum
								{	if json_names.len() > 0
									{	return Err(


github.com/bitcoindevkit/bdk/issues?q=is%3Aissue+is%3Aopen+created%3A2022-10-01..2022-10-31%20-author:app/dependabot
[bdk-open_issues-2]: https://github.com/bitcoindevkit/bdk-cli/issues?q=is%3Aissue+is%3Aopen+created%3A2022-10-01..2022-10-31%20-author:app/dependabot
[bdk-open_issues-3]: https://github.com/bitcoindevkit/bdk-ffi/issues?q=is%3Aissue+is%3Aopen+created%3A2022-10-01..2022-10-31%20-author:app/dependabot
[bdk-open_issues-4]: https://github.com/bitcoindevkit/rust-electrum-client/issues?q=is%3Aissue+is%3Aopen+created%3A2022-10-01..2022-10-31%20-author:app/dependabot

#### [BitMask](https://github.com/diba-io/bitmask-core)

7 merged PRs ([1][bitmask-merged-prs-1]),
2 closed issues ([1][bitmask-closed_issues-1]),
6 open issues ([1][bitmask-open_issues-1])

[bitmask-merged-prs-1]: https://github.com/diba-io/bitmask-core/pulls?q=is%3Apr+is%3Aclosed+merged%3A2022-10-01..2022-10-31%20-author:app/dependabot
[bitmask-closed_issues-1]: https://github.com/diba-io/bitmask-core/issues?q=is%3Aissue+is%3Aclosed+closed%3A2022-10-01..2022-10-31%20-author:app/dependabot
[bitmask-open_issues-1]: https://github.com/diba-io/bitmask-core/issues?q=is%3Aissue+is%3Aopen+created%3A2022-10-01..2022-10-31%20-author:app/dependabot

#### [Fedimint](https://github.com/fedimint)

77 merged PRs ([1][fedimint-merged-prs-1]),
11 closed issues ([1][fedimint-closed_issues-1]),
25 open issues ([1][fedimint-open_issues-1])

[fedimint-merged-prs-1]: https://github.com/fedimint/fedimint/pulls?q=is%3Apr+is%3Aclosed+merged%3A2022-10-01..2022-10-30%20-author:app/dependabot
[fedimint-closed_issues-1]: https://github.com/fedimint/fedimint/issues?q=is%3Aissue+is%3Aclosed+closed%3A2022-10-01..2022-10-30%20-author:app/dependabot
[fedimint-open_issues-1]: https://github.com/fedimint/fedimint/issues?q=is%3Aissue+is%3Aopen+created%3A2022-10-01..2022-10-30%20-author:app/dependabot

Fedimint is a Bitcoin banking protocol. Highlights from the last month include:
- [Distributed key generation so federation setup has no single point of failure](https://github.com/fedimint/fedimint/pull/600)
- [Modularization so that developers don't have to fork the repo to modify functionality](https://github.com/fedimint/fedimint/issues/673)
- [Proper database transactions](https://github.com/fedimint/fedimint/pull/791)
- [Improved connection to Lighting Network](https://github.com/fedimint/fedimint/pull/709)
- [Deriving our anonymous IOUs from


,
    ) -> Result<Option<(Bytes, Bytes)>, Box<dyn Error + '_>> {
        let hidden_key = HiddenKey::new(&key);
        let shard = &self.0.data[hidden_key.shard()];

        if let Some(kv_pair) = shard.read()?.get(&hidden_key) {
            Ok(Some((kv_pair.key.clone(), kv_pair.value.clone())))
        } else {
            Ok(None)
        }
    }

    /// Sets key to value, overwriting any previous value. Providing an optional `expiry`
    /// time treats the key/value pair as perishable.
    pub fn set(
        &mut self,
        key: &[u8],
        val: &[u8],
        expiry: Option<Instant>,
    ) -> Result<(), Box<dyn Error + '_>> {
        // willing to take the hit allocating on insertion
        let key = key.to_vec();
        let hidden_key = HiddenKey::new(&key);
        let value = val.to_vec();

        let kv_pair = KeyValuePair { key, value, expiry };

        if let Some(time) = expiry {
            self.0
                .expiry_times
                .write()?
                .entry(time)
                .or_insert_with(|| vec![hidden_key]);
        }

        {
            let shard = hidden_key.shard();
            let _ = self.0.data[shard].write()?.insert(hidden_key, kv_pair);
        }

        Ok(())
    }

    pub fn update(
        &mut self,
        key: &[u8],
        val: &[u8],
        expiry: Option<Instant>,
    ) -> Result<(), Box<dyn Error + '_>> {
        self.set(key, val, expiry)?;
        Ok(())
    }

    /// Removes the key/value pair from the store.
    pub fn remove(&mut self, key: &[u8]) -> Result<(), Box<dyn Error + '_>> {
        let hidden_key = HiddenKey::new(&key);

        let mut expiry = None;
        {
            let shard = &self.0.data[hidden_key.shard()];
            let mut lock = shard.write()?;
            if let Some(kv_pair) = lock.get_mut(&hidden_key) {
                expiry = kv_pair.expiry.clone(); // copying out of this scope to avoid deadlock
                lock.remove(&hidden_key);
            }
        }

        if let Some(expiry) = expiry {
            if let Some(keys) = self.0.expiry_times.write()?.get_mut(&expiry) {
                keys.retain(|&x| x != hidden_key);
            }
        }

        Ok(())
    }

    /// Remove any expired perishable items from the store
    pub fn evict(&mut self) -> Result<(), Box<dyn Error + '_>> {
        let now = Instant::now();

        let mut times_to_remove = vec![];
        let mut items_to_remove: Vec<HiddenKey> = vec![];

        for (expiry, items) in self.0.expiry_times.read()?.range(self.0.created_at..now) {
            // Avoid deleting things while holding the read lock - potential deadlock
            times_to_remove.push(expiry.clone());
            items_to_remove.extend(items);
        }

        for item in &items_to_remove {
            self.0.data[item.shard()].write()?.remove(&item);
        }
        for expiry in &times_to_remove {
            &mut self.0.expiry_times.write()?.remove(expiry);
        }

        Ok(())
    }
}

// /// C API.. in a pretty bad state

// /// Indicates that the function returned successfully
// pub const CNR_OK: isize = 0;

//