 paramIndex ) )
			{
				value = resultRow.getDecimal( resultMap( paramIndex ) );
				null_param = resultRow.wasNull();
			}
			else  if ( ! rslt_proc_val )
				null_param = true;
			else
			{
				value = Convert.ToDecimal( rslt_val_proc );
				null_param = false;
			}

			if ( trace.enabled() )  trace.log( title + ".getDecimal: " + value );
			return( value );
		} // getDecimal

		/*
		** Name: getDecimal
		**
		** Description:
		**	Retrieve parameter data as a Decimal value.  If the parameter
		**	is NULL, null is returned.
		**
		** Input:
		**	parameterName	Parameter name.
		**
		** Output:
		**	None.
		**
		** Returns:
		**	Decimal	Parameter numeric value.
		**
		** History:
		**	28-Feb-03 (gordy)
		**	    Created.
		**	 2-Jul-03 (gordy)
		**	    Don't rely on parameter names in result-set, map names
		**	    using loaded/registered parameter names and result map.
		*/

		public Decimal
			getDecimal( String parameterName )
		{
			if ( trace.enabled() )
				trace.log( title + ".getDecimal('" + parameterName + "')" );

			Decimal value = resultRow.getDecimal( resultMap( parameterName ) );
			null_param = resultRow.wasNull();

			if ( trace.enabled() )  trace.log( title + ".getDecimal: " + value );
			return( value );
		} // getDecimal

		/*
		** Name: getString
		**
		** Description:
		**	Retrieve parameter data as a String value.  If the parameter
		**	is NULL, null is returned.
		**
		** Input:
		**	paramIndex	Parameter index.
		**
		** Output:
		**	None.
		**
		** Returns:
		**	String		Parameter string value.
		**
		** History:
		**	19-May-99 (gordy)
		**	    Created.
		**	25-Aug-00 (gordy)
		**	    Implemented.
		*/

		public String
			getString( int paramIndex )
		{
			String  value = null;

			if ( trace.enabled() )
				trace.log( title + ".getString( " + paramIndex + " )" );

			if ( ! isProcRslt( paramIndex ) )
			{
				value = resultRow.getString( resultMap( paramIndex ) );
				null_param = resultRow.wasNull();
			}
			else  if ( ! rslt_proc_val )
				null_param = true;
			else
			{
				value = rslt_val_proc.ToString();
				if ( rs_max_len > 0  &&  value.Length > rs_max_len )
					value = value.Substring( 0, rs_max_len );
				null_param = false;
			}

			if ( trace.enabled() )  trace.log( title + ".getString: " + value );
			return( value );
		} // getString

		/*
		** Name: getString
		**
		** Description:
		**	Retrieve parameter data as a String value.  If the parameter
		**	is NULL, null is returned.
		**
		** Input:
		**	parameterName	Parameter name.
		**
		** Output:
		**	None.
		**
		** Returns:
		**	String		Parameter string value.
		**
		** History:
		**	28-Feb-03 (gordy)
		**	    Created.
		**	 2-Jul-03 (gordy)
		**	    Don't rely on parameter names in result-set, map names
		**	    using loaded/registered parameter names and result map.
		*/

		public String
			getString( String parameterName )
		{
			if


 = time.time()
    return [[end - start]]

def multithread_rpc(thraed, batch_size):
    multi_thread_runner = MultiThreadRunner()
    result = multi_thread_runner.run(run_rpc, thread, batch_size)

if __name__ == "__main__":
    if sys.argv[1] == "yaml":
        mode = sys.argv[2]  # brpc/  local predictor
        thread = int(sys.argv[3])
        device = sys.argv[4]
        gen_yml(device)
    elif sys.argv[1] == "run":
        mode = sys.argv[2]  # http/ rpc
        thread = int(sys.argv[3])
        batch_size = int(sys.argv[4])
        if mode == "http":
            multithread_http(thread, batch_size)
        elif mode == "rpc":
            multithread_rpc(thread, batch_size)
    elif sys.argv[1] == "dump":
        filein = sys.argv[2]
        fileout = sys.argv[3]
        parse_benchmark(filein, fileout)


  var element$macro$6 = $as_Lscalatags_JsDom$TypedTag($m_Lcom_thoughtworks_binding_dom$Runtime$TagsAndTags2$().input__Lscalatags_generic_TypedTag()).apply__sc_Seq__Lscalatags_JsDom$TypedTag($m_sci_Nil$()).render__Lorg_scalajs_dom_raw_Element();
  var this$6 = this.$$outer$2.$$outer$2.partialAppliedMonadic$macro$148$1$f.typeClass$1;
  var this$4 = this.$$outer$2.$$outer$2.partialAppliedMonadic$macro$148$1$f.typeClass$1;
  var partialAppliedMonadic$macro$128 = $m_Lcom_thoughtworks_binding_Binding$();
  var fa = new $c_Lcom_thoughtworks_binding_Binding$Constant().init___O(new $c_Lcom_thoughtworks_binding_Binding$Constant().init___O(new $c_Lcom_thoughtworks_binding_Binding$Constant().init___O(this.$$outer$2.$$outer$2.keyDownHandler$1$f)));
  if ((this$4 === null)) {
    throw $m_sjsr_package$().unwrapJavaScriptException__jl_Throwable__O(null)
  };
  var x2 = fa.get$1;
  var element$macro$155 = $as_Lcom_thoughtworks_binding_Binding(x2);
  var this$5 = partialAppliedMonadic$macro$132.typeClass$1;
  var f = new $c_sjsr_AnonFunction1().init___sjs_js_Function1((function(element$macro$133$2) {
    var element$macro$133 = $as_Lcom_thoughtworks_binding_Binding(element$macro$133$2);
    return element$macro$133
  }));
  var fa$1 = new $c_Lcom_thoughtworks_binding_Binding$Constant().init___O($as_Lcom_thoughtworks_binding_Binding($s_Lscalaz_Monad$class__map__Lscalaz_Monad__O__F1__O(this$5, element$macro$155, f)));
  var f$1 = new $c_Lcom_thoughtworks_todo_Main$$anonfun$header$2$$anonfun$apply$31$$anonfun$apply$34$$anonfun$apply$40().init___Lcom_thoughtworks_todo_Main$$anonfun$header$2$$anonfun$apply$31$$anonfun$apply$34__Lcom_thoughtworks_binding_Binding$__Lorg_scalajs_dom_raw_HTMLInputElement(this, partialAppliedMonadic$macro$132, element$macro$6);
  var fa$2 = $s_Lscalaz_Monad$class__map__Lscalaz_Monad__O__F1__O(this$6, fa$1, f$1);
  var f$2 = new $c_Lcom_thoughtworks_todo_Main$$anonfun$header$2$$anonfun$apply$31$$anonfun$apply$34$$anonfun$apply$61().init___Lcom_thoughtworks_todo_Main$$anonfun$header$2$$anonfun$apply$31$$anonfun$apply$34__Lcom_thoughtworks_binding_Binding$(this, partialAppliedMonadic$macro$132);
  return jsx$1.bind__Lcom_thoughtworks_binding_Binding__F1__Lcom_thoughtworks_binding_Binding($as_Lcom_thoughtworks_binding_Binding($s_Lscalaz_Monad$class__map__Lscalaz_Monad__O__F1__O(this$7, fa$2, f$2)), new $c_Lcom_thoughtworks_todo_Main$$anonfun$header$2$$anonfun$apply$31$$anonfun$apply$34$$anonfun$apply$63().init___Lcom_thoughtworks_todo_Main$$anonfun$header$2$$anonfun$apply$31$$anonfun$apply$34__Lcom_thoughtworks_binding_Binding(this, element$macro$154))
});
$c_Lc


de "moto.s" namespace "moto" isolated

        .section "main2" free keep
        call moto.barLabel
        .db helo.VALUE
        .ends

        .include "fileA.asm" namespace "foo" isolated

        .dstruct Instance2 instanceof foo.Instance DATA "tingle", 10, 11

        .ramsection "ram" slot 2
foo:      instanceof foo.Instance
        .ends

        .include "fileB.asm" namespace "yuh"

        yuh.DefineCockooInstance Cockoo1 1 2
        yuh.DefineCockooInstance Cockoo2 3 4

        .dstruct Cockoo3 instanceof Cockoo data 5 6


 function mapOfType<K, V>(keyType: Type<K>, valueType: Type<V>): Type<Map<K, V>> {
  return new MapOfType(keyType, valueType);
}
const needsEscapeRegEx = /[\n\r'\\\u2028\u2029]/;
const quoteNewlineRegEx = /([\n\r'\u2028\u2029])/g;
const backSlashRegEx = /\\/g;

export function escapeId(id: string): string {
	if (!needsEscapeRegEx.test(id)) return id;
	return id.replace(backSlashRegEx, '\\\\').replace(quoteNewlineRegEx, '\\$1');
}
import axios, { AxiosError } from "axios";
import { API_URL } from "../globals";

type Response = {
	code: number;
	success: boolean;
};

export type SuccessResponse = {
	data: unknown;
} & Response;

export type ErrorResponse = {
	error: {
		name?: unknown;
		message: string;
	};
} & Response;

async function get(path: string): Promise<SuccessResponse | ErrorResponse> {
	const url = API_URL + path;
	try {
		const res = await axios.get(url, { responseType: "json", withCredentials: true });

		return {
			code: res.status,
			success: true,
			data: <unknown>res.data,
		};
	} catch (error) {
		return {
			code: Number((<AxiosError>error).response?.status) || 500,
			success: false,
			error: {
				// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
				name: (<AxiosError>error).response?.data.error.name,
				// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
				message: (<AxiosError>error).response?.data.error.message || "An error occurred",
			},
		};
	}
}

async function post(path: string, body: unknown): Promise<SuccessResponse | ErrorResponse> {
	const url = API_URL + path;
	try {
		const res = await axios.post(url, body, { responseType: "json", withCredentials: true });

		return {
			code: res.status,
			success: true,
			data: <unknown>res.data,
		};
	} catch (error) {
		return {
			code: Number((<AxiosError>error).response?.status) || 500,
			success: false,
			error: {
				// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
				name: (<AxiosError>error).response?.data.error.name,
				// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
				message: (<AxiosError>error).response?.data.error.message || "An error occurred",
			},
		};
	}
}

export default { get, post };
import { Pipe, PipeTransform } from '@angular/core';
import {Network} from "../../../shared/networks/network";
import {NetworkHierarchy} from "../../../shared/networks/network-hierarchy";

@Pipe({ name: 'groupsPipe'})
export class GroupsPipe implements PipeTransform {
    transform(allGroups: NetworkHierarchy[], alreadyJoinedGroupIds: number[]) {
        if (!allGroups) {
            return allGroups.filter(group => {
                return !alreadyJoinedGroupIds.some((joinedGroupId) => joinedGroupId === group.network_id);
            });
            //return false;
        }
        return allGroups.filter(group => {
            return !group.hidden && !alreadyJoinedGroupIds.some((joinedGroupId) => joinedGroupId === group.network_id);
        });
    }
}
// export class GroupsPipe implements PipeTransform {
//     transform(allGroups: NetworkHierarchy[], searchText: string) {
//         let searchString = searchText.toLowerCase();
//         return allGroups.filter(group => {
//             if (group.network_name.toLowerCase().includes(searchString)) {
//                 return true;
//             } else if(


62.496-3.04-10.467 1.215-9.596 5.001-9.674 14.275-.292 39.349 3.469 89.997 15.755 30.157 7.315 96.533-.25 96.533-.25-63.839 26.034-140.95 1.396-162.1-.502-2.673-.24-4.137.25-4.999 6.04-1.487 18.14 3.245 43.462-4.632 56.541-16.136 26.791-47.111 37.286-76.496 41.975-23.57 3.761-65.534-7.662-88.008-24.572-18.59-13.987-23.82-36.607-20.811-76.975-24.572-4.764-50.67 4.992-58.526 6.767C35.456 235.14 0 222.613 0 222.613zm250.615 2.339c-12.675.544-21.906 7.08-25.752 19.885-5.54 18.443 1.298 45.246 25.817 46.77 0 0 12.49-.212 19.01-14.381 2.257-4.905 2.153-11.669 2.817-20.42 2.581-34.03-21.892-31.854-21.892-31.854zm6.167 53.917c-12.44 8.449-24.814-12.205-24.58-19.246.235-7.04 5.794-25.447 17.134-24.344 12.415 1.207 22.467 32.324 7.446 43.59zM73.676 245.827c-1.581-4.876-23.852 3.163-23.852 3.163-25.876 7.116-37.443 11.498 2.372 6.062 0 0 23.141-4.104 21.48-9.225zm7.164 29.616c7.893-6.238 29.413-17.098 25.208-19.86-7.512-9.803-47.98 29.52-50.782 46.707 0 0 18.48-21.24 25.574-26.847zm45.23 13.084c7.147-6.193 13.04-12.842 13.191-16.197.117-2.609-3.647-5.81-7.202-2.328-10.911 10.694-21.969 27.498-17.531 42.556 0 0-1.164-13.021 11.542-24.031zm234.57-12.842c-7.522 6.77 19.39 12.37 25.949 36.943 5.48.147-2.858-24.826-16.672-34.435-7.413-5.157-9.277-2.508-9.277-2.508zm79.892 23.066c-9.95-15.744-24.459-30.267-33.878-36.75-14.561-10.024-15.47-3.777-11.12.103 4.638 4.137 27.833 19.153 39.24 35.562 12.391 17.826 7.804 4.322 5.758 1.085zm46.505-50.1s-61.008-11.755-62.73-4.794c-2.291 9.274 62.73 4.793 62.73 4.793z"/></svg>';
  static const String animestudio =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" height="512" preserveAspectRatio="xMidYMid meet" viewBox="0 0 512 512"><path fill="currentColor" fill-rule="evenodd" d="m368.256 214.573-102.627 187.35c40.554 71.844 73.647 97.07 138.664 94.503 63.67-2.514 136.974-89.127 95.694-163.243L397.205 150.94c-3.676 12.266-25.16 55.748-28.95 63.634zM216.393 440.625


058 	add	r0, pc, #88	; 0x13410
   133b4:	e1a01005 	mov	r1, r5
   133b8:	eb000ab3 	bl	0x15e8c
   133bc:	e1540005 	cmp	r4, r5
   133c0:	03a00000 	moveq	r0, #0
   133c4:	13a00001 	movne	r0, #1
   133c8:	e8bd8070 	pop	{r4, r5, r6, pc}
   133cc:	e92d4070 	push	{r4, r5, r6, lr}
   133d0:	e1a05001 	mov	r5, r1
   133d4:	e1a01002 	mov	r1, r2
   133d8:	e1a04000 	mov	r4, r0
   133dc:	ebffffd1 	bl	0x13328
   133e0:	e3500000 	cmp	r0, #0
   133e4:	1a000004 	bne	0x133fc
   133e8:	e1a01005 	mov	r1, r5
   133ec:	e1a00004 	mov	r0, r4
   133f0:	ebffffd3 	bl	0x13344
   133f4:	e3500000 	cmp	r0, #0
   133f8:	08bd8070 	popeq	{r4, r5, r6, pc}
l133fc:		e3a00001 	mov	r0, #1
   13400:	e8bd8070 	pop	{r4, r5, r6, pc}

v13404:		5f0a6c39
v13408:		"sum=%x\n",0
v13410:		"src_sum=%x\n",0

   1341c:	e3a00001 	mov	r0, #1
   13420:	e12fff1e 	bx	lr
   13424:	e59f003c 	ldr	r0, [pc, #60]	; 0x13468
   13428:	e12fff1e 	bx	lr

f1342c:		e5902010 	ldr	r2, [r0, #16]
   13430:	e6ff1071 	uxth	r1, r1
   13434:	e7cf201f 	bfc	r2, #0, #16
   13438:	e1811002 	orr	r1, r1, r2
   1343c:	e5801010 	str	r1, [r0, #16]
   13440:	e3a02080 	mov	r2, #128	; 0x80
   13444:	e1a01000 	mov	r1, r0
   13448:	e59f001c 	ldr	r0, [pc, #28]	; 0x1346c
   1344c:	ea000d53 	b	0x169a0
   13450:	e59f1018 	ldr	r1, [pc, #24]	; 0x13470
   13454:	e3a020ac 	mov	r2, #172	; 0xac
   13458:	e92d4010 	push	{r4, lr}
   1345c:	eb000d71 	bl	0x16a28
   13460:	e3a00000 	mov	r0, #0
   13464:	e8bd8010 	pop	{r4, pc}

v13468:		20100000
v1346c:		2a000030
v13470:		000101f8

f13474:		e92d41f0 	push	{r4, r5, r6, r7, r8, lr


24s-10.7 24-24 24H296c-13.3 0-24-10.7-24-24s10.7-24 24-24z"],skull:[512,512,[128128],"f54c","M416 398.9c58.5-41.1 96-104.1 96-174.9C512 100.3 397.4 0 256 0S0 100.3 0 224c0 70.7 37.5 133.8 96 174.9c0 .4 0 .7 0 1.1v64c0 26.5 21.5 48 48 48h48V464c0-8.8 7.2-16 16-16s16 7.2 16 16v48h64V464c0-8.8 7.2-16 16-16s16 7.2 16 16v48h48c26.5 0 48-21.5 48-48V400c0-.4 0-.7 0-1.1zM96 256a64 64 0 1 1 128 0A64 64 0 1 1 96 256zm256-64a64 64 0 1 1 0 128 64 64 0 1 1 0-128z"],"tower-broadcast":[576,512,["broadcast-tower"],"f519","M80.3 44C69.8 69.9 64 98.2 64 128s5.8 58.1 16.3 84c6.6 16.4-1.3 35-17.7 41.7s-35-1.3-41.7-17.7C7.4 202.6 0 166.1 0 128S7.4 53.4 20.9 20C27.6 3.6 46.2-4.3 62.6 2.3S86.9 27.6 80.3 44zM555.1 20C568.6 53.4 576 89.9 576 128s-7.4 74.6-20.9 108c-6.6 16.4-25.3 24.3-41.7 17.7S489.1 228.4 495.7 212c10.5-25.9 16.3-54.2 16.3-84s-5.8-58.1-16.3-84C489.1 27.6 497 9 513.4 2.3s35 1.3 41.7 17.7zM352 128c0 23.7-12.9 44.4-32 55.4V480c0 17.7-14.3 32-32 32s-32-14.3-32-32V183.4c-19.1-11.1-32-31.7-32-55.4c0-35.3 28.7-64 64-64s64 28.7 64 64zM170.6 76.8C163.8 92.4 160 109.7 160 128s3.8 35.6 10.6 51.2c7.1 16.2-.3 35.1-16.5 42.1s-35.1-.3-42.1-16.5c-10.3-23.6-16-49.6-16-76.8s5.7-53.2 16-76.8c7.1-16.2 25.9-23.6 42.1-16.5s23.6 25.9 16.5 42.1zM464 51.2c10.3 23.6 16 49.6 16 76.8s-5.7 53.2-16 76.8c-7.1 16.2-25.9 23.6-42.1 16.5s-23.6-25.9-16.5-42.1c6.8-15.6 10.6-32.9 10.6-51.2s-3.8-35.6-10.6-51.2c-7.1-16.2 .3-35.1 16.5-42.1s35.1 .3 42.1 16.5z"],"truck-pickup":[640,512,[128763],"f63c","M368.6 96l76.8 96H288V96h80.6zM224 80V192H64c-17.7 0-32 14.3-32 32v64c-17.7 0-32 14.3-32 32s14.3 32 32 32H65.1c-.7 5.2-1.1 10.6-1.1 16c0 61


eadphone_mute_used, the default pa config is close(check sys_config.fex).*/
		gpio_set_value(item_mute.gpio.gpio, 0);
	}
	msleep(150);
#ifdef CONFIG_ARCH_SUN8IW3
	hmic_wr_prcm_control(MIC1G_MICBIAS_CTRL, 0x1, HMICBIASEN, 0x0);
#endif
	sunxi_hppa_disable();
	msleep(530);
	return 0;
}

static int switch_resume(struct platform_device *pdev)
{
	struct gpio_switch_data *switch_data;

//	if (check_scene_locked(SCENE_TALKING_STANDBY) != 0) {
		hmic_wr_control(SUNXI_HMIC_CTL, 0xf, HMIC_M, 0xf);						/*0xf should be get from hw_debug 28*/
		hmic_wr_control(SUNXI_HMIC_CTL, 0xf, HMIC_N, 0x1);						/*0xf should be get from hw_debug 24*/
		hmic_wr_control(SUNXI_HMIC_CTL, 0x1, HMIC_EARPHONE_OUT_IRQ_EN, 0x1); 	/*20*/
		hmic_wr_control(SUNXI_HMIC_CTL, 0x1, HMIC_EARPHONE_IN_IRQ_EN, 0x1); 	/*19*/
		hmic_wr_control(SUNXI_HMIC_CTL, 0x3, HMIC_DS_SAMP, 0x1); 				/*14*/
		hmic_wr_control(SUNXI_HMIC_CTL, 0x1f, HMIC_TH2_KEY, 0x8);				/*0xf should be get from hw_debug 8*/
		hmic_wr_control(SUNXI_HMIC_CTL, 0x1f, HMIC_TH1_EARPHONE, 0x1);			/*0x1 should be get from hw_debug 0*/
//	}
	switch_data = (struct gpio_switch_data *)platform_get_drvdata(pdev);

	if (switch_data != NULL) {
		queue_work(resume_switch_work_queue, &switch_data->resume_work);
	}
	return 0;
}

static void switch_shutdown(struct platform_device *devptr)
{
	if (g_headphone_mute_used) {
		/*config gpio info of headphone_mute_used, the default pa config is close(check sys_config.fex).*/
		gpio_set_value(item_mute.gpio.gpio, 0);
	}
	msleep(150);
	sunxi_hppa_disable();
	msleep(550);
}

static int __exit gpio_switch_remove(struct platform_device *pdev)
{
	struct gpio_switch_data *switch_data = platform_get_drvdata(pdev);

	if (resume_switch_work_queue != NULL) {
		flush_workqueue(resume_switch_work_queue);
		destroy_workqueue(resume_switch_work_queue);
	}

    if (switch_data->key) {
        input_unregister_device(switch_data->key);
        input_free_device(switch_data->key);
    }

    switch_dev_unregister(&switch_data->sdev);

	kfree(switch_data);

	return 0;
}

static struct platform_driver gpio_switch_driver = {
	.probe		= gpio_switch_probe,
	.remove		= __exit_p(gpio_switch_remove),
	.driver		= {
		.name	= "switch-gpio",
		.owner	= THIS_MODULE,
	},
	.suspend	= switch_suspend,
	.resume		= switch_resume,
	.shutdown   = switch_shutdown,
};

static struct gpio_switch_platform_data headset_switch_data = {
    .name = "h2w",
};

static struct platform_device gpio_switch_device = {
    .name = "switch-gpio",
    .dev = {
    	.platform_data = &headset_switch_data,
    }
};

static int __init gpio_switch_init(void)
{
	int ret = 0;

	ret = platform_device_register(&gpio_switch_device);
	if (ret == 0) {
		ret = platform_driver_register(&gpio_switch_driver);
	}

	return ret;
}

static void __exit gpio_switch_exit(void)
{
	platform_driver_unregister(&gpio_switch_driver);
	platform_device_unregister(&gpio_switch_device);

}
module_init(gpio_switch_init);
module_exit(gpio_switch_exit);

MODULE_AUTHOR("huanxin<huanxin@reuuimllatech.com>");
MODULE_DESCRIPTION("Switch driver");
MODULE_LICENSE("GPL");


 whether the number of colors is enough for drawing specified delimiters.
 * Adds standard colors if not enough or cuts the array if there are too many of them.
 * @param arcDelimiters - array of delimiters.
 * @param arcColors - array of colors (strings).
 * @returns modified list of colors.
 */
export function arcColorsModifier(
  arcDelimiters: number[],
  arcColors: string[],
) {
  if (arcDelimiters.length > arcColors.length - 1) {
    const colorDiff = arcDelimiters.length - arcColors.length + 1
    for (let i = 0; i < colorDiff; i++) {
      arcColors.push(schemePaired[i % schemePaired.length])
    }
  } else if (arcDelimiters.length < arcColors.length - 1) {
    arcColors = arcColors.slice(0, arcDelimiters.length + 1)
  }

  return arcColors
}

/**
 * Function that checks whether value that needle points at is between 0 and 100.
 * If it is less than 0 or larger than 100, value is equated to 0 and 100 respectively.
 * @param needleValue - value at which needle points.
 * @returns modified needleValue.
 */
export function needleValueModifier(needleValue: number) {
  return needleValue < 0 ? 0 : needleValue > 100 ? 100 : needleValue
}

/**
 * Function that converts percentage into radians.
 * @param perc - percentage.
 * @returns value in radians.
 */
export function perc2RadWithShift(perc: number) {
  return (perc / 100 - 0.5) * Math.PI
}

/**
 * Function for drawing gauge arc.
 * @param svg - original svg rectangle.
 * @param chartHeight - height of gauge.
 * @param arcColors - array of colors.
 * @param outerRadius - outter radius of gauge.
 * @param arcDelimiters - array of delimiters in percentage.
 * @returns modified svg.
 */
export function arcOutline(
  svg,
  chartHeight: number,
  offset: number,
  arcColors: string[],
  outerRadius: number,
  arcDelimiters: number[],
  arcOverEffect: boolean,
  padding: number,
  paddingColor: string,
  arcLabels: string[],
  arcLabelFontSize: number,
  labelsFont: string,
) {
  arcColors.forEach((color, i) => {
    const startAngle = perc2RadWithShift(i ? arcDelimiters[i - 1] : 0)
    const endAngle = perc2RadWithShift(arcDelimiters[i] || 100) // 100 for last arc slice

    let gaugeArc = arc()
      .innerRadius(chartHeight)
      .outerRadius(outerRadius)
      .startAngle(startAngle)
      .endAngle(endAngle)

    const innerArc = svg
      .append('path')
      .attr('d', gaugeArc)
      .attr('fill', color)
      .attr(
        'transform',
        'translate(' +
          (chartHeight + offset * 2) +
          ', ' +
          (chartHeight + offset) +
          ')',
      )

    if (arcOverEffect) {
      gaugeArc = arc()
        .innerRadius(chartHeight)
        .outerRadius(chartHeight + chartHeight * 0.1)
        .startAngle(startAngle)
        .endAngle(endAngle)

      const outerArc = svg
        .append('path')
        .attr('d', gaugeArc)
        .attr('fill', 'transparent')
        .attr('opacity', '0.2')
        .attr(
          'transform',
          'translate(' +
            (chartHeight + offset * 2) +
            ', ' +
            (chartHeight + offset) +
            ')',
        )

      innerArc
        .on('mouseover', () => {
          innerArc.style('opacity', 0.8)
          outerArc
            .transition()
            .duration(50)
            .ease(easeLinear)
            .attr('fill', color)
        })
        .on('mouseout', () => {
          innerArc.st


   )
        )
    }

    fun setLocationMode(mode: MyLocationConfiguration.LocationMode = MyLocationConfiguration.LocationMode.NORMAL) {
        MyLocationConfiguration(
            mode,
            true,
            null,
            Color.TRANSPARENT,
            Color.TRANSPARENT
        ).apply {
            if (mode == MyLocationConfiguration.LocationMode.NORMAL) {
                baiduMap.setMapStatus(
                    MapStatusUpdateFactory.newMapStatus(
                        MapStatus.Builder().overlook(0f).rotate(0f).build()
                    )
                )
            }
            baiduMap.setMyLocationConfiguration(this)
        }
    }

    init {
        setLocationMode(MyLocationConfiguration.LocationMode.NORMAL)

        mLocationClient = LocationClient(context)
        baiduMap.isMyLocationEnabled = true

        //通过LocationClientOption设置LocationClient相关参数
        val option = LocationClientOption()
        option.setScanSpan(1000)
        option.setNeedDeviceDirect(true)
        option.isOpenGnss = true
        option.setIsNeedAltitude(true)
        option.setOpenAutoNotifyMode(1000, 0, LocationClientOption.LOC_SENSITIVITY_MIDDLE)
        //设置locationClientOption
        mLocationClient.locOption = option

        mLocationClient.registerLocationListener(myLocationListener)
        //开启地图定位图层
        mLocationClient.start()
    }

    fun onDestroy() {
        mLocationClient.unRegisterLocationListener(myLocationListener)
        mLocationClient.stop()
        baiduMap.isMyLocationEnabled = false
    }

}package com.huolala.mockgps.model

import android.os.Parcel
import android.os.Parcelable
import androidx.annotation.IntDef
import com.huolala.mockgps.utils.LocationUtils

@IntDef(NaviType.NONE, NaviType.LOCATION, NaviType.NAVI, NaviType.NAVI_FILE)
@Retention(AnnotationRetention.SOURCE)
annotation class NaviType {
    companion object {
        const val NONE = -1
        const val LOCATION = 0
        const val NAVI = 1
        const val NAVI_FILE = 2
    }
}

/**
 * @author jiayu.liu
 */
data class MockMessageModel(
    var locationModel: PoiInfoModel? = null,
    var startNavi: PoiInfoModel? = null,
    var wayNaviList: List<PoiInfoModel>? = null,
    var endNavi: PoiInfoModel? = null,
    /**
     * 0.模拟定位  1.模拟导航  2.文件数据导航
     */
    @NaviType
    var naviType: Int = 0,
    /***
     * 速度 单位 KM/H
     */
    var speed: Int = 60,
    var uid: String? = "",
    var pointType: String? = LocationUtils.gcj02
) : Parcelable {
    constructor(parcel: Parcel) : this(
        parcel.readParcelable(PoiInfoModel::class.java.classLoader),
        parcel.readParcelable(PoiInfoModel::class.java.classLoader),
        parcel.createTypedArrayList(PoiInfoModel),
        parcel.readParcelable(PoiInfoModel::class.java.classLoader),
        parcel.readInt(),
        parcel.readInt(),
        parcel.readString(),
        parcel.readString()
    )

    override fun writeToParcel(parcel: Parcel, flags: Int) {
        parcel.writeParcelable(locationModel, flags)
        parcel.writeParcelable(startNavi, flags)
        parcel.writeTypedList(wayNaviList)
        parcel.writeParcelable(endNavi, flags)
        parcel.writeInt(naviType)
        parcel.writeInt(speed)
        parcel.writeString(uid)
        parcel.writeString(pointType)
    }

    override fun describeContents(): Int {


.id;

  public getDescription = () => this.overrideOptions.description;

  private setOverrideOptions = (programKey: string) => {
    const programKeyUpperCase = programKey.toUpperCase();
    if (this.campaignOptions.hasOwnProperty(programKeyUpperCase)) {
      return {
        ...this.overrideOptions,
        ...this.campaignOptions[programKeyUpperCase],
      };
    }
    return this.overrideOptions;
  };
}

const overrideProgram = new ProgramOverrideTS2("PROGRAM2");

console.log("\ngetTitle", overrideProgram.getTitle());
if (overrideProgram.getTitle()) {
  console.log("OVERRIDE");
}

console.log("\ngetId", overrideProgram.getId());
if (overrideProgram.getId()) {
  console.log("OVERRIDE");
}

console.log("\ngetDescription", overrideProgram.getDescription());
if (overrideProgram.getDescription()) {
  console.log("OVERRIDE");
}
export interface Mappable {
  location: {
    lat: number;
    lon: number;
  }

  markerContent(): string;
}import * as commander from 'commander';
import * as fs from 'fs';
import * as process from 'process';

import * as stl from './stl';

commander
  .usage('[options] <file>')
  .option('-v, --verbose', 'print debug output to stderr')
  .parse(process.argv);

if (commander.args.length !== 1) {
  throw new Error(`invalid argument length: ${commander.args.length}`);
}

let path = commander.args[0];
if (path === '-') {
  path = '/dev/stdin';
}

const buf = fs.readFileSync(path);
const triangles = stl.parse(buf);
const mesh = stl.convert(triangles, {
  scale: 0.001,
  verbose: commander.verbose,
});

console.log(JSON.stringify(mesh));
import { getTicTacToeWinner } from '../ticTacToeWinner';

describe("Tic Tac Toe Winner", () => {
  it("finds winner in row", function() {
    expect(getTicTacToeWinner([ 0, 0, 0, 1, 1, 1, 2, 2, 0 ], 0)).toBe(1);
  });
  it("finds winner in column", () => {
    expect(getTicTacToeWinner([ 1, 0, 0, 1, 0, 0, 1, 0, 0 ], 0)).toBe(1);
  });
  it("finds winner in diagonals", () => {
    expect(getTicTacToeWinner([ 1, 0, 0, 0, 1, 0, 0, 0, 1 ], 0)).toBe(1);
    expect(getTicTacToeWinner([ 0, 0, 1, 0, 1, 0, 1, 0, 0 ], 0)).toBe(1);
  });
  it("recognizes if there is not winner", function() {
    expect(getTicTacToeWinner([ 0, 0, 0, 0, 0, 0, 0, 0, 0 ], 0)).toBeUndefined();
  });
});import axios from "axios";
import { RemoteNew } from '../types';

export const API = axios.create({
    baseURL: "https://gnews.io/api/v4",
    params: {
        q: 'watches',
        token: process.env.NEXT_PUBLIC_GNEWS_KEY,
    },
});

export const getPosts = async (q = "watches") : Promise<RemoteNew[]> => {
    let posts
    try {
        posts = await API.get("/search", {
            params: {
                q: q,
            },
        })
    }
    catch(e){
        console.error(e)
    }
    return posts?.data?.articles as RemoteNew[]
};
import { IRevendedorRepository } from '../repositories/interfaces/IRevendedor.repository'
import { RevendedorDTO } from '../domain/DTO/revendedor.dto';
import { Revendedor } from '../domain/models/Revendedor';
import { IRevendedorService } from './Interfaces/IRevendedor.service'
import {


       |
| 知识图谱构建        | 如何利用知识图谱构建技术将一组非结构化数据转换成结构化数据？                                                                                |
| 异常检测            | 如何使用异常检测技术对服务器日志进行监控和预警？                                                                                |
| 视频分析            | 如何使用计算机视觉技术对视频进行目标跟踪和运动分析？                                                                                |
|电影推荐|有哪些值得观看的最新电影？|
|美食推荐|请问您能为我推荐一家味道正宗的中餐馆吗？|
|新闻分类|这篇新闻属于哪个领域，可以简要概括一下主要内容吗？|
|文本编辑|请帮我修改一下这段文字，让它更通顺易懂。|
|旅游指南|如果我明天要去上海旅游，您能为我提供一份详细的旅游攻略吗？|
|商品推荐|我想买一台性价比高的笔记本电脑，您有什么好的推荐吗？|
|情感分析|根据这封邮件的语气和措辞，可以判断出发件人的情感倾向是积极还是消极吗？|
|科技趋势|当前最受瞩目的科技趋势是什么，在未来几年内有哪些可能的发展方向？|
|医学咨询|我父亲最近总是感到乏力，且食欲不振，请问他应该如何调整饮食和生活方式？|
|学术论文|请问您对于这篇论文的结论是否认同？如有异议，您认为哪些地方需要改进或深入研究？|
| 文学 | 请用一句话概括《红楼梦》的主题。 |
| 科技 | 什么是人工智能？它有哪些应用场景？ |
| 健康 | 如何预防近视？ |
| 美食 | 如何制作一道美味的意大利面条？ |
| 艺术 | 你认为毕加索最著名的画作是哪幅？为什么？ |
| 旅游 | 请推荐一个适合度假的旅游胜地。这个地方有哪些值得去的特色景点？ |
| 政治 | 美国总统任期是多长时间？如何选举总统？ |
| 教育 | 如何帮助孩子提高写作水平？ |
| 商业 | 谈谈电商的优势和劣势。 |
| 社会 | 什么是社会心理学？它研究的范围是什么？ |
|电影推荐|你能推荐一部悬疑片，评分高于8.5分的吗？|
|菜谱查询|请问如何制作家常红烧肉？需要哪些材料？|
|健康咨询|我有颈椎病的症状，有什么运动或按摩可以缓解疼痛？|
|翻译服务|请你翻译一段中文文章到英文。原文是：“我们应该尊重不同的文化和价值观。”|
|金融投资|我想在股市上赚取更多利润，请问应该选哪些板块进行投资？|
|新闻摘要|最近国内的疫情有什么变化吗？|
|旅游建议|我想去海南度假，请问有哪些景点值得游玩？|
|历史知识|请问秦始皇统一六国的时间是哪一年？|
|语言学习|我正在学习法语，请问有什么好的方法可以快速提高口语水平？|
|社交礼仪|参加朋友的婚礼应该注意哪些礼仪？|
|天气预报|明天的气温是多少度？|
|旅游建议|你有什么推荐的旅游景点吗？|
|电影推荐|能给我一些经典的电影推荐吗？|
|音乐推荐|你有什么好听的新歌推荐吗？|
|产品介绍|请介绍一下这款手机的配置和特点。|
|菜谱


an class="colon">:

Gst.Allocator (2),     Gst.Object (1),     GObject.Object (7)

Properties¶

Inherited:

Gst.Object (2)

Signals¶

Inherited:

Gst.Object (1),     GObject.Object (1)

Fields¶

Inherited:

Gst.Object (1),     GObject.Object (1)

<colgroup>
<col style="width: 16.4%" />
<col style="width: 0.8%" />
<col style="width: 0.


地说，这里是装饰器和责任链模式的混合使用。例如，EchoFilter 的作用是判断是否是回声测试请求，是的话直接返回内容，这是一种责任链的体现。而像ClassLoaderFilter 则只是在主功能上添加了功能，更改当前线程

的 ClassLoader，这是典型的装饰器模式。
**观察者模式**
Dubbo 的 Provider 启动时，需要与注册中心交互，先注册自己的服务，再订阅自己的服务，订阅时，采用了观察者模式，开启一个 listener。注册中心会每 5 秒定时检查是否有服务更新，如果有更新，向该服务的提供者发送一个 notify 消息，provider 接受到 notify 消息后，即运行 NotifyListener 的 notify 方法，执行监听器方法。

**动态代理模式**
Dubbo 扩展 JDK SPI 的类 ExtensionLoader 的 Adaptive 实现是典型的动态代理实现。Dubbo 需要灵活地控制实现类，即在调用阶段动态地根据参数决定调用哪个实现类，所以采用先生成代理类的方法，能够做到灵活的调用。生成代理类的代码是 ExtensionLoader 的 createAdaptiveExtensionClassCode 方法。代理类的主要逻辑是，获取 URL 参数中指定参数的值作为获取实现类的 key。

### 19、Dubbo 配置文件是如何加载到 Spring 中的？

Spring 容器在启动的时候，会读取到 Spring 默认的一些 schema 以及 Dubbo 自定义的 schema，每个 schema 都会对应一个自己的 NamespaceHandler，NamespaceHandler 里面通过 BeanDefinitionParser 来解析配置信息并转化为需要加载的 bean 对象!

### 20、Dubbo SPI 和 Java SPI 区别？

**JDK SPI**
JDK 标准的 SPI 会一次性加载所有的扩展实现，如果有的扩展吃实话很耗时，但也没用上，很浪费资源。
所以只希望加载某个的实现，就不现实了

**DUBBO SPI**
1，对 Dubbo 进行扩展，不需要改动 Dubbo 的源码
2，延迟加载，可以一次只加载自己想要加载的扩展实现。
3，增加了对扩展点 IOC 和 AOP 的支持，一个扩展点可以直接 setter 注入其它扩展点。
4，Dubbo 的扩展机制能很好的支持第三方 IoC 容器，默认支持 Spring Bean。

### 21、Dubbo 支持分布式事务吗？

目前暂时不支持，可与通过 tcc-transaction 框架实现
介绍：tcc-transaction 是开源的 TCC 补偿性分布式事务框架
Git 地址：https://github.com/changmingxie/tcc-transaction
TCC-Transaction 通过 Dubbo 隐式传参的功能，避免自己对业务代码的入侵。

### 22、Dubbo 可以对结果进行缓存吗？

为了提高数据访问的速度。Dubbo 提供了声明式缓存，以减少用户加缓存的工作
量

```xml
<dub


import sys
import math
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import Timer, FallingEdge, RisingEdge, ClockCycles
from cocotb.handle import Force, Release

# Hack to import some helpers despite existing outside a package.
sys.path.append("..")
from util.i2s import *

@cocotb.test()
async def test_integration_00(dut):

    sample_width=16

    clk_256fs = Clock(dut.CLK, 83, units='ns')
    cocotb.start_soon(clk_256fs.start())

    dut.eurorack_pmod1.ak4619_instance.sdout1.value = 0
    # Simulate all jacks connected so the cal core doesn't zero them
    dut.eurorack_pmod1.jack.value = Force(0xFF)

    # The reset timer is downstream of the PLL lock.
    # So if we toggle the PLL lock, we are triggering
    # a reset from the highest-level part of the system.
    dut.sysmgr_instance.pll_lock.value = 0
    await RisingEdge(dut.clk_256fs)
    await RisingEdge(dut.clk_256fs)
    dut.sysmgr_instance.pll_lock.value = 1

    ak4619 = dut.eurorack_pmod1.ak4619_instance

    await FallingEdge(dut.strobe)

    N = 20

    for i in range(N):

        v = bits_from_signed(int(16000*math.sin((2*math.pi*i)/N)), sample_width)

        await i2s_clock_out_u32(ak4619.bick, ak4619.sdout1, v << 16)
        await i2s_clock_out_u32(ak4619.bick, ak4619.sdout1, v << 16)
        await i2s_clock_out_u32(ak4619.bick, ak4619.sdout1, v << 16)
        await i2s_clock_out_u32(ak4619.bick, ak4619.sdout1, v << 16)

        # Note: this edge is also where dac_words <= sample_in (sample.sv)

        print("Data clocked from sdout1 present at sample_outX:")
        print(hex(ak4619.sample_out0.value.integer))
        print(hex(ak4619.sample_out1.value.integer))
        print(hex(ak4619.sample_out2.value.integer))
        print(hex(ak4619.sample_out3.value.integer))


("zend/lang/operators/divide_variationStr.php");
        check("zend/lang/operators/modulus_variationStr.php");
        check("zend/lang/operators/multiply_variationStr.php");
        check("zend/lang/operators/negate_variationStr.php");

        check("zend/lang/operators/operator_equals_basic.php");
        check("zend/lang/operators/operator_gt_basic.php");
        check("zend/lang/operators/operator_gt_or_equal_basic.php");
        check("zend/lang/operators/operator_identical_basic.php");
        check("zend/lang/operators/operator_lt_basic.php");
        check("zend/lang/operators/operator_lt_or_equal_basic.php");
        check("zend/lang/operators/operator_notequals_basic.php");
        check("zend/lang/operators/operator_notidentical_basic.php");

        check("zend/lang/operators/postdec_variationStr.php");
        check("zend/lang/operators/postinc_variationStr.php");
        check("zend/lang/operators/predec_variationStr.php");
        check("zend/lang/operators/preinc_variationStr.php");
        check("zend/lang/operators/subtract_variationStr.php");
    }

    @Test
    public void testPhp7GroupUseDeclarations() {
        check("zend/php7/ns_088.phpt", true);
        check("zend/php7/ns_089.phpt");
        check("zend/php7/ns_090.phpt");
        check("zend/php7/ns_091.phpt");
        check("zend/php7/ns_092.phpt", true);
        check("zend/php7/ns_093.phpt");
        check("zend/php7/ns_094.phpt", true);
        check("zend/php7/ns_095.phpt");
        check("zend/php7/ns_096.phpt", true);
    }

    @Test
    public void testUnicodeEscape() {
        check("zend/lang/string/unicode_escape.phpt");
        check("zend/lang/string/unicode_escape_empty.phpt", true);
        check("zend/lang/string/unicode_escape_incomplete.phpt", true);
        check("zend/lang/string/unicode_escape_large_codepoint.phpt", true);
        check("zend/lang/string/unicode_escape_legacy.phpt", true);
        check("zend/lang/string/unicode_escape_sign.phpt", true);
        check("zend/lang/string/unicode_escape_sign2.phpt", true);
        //check("zend/lang/string/unicode_escape_surrogates.phpt", true);
        check("zend/lang/string/unicode_escape_whitespace.phpt", true);
    }
}
package org.develnext.jphp.zend.ext.standard.date;

import static org.assertj.core.api.Assertions.assertThat;
import static org.develnext.jphp.zend.ext.standard.date.DateTimeTokenizer.Token.EOF;
import static org.junit.Assert.assertEquals;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.develnext.jphp.zend.ext.standard.date.DateTimeTokenizer.Symbol;
import org.develnext.jphp.zend.ext.standard.date.DateTimeTokenizer.Token;
import org.junit.Test;

public class DateTimeTokenizerTest {
    private static List<Token> tokenize(final String time) {
        List<Token> tokens = new ArrayList<>();
        DateTimeTokenizer tokenizer = new DateTimeTokenizer(time);

        Token t;
        while ((t = tokenizer.next()) != EOF) tokens.add(t);

        return tokens;
    }

    @Test
    public void hourAndMinute() {
        assertE


4. 移动威胁正从个人向企业组织迁移

除了大量的个人用户遭受到移动威胁的侵蚀，由于企业对移动威胁的重视程度普遍不足，导致移动威胁造成的企业资产受损的事件近年有上升趋势。其中具有代表性的威胁案例是2016年8月由国外安全厂商首先公开披露的恶意代码“DressCode”，该病毒利用SOCKS代理反弹技术突破内网防火墙限制，窃取内网数据，能够以手机终端作为跳板实现对企业内网的渗透（具体的攻击流程如下图所示）。“DressCode”恶意代码的出现表明移动恶意代码已经具备对企业进行渗透攻击的能力。

DressCode攻击流程图

在另外一个场景中，则是通过篡改DNS实现对企业的渗透和攻击，2016年底在移动平台出现的“Switcher”恶意代码家族能够借助移动终端接入Wi-Fi对连入的路由器DNS服务进行攻击，恶意篡改DNS服务器地址从而实现受害用户网络流量劫持。从其整体的攻击流程和目标来看，移动威胁当前已经具备了对DNS这类网络服务进行恶意利用的能力。

<img class="aligncenter size-full wp-image-23433" src="http://www.aqniu.com/wp-content/uploads/2017/03/DNS劫持流程图-800.jpg" alt="" width="800" height="506" srcset="http://www.aqniu.com/wp-content/uploads/2017/03/DNS劫持流程图-800.jpg 800w, http://www.aqniu.com/wp-content/uploads/2017/03/


ScratchBuffer.Value = new byte[MaxKeyLen];

			buf[8] = (byte)(key32);
			buf[7] = (byte)(key32 >> 8);
			buf[6] = (byte)(key32 >> 16);
			buf[5] = (byte)(key32 >> 24);
			buf[4] = (byte)(key >> 32);
			buf[3] = (byte)(key >> 40);
			buf[2] = (byte)(key >> 48);
			buf[1] = (byte)(key >> 56);
			buf[0] = 0xFF;

			return new KeyWalker(buf, 9);
		}

		private void ThrowKeyAlreadyExists(long key)
		{
			CheckParam.ThrowBadArgument(nameof(key), "Key already exists: {0}", key);
		}

		private KeyWalker Encode(int key)
		{
			return IsShortKey(key) ? EncodeShort(key) : EncodeMed(key);
		}
		private KeyWalker Encode(uint key)
		{
			return IsShortKey(key) ? EncodeShort((int)key) : EncodeMed((long)key);
		}
		private KeyWalker Encode(long key)
		{
			int key32 = (int)key;
			if (key32 == key)
				return Encode(key32);
			else
				return IsLongKey(key) ? EncodeLong(key) : EncodeMed(key);
		}
		private KeyWalker Encode(ulong key)
		{
			uint key32 = (uint)key;
			if (key32 == key)
				return Encode(key32);
			else
				return IsLongKey(key) ? EncodeLong(key) : EncodeMed((long)key);
		}

		protected TValue GetValue(ref KeyWalker key, int keyI)
		{
			CPNode<TValue> head = Head;
			if (head != null)
			{
				TValue value = default(TValue);
				if (head.Set(ref key, ref value, ref head, CPMode.Find))
					return value;
			}
			throw new KeyNotFoundException(Localize.Localized("Key not found: ") + keyI.ToString());
		}
		protected TValue GetValue(ref KeyWalker key, long keyI)
		{
			CPNode<TValue> head = Head;
			if (head != null)
			{
				TValue value = default(TValue);
				if (head.Set(ref key, ref value, ref head, CPMode.Find))
					return value;
			}
			throw new KeyNotFoundException(Localize.Localized("Key not found: ") + keyI.ToString());
		}
		protected TValue GetValue(ref KeyWalker key, ulong keyI)
		{
			CPNode<TValue> head = Head;
			if (head != null)
			{
				TValue value = default(TValue);
				if (head.Set(ref key, ref value, ref head, CPMode.Find))
					return value;
			}
			throw new KeyNotFoundException(Localize.Localized("Key not found: ") + keyI.ToString());
		}

		internal static int DecodeInt(byte[] buf, int len)
		{
			if (len == 3)
			{
				Debug.Assert(buf[0] > 1 && buf[0] < 0xFE);
				return (buf[2] + (buf[1] << 8) + (buf[0] << 16)) - 0x30000;
			}
			if (len == 6)
			{
				Debug.Assert(buf[0] == 1 || buf[0] == 0xFE);
				return (buf[5] + (buf[4] << 8)) + ((buf[3] << 16) + (buf[2] << 24));
			}
			if (len == 9)
			{
				Debug.Assert(buf[0] == 0 || buf[0] == 0xFF);
				return (buf[8] + (buf[7] << 8)) + ((buf[6] << 16) + (buf[5] << 24));
			}
			throw new InvalidOperationException("CPIntTrie contains an invalid key");
		}
		internal static long DecodeLong(byte[] buf, int len)
		{
			if (len == 3)
			{
				Debug


 modifier letter
  ESC N letter
  ESC [ [ num ; modifier char
  ESC [ [ 1 ; modifier letter
  ESC ESC [ num char
  ESC ESC O letter

  - char is usually ~ but $ and ^ also happen with rxvt
  - modifier is 1 +
                (shift     * 1) +
                (left_alt  * 2) +
                (ctrl      * 4) +
                (right_alt * 8)
  - two leading ESCs apparently mean the same as one leading ESC
*/

// Regexes used for ansi escape code splitting
var metaKeyCodeReAnywhere = /(?:\x1b)([a-zA-Z0-9])/;
var metaKeyCodeRe = new RegExp('^' + metaKeyCodeReAnywhere.source + '$');
var functionKeyCodeReAnywhere = new RegExp('(?:\x1b+)(O|N|\\[|\\[\\[)(?:' + [
  '(\\d+)(?:;(\\d+))?([~^$])',
  '(?:M([@ #!a`])(.)(.))', // mouse
  '(?:1;)?(\\d+)?([a-zA-Z])'
].join('|') + ')');
var functionKeyCodeRe = new RegExp('^' + functionKeyCodeReAnywhere.source);
var escapeCodeReAnywhere = new RegExp([
  functionKeyCodeReAnywhere.source, metaKeyCodeReAnywhere.source, /\x1b./.source
].join('|'));

function emitKeys(stream, s) {
  if (Buffer.isBuffer(s)) {
    if (s[0] > 127 && s[1] === undefined) {
      s[0] -= 128;
      s = '\x1b' + s.toString(stream.encoding || 'utf-8');
    } else {
      s = s.toString(stream.encoding || 'utf-8');
    }
  }

  if (isMouse(s)) return;

  var buffer = [];
  var match;
  while (match = escapeCodeReAnywhere.exec(s)) {
    buffer = buffer.concat(s.slice(0, match.index).split(''));
    buffer.push(match[0]);
    s = s.slice(match.index + match[0].length);
  }
  buffer = buffer.concat(s.split(''));

  buffer.forEach(function(s) {
    var ch,
        key = {
          sequence: s,
          name: undefined,
          ctrl: false,
          meta: false,
          shift: false
        },
        parts;

    if (s === '\r') {
      // carriage return
      key.name = 'return';

    } else if (s === '\n') {
      // enter, should have been called linefeed
      key.name = 'enter';
      // linefeed
      // key.name = 'linefeed';

    } else if (s === '\t') {
      // tab
      key.name = 'tab';

    } else if (s === '\b' || s === '\x7f' ||
               s === '\x1b\x7f' || s === '\x1b\b') {
      // backspace or ctrl+h
      key.name = 'backspace';
      key.meta = (s.charAt(0) === '\x1b');

    } else if (s === '\x1b' || s === '\x1b\x1b') {
      // escape key
      key.name = 'escape';
      key.meta = (s.length === 2);

    } else if (s === ' ' || s === '\x1b ') {
      key.name = 'space';
      key.meta = (s.length === 2);

    } else if (s.length === 1 && s <= '\x1a') {
      // ctrl+letter
      key.name = String.fromCharCode(s.charCodeAt(0) + 'a'.charCodeAt(0) - 1);
      key.ctrl = true;

    } else if (s.length === 1 && s >= 'a' && s <= 'z') {
      // lowercase letter
      key.name = s;

    } else if (s.length === 1 && s >= 'A' && s <= 'Z') {
      // shift+letter
      key.name = s.toLowerCase();
      key.shift = true;

    } else if (parts = metaKeyCodeRe.exec(s)) {
      // meta+character key
      key.name = parts[1].toLowerCase();
      key.meta = true;
      key.shift = /^[A-Z]$/.test(parts[1]);

    } else if (parts = functionKeyCodeRe.exec(s)) {


)'],
  ['don', '《Don》ドン(Sirに当たるスペイン語で男性の洗礼名の前につける) / 〈C〉スペイン貴族(紳士) / 〈C〉(オックスフォード・ケンブリッジ両大学の)学監,指導教授 / 〈C〉《英》大学教師'],
  ['don', '〈衣服〉‘を\'着る,〈帽子〉‘を\'かぶる[do onの短縮形]'],
  ['Don', 'ドン川(旧ソ連ヨーロッパ中部の川で,Azov海に注ぐ)'],
  ['Don Juan', '(スペインの伝説で有名な)ドンファン / 〈C〉《話》女たらし,色男'],
  ['Don Quixote', 'ドンキホーテ(スペインの作家Cervantesの風刺小説およびその主人公の名) / 〈C〉現実離れした理想家'],
  ['don\'t', 'do notの短縮形 / してはいけないこと'],
  ['Dona', '…夫人(Madam)'],
  ['donate', '(…に)…‘を\'寄贈する,寄付する《+『名』+『to』+『名』》 / (…に)寄贈(寄付)する《+『to』+『名』》'],
  ['donation', '寄贈,寄付 / 寄付金,寄贈品'],
  ['done', 'doの過去分詞 / 仕上がった,完成した / 「(食べ物が)焼けた」の意を表す'],
  ['donjon', '(昔の城の)天守閣'],
  ['donkey', '(家畜化された)『ロバ』 / ばか者,とんま;強情な人,がんこ者'],
  ['donkey engine', '(船舶用の小さな)補助機関'],
  ['donkey jacket', '足の先まで届く厚地の布製のジャケット'],
  ['donkeys years', 'とても長い間'],
  ['donkeywork', '退屈なつらい仕事'],
  ['donna', '《Donna》ドンナ(Lady, Madamに当たるイタリア語;既婚婦人の洗礼名の前につける敬称) / イタリアの貴婦人'],
  ['donnish', '(英国大学の)学監 (don) らしい; 学者ぶる，学問一徹の,形式ばった,堅苦しい'],
  ['donnybrook', '荒々しい口論;けんか騒ぎ,乱闘'],
  ['donor', '寄付者,寄贈者 / (移植用の組織・器官の)提供者,献血者'],
  ['donut', '=doughnut'],
  ['doodad', '小さな飾り物,安ぴか物'],
  ['doodle', '(考えごとなどをしているときの)いたずら書き / (考えごとなどをしながら)いたずら書きする / …‘を\'いたずら書きする'],
  ['doodlebug', '《米》アリ地獄 / 《英話》V1号爆弾


srNetworkQueueEntry & entry);
  /**
   * Number of entries
   *
   * \return the current queue size/length
   */
  uint32_t GetSize ();

  /**
   * Set the maximum queue size
   *
   * \param maxSize the maximum queue size
   */
  void SetMaxNetworkSize (uint32_t maxSize);
  /**
   * Set the maximum entry lifetime in the queue
   *
   * \param delay the maximum entry lifetime
   */
  void SetMaxNetworkDelay (Time delay);
  /**
   * Return the maximum queue size
   *
   * \return the maximum queue size
   */
  uint32_t GetMaxNetworkSize (void) const;
  /**
   * Return the maximum entry lifetime for this queue
   *
   * \return the maximum entry lifetime for this queue
   */
  Time GetMaxNetworkDelay (void) const;
  /**
   * Clear the queue
   */
  void Flush (void);

  std::vector<DsrNetworkQueueEntry> & GetQueue ()
  {
    return m_dsrNetworkQueue;
  }

private:
  /**
   * Clean the queue by removing entries that exceeded lifetime.
   */
  void Cleanup (void);
  std::vector<DsrNetworkQueueEntry> m_dsrNetworkQueue; //!< Queue (vector) of entries
  uint32_t m_size; //!< Current queue size
  uint32_t m_maxSize; //!< Maximum queue size
  Time m_maxDelay; //!< Maximum entry lifetime
};

} // namespace dsr
} // namespace ns3

#endif /* DSR_NETWORK_QUEUE_H */


///
/// # Example
/// ```
/// #[macro_use] extern crate numbers;
/// use numbers::Matrix;
/// pub fn main(){
///     let mut a = Matrix :: new(vec![4.0,7.0,2.0,6.0, 5.0,7.0,2.0,3.0,3.0], 3,3).ok().unwrap();
///     let tr = numbers::operations::trace(&mut a);
///     assert!(tr-12.0 < 1e-14)
///  }
/// ```
pub fn trace<T: SqMat>(a: &mut T ) -> f64{
    let diag : Vec<f64> = a.diagonal();
    diag.iter().fold(0.0,|a,&b| a + b)

}

/// Get the product of the diagonal elements of a matrix.
///
/// # Arguments
///
/// * `Matrix` - Matrix of type f64
///
/// # Example
/// ```
/// #[macro_use] extern crate numbers;
/// use numbers::Matrix;
/// pub fn main(){
///     let mut a = Matrix :: new(vec![4.0,7.0,2.0,6.0, 5.0,7.0,2.0,3.0,3.0], 3,3).ok().unwrap();
///     let tr = numbers::operations::prod_diag(&mut a);
///     assert!(tr-60.0 < 1e-14)
///  }
/// ```
pub fn prod_diag<T: SqMat> (a: &mut T ) -> f64{
    let diag : Vec<f64> = a.diagonal();
    diag.iter().fold(0.0,|a,&b| a * b)

}

/// Derive the pseudoinverse of a matrix via SVD.
///
/// # Arguments
///
/// * `Matrix` - Matrix of type f64
///
/// # Example
/// ```
/// #[macro_use] extern crate numbers;
/// use numbers::Matrix;
/// pub fn main(){
///     let mut b = Matrix :: new(vec![4.0,7.0,5.0,10.0], 2,2).ok().unwrap();
///      let inv = numbers::operations::pseudoinverse(&mut b).ok().unwrap();
///     let pinv = numbers::operations::pseudoinverse(&mut b).ok().unwrap();
///     matrix_equal!(inv,pinv)
///  }
/// ```
pub fn pseudoinverse <T: NonSingularMat>(a : &mut T ) ->Result<T,MatrixError> {
    let (mut u,mut e, mut vt) = try!(svd(a));
    let inv_e = try!(a.matrix_map(&|x : &f64| if x > &0.0 { x.recip()} else { 0.0 },&mut e));
    let mut d = try!(dot(&mut u, &mut inv_e.transpose()));
    dot (&mut d, &mut vt)
}

/// Check whether a matrix is orthogonal, ie that A^T A = I.
  ///
  /// # Arguments
  ///
  /// * `Matrix` - Matrix of type f64
  ///
  /// # Example
  /// ```
  ///#[macro_use] extern crate numbers;
  /// use numbers::Matrix;
  /// pub fn main(){
  /// let mut a = Matrix :: new(vec![1.0,1.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0],3,3).ok().unwrap();
  /// assert!(numbers::operations::is_orthogonal(&mut a).ok().unwrap())
  ///}
  /// ```
pub fn is_orthogonal <T : SqMat> (a : &mut T ) -> Result<bool, MatrixError>{
    let mut at = a.transpose();
    let d = try!(dot (a, &mut at));
    let l : Matrix <f64> = Matrix::identity(a.row_size);
    matrix_equal!(d,l)
}

/// Check whether a matrix is normal, ie that A^T A = A A^T.
///
/// # Arguments
///
/// * `Matrix` - Matrix of type


ConverterString.read(buf))
            7 -> QrCodeLoginException.SessionTokens(FfiConverterString.read(buf))
            8 -> QrCodeLoginException.DeviceKeyUpload(FfiConverterString.read(buf))
            9 -> QrCodeLoginException.SecretImport(FfiConverterString.read(buf))
            else -> throw RuntimeException("invalid error enum value, something is very wrong!!")
        }

    }

    override fun allocationSize(value: QrCodeLoginException): ULong {
        return 4UL
    }

    override fun write(value: QrCodeLoginException, buf: ByteBuffer) {
        when(value) {
            is QrCodeLoginException.OAuth -> {
                buf.putInt(1)
                Unit
            }
            is QrCodeLoginException.LoginFailure -> {
                buf.putInt(2)
                Unit
            }
            is QrCodeLoginException.UnexpectedMessage -> {
                buf.putInt(3)
                Unit
            }
            is QrCodeLoginException.SecureChannel -> {
                buf.putInt(4)
                Unit
            }
            is QrCodeLoginException.CrossProcessRefreshLock -> {
                buf.putInt(5)
                Unit
            }
            is QrCodeLoginException.UserIdDiscovery -> {
                buf.putInt(6)
                Unit
            }
            is QrCodeLoginException.SessionTokens -> {
                buf.putInt(7)
                Unit
            }
            is QrCodeLoginException.DeviceKeyUpload -> {
                buf.putInt(8)
                Unit
            }
            is QrCodeLoginException.SecretImport -> {
                buf.putInt(9)
                Unit
            }
        }.let { /* this makes the `when` an expression, which ensures it is exhaustive */ }
    }

}

/**
 * The role of a member in a room.
 */

enum class RoomMemberRole {

    /**
     * The member is a creator.
     *
     * A creator has an infinite power level and cannot be demoted, so this
     * role is immutable. A room can have several creators.
     *
     * It is available in room versions where
     * `explicitly_privilege_room_creators` in [`AuthorizationRules`] is set to
     * `true`.
     *
     * [`AuthorizationRules`]: ruma::room_version_rules::AuthorizationRules
     */
    CREATOR,
    /**
     * The member is an administrator.
     */
    ADMINISTRATOR,
    /**
     * The member is a moderator.
     */
    MODERATOR,
    /**
     * The member is a regular user.
     */
    USER;
    companion object
}

/**
 * @suppress
 */
public object FfiConverterTypeRoomMemberRole: FfiConverterRustBuffer<RoomMemberRole> {
    override fun read(buf: ByteBuffer) = try {
        RoomMemberRole.values()[buf.getInt() - 1]
    } catch (e: IndexOutOfBoundsException) {
        throw RuntimeException("invalid enum value, something is very wrong!!", e)
    }

    override fun allocationSize(value: RoomMemberRole) = 4UL

    override fun write(value: RoomMemberRole, buf: ByteBuffer) {
        buf.putInt(value.ordinal + 1)
    }
}

/**
 * Status for the back-pagination on a room event cache.
 */
sealed class RoomPaginationStatus {

    /**
     * No back-pagination is happening right now.
     */
    data class Idle(
        /**
         * Have we hit the start of the timeline, i.e. back-paginating wouldn't
         * have any effect?
         */
        val `hitTimelineStart`: kotlin.Boolean) : RoomPaginationStatus() {
        companion object
    }

    /**
     * Back-pagination is already running in the background.
     */
    object Paginating : RoomPaginationStatus()

    co


from os.path import join

from pythonforandroid.recipe import PythonRecipe
from pythonforandroid.toolchain import current_directory
from pythonforandroid.util import rmdir

class ZopeInterfaceRecipe(PythonRecipe):
    call_hostpython_via_targetpython = False
    name = 'zope_interface'
    version = '4.1.3'
    url = 'https://pypi.python.org/packages/source/z/zope.interface/zope.interface-{version}.tar.gz'
    site_packages_name = 'zope.interface'
    depends = ['setuptools']
    patches = ['no_tests.patch']

    def build_arch(self, arch):
        super().build_arch(arch)
        # The zope.interface module lacks of the __init__.py file in one of his
        # folders (once is installed), that leads into an ImportError.
        # Here we intentionally apply a patch to solve that, so, in case that
        # this is solved in the future an error will be triggered
        zope_install = join(self.ctx.get_site_packages_dir(arch), 'zope')
        self.apply_patch('fix-init.patch', arch.arch, build_dir=zope_install)

    def prebuild_arch(self, arch):
        super().prebuild_arch(arch)
        with current_directory(self.get_build_dir(arch.arch)):
            rmdir('src/zope/interface/tests')
            rmdir('src/zope/interface/common/tests')

recipe = ZopeInterfaceRecipe()


ll client information from the database.
     * @return True if all clients were removed successfully.
     */
    bool DeleteClients();

    /*!
     * @brief Add a client to the database if it's not already in there.
     * @param strClientName The name of the client.
     * @param strGuid The unique ID of the client.
     * @return The database ID of the client.
     */
    int Persist(const ADDON::AddonPtr addon);

    /*!
     * @brief Remove a client from the database
     * @param strGuid The unique ID of the client.
     * @return True if the client was removed successfully, false otherwise.
     */
    bool Delete(const CPVRClient &client);

    /*!
     * @brief Get the database ID of a client.
     * @param strClientUid The unique ID of the client.
     * @return The database ID of the client or -1 if it wasn't found.
     */
    int GetClientId(const std::string &strClientUid);
    //@}

  private:
    /*!
     * @brief Create the PVR database tables.
     * @return True if the tables were created successfully, false otherwise.
     */
    void CreateTables();
    void CreateAnalytics();

    bool DeleteChannelsFromGroup(const CPVRChannelGroup &group);
    bool DeleteChannelsFromGroup(const CPVRChannelGroup &group, const std::vector<int> &channelsToDelete);

    bool GetCurrentGroupMembers(const CPVRChannelGroup &group, std::vector<int> &members);
    int GetLastChannelId(void);
    bool RemoveStaleChannelsFromGroup(const CPVRChannelGroup &group);

    /*!
     * @brief Update an old version of the database.
     * @param version The version to update the database from.
     */
    void UpdateTables(int version);
    virtual int GetMinSchemaVersion() const { return 11; }

    bool PersistGroupMembers(CPVRChannelGroup &group);

    bool PersistChannels(CPVRChannelGroup &group);

    bool RemoveChannelsFromGroup(const CPVRChannelGroup &group);
  };

  /*!
   * @brief Try to open the PVR database.
   * @return The opened database or NULL if the database failed to open.
   */
  inline CPVRDatabase *GetPVRDatabase(void)
  {
    CPVRDatabase *database = g_PVRManager.GetTVDatabase();
    if (!database || !database->IsOpen())
    {
      CLog::Log(LOGERROR, "PVR - failed to open the database");
      database = NULL;
    }

    return database;
  }
}


 com.gy4j.jvm.eye.core.command.jvm.response.JvmResponse;
import com.gy4j.jvm.eye.core.command.jvm.vo.JvmInfoVO;
import com.gy4j.jvm.eye.core.response.IResponse;
import com.gy4j.jvm.eye.core.util.JsonUtils;

import java.lang.management.ClassLoadingMXBean;
import java.lang.management.CompilationMXBean;
import java.lang.management.GarbageCollectorMXBean;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryManagerMXBean;
import java.lang.management.MemoryUsage;
import java.lang.management.OperatingSystemMXBean;
import java.lang.management.RuntimeMXBean;
import java.lang.management.ThreadMXBean;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * @author gy4j
 * 功能：
 * 日期：2022/11/26
 * 版本       开发者     描述
 * 1.0.0     gy4j     ...
 */
public class JvmCommand extends AbstractCommand {

    @Override
    public IResponse executeForResponse(IClient client) {
        JvmResponse jvmResponse = new JvmResponse();
        JvmInfoVO jvmInfoVO = new JvmInfoVO();
        addRuntimeInfo(jvmInfoVO.getRuntimeInfo());
        addClassLoading(jvmInfoVO.getClassLoadingInfo());
        addCompilation(jvmInfoVO.getCompilationInfo());
        addGarbageCollectors(jvmInfoVO.getGarbageCollectorInfo());
        addMemoryManagers(jvmInfoVO.getMemoryManagerInfo());
        addMemory(jvmInfoVO.getMemoryInfo());
        addOperatingSystem(jvmInfoVO.getOperatingSystemInfo());
        addThread(jvmInfoVO.getThreadInfo());
        addFileDescriptor(jvmInfoVO.getFileDescriptorInfo());
        jvmResponse.setJvmInfo(jvmInfoVO);
        return jvmResponse;
    }

    @Override
    public Class<? extends IResponse> getResponseClass() {
        return JvmResponse.class;
    }

    private void addFileDescriptor(Map<String, String> fileDescriptorInfo) {
        OperatingSystemMXBean operatingSystemMXBean = ManagementFactory.getOperatingSystemMXBean();
        fileDescriptorInfo.put("MAX-FILE-DESCRIPTOR-COUNT", invokeFileDescriptor(operatingSystemMXBean, "getMaxFileDescriptorCount") + "");
        fileDescriptorInfo.put("OPEN-FILE-DESCRIPTOR-COUNT", invokeFileDescriptor(operatingSystemMXBean, "getOpenFileDescriptorCount") + "");
    }

    private long invokeFileDescriptor(OperatingSystemMXBean os, String name) {
        try {
            final Method method = os.getClass().getDeclaredMethod(name);
            method.setAccessible(true);
            return (Long) method.invoke(os);
        } catch (Exception e) {
            return -1;
        }
    }

    private void addRuntimeInfo(Map<String, String> runtimeInfo) {
        RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
        String bootClassPath = "";
        try {
            bootClassPath = runtimeMXBean.getBootClassPath();
        } catch (Exception e) {
            // under jdk9 will throw UnsupportedOperationException, ignore
        }
        runtimeInfo.put("MACHINE-NAME", runtimeMXBean.getName());
        runtimeInfo.put("JVM-START-TIME", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(runtimeMXBean.getStartTime())));
        runtimeInfo.put("MANAGEMENT-SPEC-VERSION", runtimeMXBean.getManagementSpecVersion());
        runtimeInfo.put("SPEC-NAME", runtimeMXBean.getSpecName());
        runtimeInfo.put("SPEC-VENDOR", runtimeMXBean.getSpecVendor());
        runtimeInfo.put("SPEC-VERSION", runtimeMXBean.getSpecVersion());
        runtimeInfo.put("V


 checkout
      // that auto-converts line endings.
      final splitter = LineSplitter();
      if (file.existsSync()) {
        final data = file.readAsStringSync();
        final lines = splitter.convert(data);
        for (final line in lines) {
          input.add(utf8.encode(line));
        }
      }
    }

    for (final file in files) {
      addTextFile(file);
    }

    input.close();
    final res = output.events.single;

    // Truncate to 128bits.
    final hash = res.bytes.sublist(0, 16);
    return hex.encode(hash);
  }

  List<File> getFiles() {
    final src = Directory(path.join(manifestDir, 'src'));
    final files = src
        .listSync(recursive: true, followLinks: false)
        .whereType<File>()
        .toList();
    files.sortBy((element) => element.path);
    void addFile(String relative) {
      final file = File(path.join(manifestDir, relative));
      if (file.existsSync()) {
        files.add(file);
      }
    }

    addFile('Cargo.toml');
    addFile('Cargo.lock');
    addFile('build.rs');
    addFile('cargokit.yaml');
    return files;
  }

  final String manifestDir;
  final String? tempStorage;
}
/// 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';

import 'package:ed25519_edwards/ed25519_edwards.dart';
import 'package:http/http.dart';
import 'package:logging/logging.dart';
import 'package:path/path.dart' as path;

import 'builder.dart';
import 'crate_hash.dart';
import 'options.dart';
import 'precompile_binaries.dart';
import 'rustup.dart';
import 'target.dart';

class Artifact {
  /// File system location of the artifact.
  final String path;

  /// Actual file name that the artifact should have in destination folder.
  final String finalFileName;

  AritifactType get type {
    if (finalFileName.endsWith('.dll') ||
        finalFileName.endsWith('.dll.lib') ||
        finalFileName.endsWith('.pdb') ||
        finalFileName.endsWith('.so') ||
        finalFileName.endsWith('.dylib')) {
      return AritifactType.dylib;
    } else if (finalFileName.endsWith('.lib') || finalFileName.endsWith('.a')) {
      return AritifactType.staticlib;
    } else {
      throw Exception('Unknown artifact type for $finalFileName');
    }
  }

  Artifact({
    required this.path,
    required this.finalFileName,
  });
}

final _log = Logger('artifacts_provider');

class ArtifactProvider {
  ArtifactProvider({
    required this.environment,
    required this.userOptions,
  });

  final BuildEnvironment environment;
  final CargokitUserOptions userOptions;

  Future<Map<Target, List<Artifact>>> getArtifacts(List<Target> targets) async {
    final result = await _getPrecompiledArtifacts(targets);

    final pendingTargets = List.of(targets);
    pendingTargets.removeWhere((element) => result.containsKey(element));

    if (pendingTargets.isEmpty) {
      return result;
    }

    final rustup = Rustup();
    for (final target in targets) {
      final builder = RustBuilder(target: target, environment: environment);
      builder.prepare(rustup);
      _log.info('Building ${environment.crateInfo.packageName} for $target');
      final targetDir = await builder.build();
      // For local build accept both static and dynamic libraries.
      final artifactNames = <String>{
        ...getArtifactNames(
          target: target,


er",
    "Zuckerman",
    "Zug",
    "Zulch",
    "Zuleika",
    "Zulema",
    "Zullo",
    "Zumstein",
    "Zumwalt",
    "Zurek",
    "Zurheide",
    "Zurkow",
    "Zurn",
    "Zusman",
    "Zuzana",
    "Zwart",
    "Zweig",
    "Zwick",
    "Zwiebel",
    "Zysk"
        };

        #endregion
    }
}


) {
			return;
		}
		if(cookiesTag.length <= 25) {
			PlatformApplication.setLocalStorage(localStorageKey, null, false);
			return;
		}
		try {
			byte[] decrypted;
			int decryptedLen;
			switch(cookiesTag[0]) {
			case 2:
				if(key == null || key.length == 0) {
					throw new IOException("Data is encrypted!");
				}
				decrypted = new byte[cookiesTag.length - 5];
				decryptedLen = (cookiesTag[1] << 24) | (cookiesTag[2] << 16) | (cookiesTag[3] << 8) | (cookiesTag[4] & 0xFF);
				if(decryptedLen < 25) {
					throw new IOException("too short!");
				}
				AESLightEngine aes = new AESLightEngine();
				aes.init(false, key);
				int bs = aes.getBlockSize();
				if(decrypted.length % bs != 0) {
					throw new IOException("length not aligned to block size!");
				}
				byte[] cbcHelper = new byte[] { (byte) 29, (byte) 163, (byte) 4, (byte) 20, (byte) 207, (byte) 26,
						(byte) 140, (byte) 55, (byte) 246, (byte) 250, (byte) 141, (byte) 183, (byte) 153, (byte) 154,
						(byte) 59, (byte) 4 };
				for(int i = 0; i < decryptedLen; i += bs) {
					processBlockDecryptHelper(aes, cookiesTag, 5 + i, decrypted, i, bs, Math.min(decryptedLen - i, bs), cbcHelper);
				}
				if(decrypted[0] != (byte)0x69) {
					throw new IOException("Data is corrupt!");
				}
				break;
			case 1:
				if(key != null && key.length > 0) {
					throw new IOException("Data isn't encrypted!");
				}
				decrypted = cookiesTag;
				decryptedLen = cookiesTag.length;
				break;
			default:
				throw new IOException("Unknown type!");
			}
			SHA1Digest digest = new SHA1Digest();
			digest.update(decrypted, 25, decryptedLen - 25);
			byte[] digestOut = new byte[20];
			digest.doFinal(digestOut, 0);
			for(int i = 0; i < 20; ++i) {
				if(digestOut[i] != decrypted[5 + i]) {
					throw new IOException("Invalid checksum!");
				}
			}
			int decompressedLen = (decrypted[1] << 24) | (decrypted[2] << 16) | (decrypted[3] << 8) | (decrypted[4] & 0xFF);
			byte[] decompressed = new byte[decompressedLen];
			try (InputStream zstream = EaglerZLIB.newInflaterInputStream(new EaglerInputStream(decrypted, 25, decryptedLen - 25))) {
				int i = 0, j;
				while(i < decompressedLen && (j = zstream.read(decompressed, i, decompressedLen - i)) != -1) {
					i += j;
				}
				if(i != decompressedLen) {
					throw new IOException("Length does not match!");
				}
			}
			DataInputStream dis = new DataInputStream(new EaglerInputStream(decompressed));
			int readCount = dis.readInt();
			long time = System.currentTimeMillis();
			for(int i = 0; i < readCount; ++i) {
				byte flags = dis.readByte();
				long expires = dis.readLong();
				int len = dis.readUnsignedShort();
				String server = dis.readUTF();
				if(len == 0) {
					continue;
				}
				if(expires < time) {
					dis.skipBytes(len);
					continue;
				}
				byte[] cookieData = new byte[len];
				dis.readFully(cookieData);
				server = normalize(server);
				dataStore.put(server, new


IBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) 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 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "JSWebAssemblyGlobal.h"
#include "ObjectConstructor.h"

#if ENABLE(WEBASSEMBLY)

#include "JSCInlines.h"

namespace JSC {

const ClassInfo JSWebAssemblyGlobal::s_info = { "WebAssembly.Global", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSWebAssemblyGlobal) };

JSWebAssemblyGlobal* JSWebAssemblyGlobal::tryCreate(JSGlobalObject* globalObject, VM& vm, Structure* structure, Ref<Wasm::Global>&& global)
{
    auto throwScope = DECLARE_THROW_SCOPE(vm);

    if (!globalObject->webAssemblyEnabled()) {
        throwException(globalObject, throwScope, createEvalError(globalObject, globalObject->webAssemblyDisabledErrorMessage()));
        return nullptr;
    }

    auto* instance = new (NotNull, allocateCell<JSWebAssemblyGlobal>(vm.heap)) JSWebAssemblyGlobal(vm, structure, WTFMove(global));
    instance->global()->setOwner(instance);
    instance->finishCreation(vm);
    return instance;
}

Structure* JSWebAssemblyGlobal::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
{
    return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
}

JSWebAssemblyGlobal::JSWebAssemblyGlobal(VM& vm, Structure* structure, Ref<Wasm::Global>&& global)
    : Base(vm, structure)
    , m_global(WTFMove(global))
{
}

void JSWebAssemblyGlobal::finishCreation(VM& vm)
{
    Base::finishCreation(vm);
    ASSERT(inherits(vm, info()));
}

void JSWebAssemblyGlobal::destroy(JSCell* cell)
{
    static_cast<JSWebAssemblyGlobal*>(cell)->JSWebAssemblyGlobal::~JSWebAssemblyGlobal();
}

template<typename Visitor>
void JSWebAssemblyGlobal::visitChildrenImpl(JSCell* cell, Visitor& visitor)
{
    JSWebAssemblyGlobal* thisObject = jsCast<JSWebAssemblyGlobal*>(cell);
    ASSERT_GC_OBJECT_INHERITS(thisObject, info());

    Base::visitChildren(thisObject, visitor);
    thisObject->global()->visitAggregate(visitor);
}

JSObject* JSWebAssemblyGlobal::type(JSGlobalObject* globalObject)
{
    VM& vm = globalObject->vm();

    JSObject* result = constructEmptyObject(globalObject, globalObject->objectPrototype(), 2);

    result->putDirect(vm, Identifier::fromString(vm, "mutable"), jsBoolean(m_global->mutability() == Wasm::GlobalInformation::Mutable));

    Wasm::Type valueType = m_global->type();
    JSString* valueString = nullptr;
    switch (valueType.kind) {
    case Wasm::TypeKind::I32:
        valueString = jsNontrivialString(vm, "i32");
        break;
    case Wasm::TypeKind::I64:
        valueString = jsNontrivialString(vm, "i64");
        break;
    case Wasm::TypeKind::F32:
        valueString = jsNontrivialString(vm, "f32");
        break;
    case Wasm::TypeKind::F64:
        valueString = jsNontrivialString(vm, "f64");
        break;
    case Wasm::TypeKind::Externref:
        valueString = jsNontrivialString(vm, "externref");
        break;
    case Wasm::TypeKind::Funcref:
        valueString = jsNontrivialString(vm, "funcref");
        break;
    default:
        RELEASE_ASSERT_NOT_REACHED();
    }
    result->putDirect(vm, Identifier::fromString(vm, "value"), valueString);

    return result;
}

DEFINE_VISIT_CHILDREN(JSWebAssemblyGlobal


from trampoline.S removes the need
	 * to have any identity mapped pages in the kernel page table
	 * after the boot processor executes this code.
	 */

	/* Sanitize CPU configuration */
	call verify_cpu

	movq	$(init_level4_pgt - __START_KERNEL_map), %rax
1:

	/* Enable PAE and PSE, but defer PGE until kaiser_enabled is decided */
	movl	$(X86_CR4_PAE | X86_CR4_PSE), %ecx
	movq	%rcx, %cr4

	/* Setup early boot stage 4 level pagetables. */
	addq	phys_base(%rip), %rax
	movq	%rax, %cr3

	/* Ensure I am executing from virtual addresses */
	movq	$1f, %rax
	ANNOTATE_RETPOLINE_SAFE
	jmp	*%rax
1:

	/* Check if nx is implemented */
	movl	$0x80000001, %eax
	cpuid
	movl	%edx,%edi

	/* Setup EFER (Extended Feature Enable Register) */
	movl	$MSR_EFER, %ecx
	rdmsr
	btsl	$_EFER_SCE, %eax	/* Enable System Call */
	btl	$20,%edi		/* No Execute supported? */
	jnc     1f
	btsl	$_EFER_NX, %eax
	btsq	$_PAGE_BIT_NX,early_pmd_flags(%rip)
1:	wrmsr				/* Make changes effective */

	/* Setup cr0 */
#define CR0_STATE	(X86_CR0_PE | X86_CR0_MP | X86_CR0_ET | \
			 X86_CR0_NE | X86_CR0_WP | X86_CR0_AM | \
			 X86_CR0_PG)
	movl	$CR0_STATE, %eax
	/* Make changes effective */
	movq	%rax, %cr0

	/* Setup a boot time stack */
	movq initial_stack(%rip), %rsp

	/* zero EFLAGS after setting rsp */
	pushq $0
	popfq

	/*
	 * We must switch to a new descriptor in kernel space for the GDT
	 * because soon the kernel won't have access anymore to the userspace
	 * addresses where we're currently running on. We have to do that here
	 * because in 32bit we couldn't load a 64bit linear address.
	 */
	lgdt	early_gdt_descr(%rip)

	/* set up data segments */
	xorl %eax,%eax
	movl %eax,%ds
	movl %eax,%ss
	movl %eax,%es

	/*
	 * We don't really need to load %fs or %gs, but load them anyway
	 * to kill any stale realmode selectors.  This allows execution
	 * under VT hardware.
	 */
	movl %eax,%fs
	movl %eax,%gs

	/* Set up %gs.
	 *
	 * The base of %gs always points to the bottom of the irqstack
	 * union.  If the stack protector canary is enabled, it is
	 * located at %gs:40.  Note that, on SMP, the boot cpu uses
	 * init data section till per cpu areas are set up.
	 */
	movl	$MSR_GS_BASE,%ecx
	movl	initial_gs(%rip),%eax
	movl	initial_gs+4(%rip),%edx
	wrmsr

	/* rsi is pointer to real mode structure with interesting info.
	   pass it to C */
	movq	%rsi, %rdi

	/* Finally jump to run C code and to be on real kernel address
	 * Since we are running on identity-mapped space we have to jump
	 * to the full 64bit address, this is only possible as indirect
	 * jump.  In addition we need to ensure %cs is set so we make this
	 * a far return.
	 *
	 * Note: do not change to far jump indirect with


Available := c.cfg.PreimageDB.LookupPreimage(
		hash,
	)
	if preimageAvailable {
		return true, nil
	}

	// Then check if we have an invoice that can be settled by this HTLC.
	//
	// TODO(joostjager): Check that there are still more blocks remaining
	// than the invoice cltv delta. We don't want to go to chain only to
	// have the incoming contest resolver decide that we don't want to
	// settle this invoice.
	invoice, err := c.cfg.Registry.LookupInvoice(hash)
	switch err {
	case nil:
	case channeldb.ErrInvoiceNotFound, channeldb.ErrNoInvoicesCreated:
		return false, nil
	default:
		return false, err
	}

	preimageAvailable = invoice.Terms.PaymentPreimage != nil

	return preimageAvailable, nil
}

// checkLocalChainActions is similar to checkCommitChainActions, but it also
// examines the set of HTLCs on the remote party's commitment. This allows us
// to ensure we're able to satisfy the HTLC timeout constraints for incoming vs
// outgoing HTLCs.
func (c *ChannelArbitrator) checkLocalChainActions(
	height uint32, trigger transitionTrigger,
	activeHTLCs map[HtlcSetKey]htlcSet,
	commitsConfirmed bool) (ChainActionMap, error) {

	// First, we'll check our local chain actions as normal. This will only
	// examine HTLCs on our local commitment (timeout or settle).
	localCommitActions, err := c.checkCommitChainActions(
		height, trigger, activeHTLCs[LocalHtlcSet],
	)
	if err != nil {
		return nil, err
	}

	// Next, we'll examine the remote commitment (and maybe a dangling one)
	// to see if the set difference of our HTLCs is non-empty. If so, then
	// we may need to cancel back some HTLCs if we decide go to chain.
	remoteDanglingActions := c.checkRemoteDanglingActions(
		height, activeHTLCs, commitsConfirmed,
	)

	// Finally, we'll merge the two set of chain actions.
	localCommitActions.Merge(remoteDanglingActions)

	return localCommitActions, nil
}

// checkRemoteDanglingActions examines the set of remote commitments for any
// HTLCs that are close to timing out. If we find any, then we'll return a set
// of chain actions for HTLCs that are on our commitment, but not theirs to
// cancel immediately.
func (c *ChannelArbitrator) checkRemoteDanglingActions(
	height uint32, activeHTLCs map[HtlcSetKey]htlcSet,
	commitsConfirmed bool) ChainActionMap {

	var (
		pendingRemoteHTLCs []channeldb.HTLC
		localHTLCs         = make(map[uint64]struct{})
		remoteHTLCs        = make(map[uint64]channeldb.HTLC)
		actionMap          = make(ChainActionMap)
	)

	// First, we'll construct two sets of the outgoing HTLCs: those on our
	// local commitment, and those that are on the remote commitment(s).
	for htlcSetKey, htlcs := range activeHTLCs {
		if htlcSetKey.IsRemote {
			for _, htlc := range htlcs.outgoingHTLCs {
				remoteHTLCs[htlc.HtlcIndex] = htlc
			}
		} else {
			for _, htlc := range htlcs.outgoingHTLCs {
				localHTLCs[htlc.HtlcIndex] = struct{}{}
			}
		}
	}

	// With both sets constructed, we'll now compute the set difference of
	// our two sets of HTLCs. This'll give us the HTLCs that exist on the
	// remote commitment transaction, but not on ours.
	for htlcIndex, htlc := range remoteHTLCs {
		if _, ok := localHTLCs[htlcIndex]; ok {
			continue
		}

		pendingRemoteHTLCs = append(pendingRemoteHTLCs, htlc)
	}


data = (0..128)
        .map(|_| Bits::<8>::from(rand::random::<u8>()))
        .collect::<Vec<_>>();
    let data = rdata.clone();
    let mut sim = Simulation::new();
    sim.add_clock(5, |x: &mut Box<HLSFIFOTest>| x.clock.next = !x.clock.val());
    sim.add_testbench(move |mut sim: Sim<HLSFIFOTest>| {
        let mut x = sim.init()?;
        wait_clock_true!(sim, clock, x);
        for sample in &rdata {
            x = sim.watch(|x| !x.fifo.bus_write.full.val(), x)?;
            x.fifo.bus_write.data.next = (*sample).into();
            x.fifo.bus_write.write.next = true;
            wait_clock_cycle!(sim, clock, x);
            x.fifo.bus_write.write.next = false;
            if rand::thread_rng().gen::<f64>() < 0.3 {
                for _ in 0..(rand::thread_rng().gen::<u8>() % 40) {
                    wait_clock_cycle!(sim, clock, x);
                }
            }
        }
        sim.done(x)
    });
    sim.add_testbench(move |mut sim: Sim<HLSFIFOTest>| {
        let mut x = sim.init()?;
        wait_clock_true!(sim, clock, x);
        for sample in &data {
            x = sim.watch(|x| !x.fifo.bus_read.empty.val(), x)?;
            sim_assert!(sim, x.fifo.bus_read.data.val() == *sample, x);
            x.fifo.bus_read.read.next = true;
            wait_clock_cycle!(sim, clock, x);
            x.fifo.bus_read.read.next = false;
            if rand::thread_rng().gen::<f64>() < 0.3 {
                for _ in 0..(rand::thread_rng().gen::<u8>() % 40) {
                    wait_clock_cycle!(sim, clock, x);
                }
            }
        }
        sim.done(x)
    });
    sim.run_traced(
        Box::new(uut),
        100_000,
        std::fs::File::create(vcd_path!("hls_fifo.vcd")).unwrap(),
    )
    .unwrap();
}

#[derive(LogicBlock)]
struct FIFOTestFixture {
    feeder: LazyFIFOFeeder<Bits<8>, 10>,
    fifo: SyncFIFO<Bits<8>, 4, 5, 1>,
    reader: LazyFIFOReader<Bits<8>, 10>,
    clock: Signal<In, Clock>,
}

impl Logic for FIFOTestFixture {
    #[hdl_gen]
    fn update(&mut self) {
        self.feeder.clock.next = self.clock.val();
        self.reader.clock.next = self.clock.val();
        self.fifo.clock.next = self.clock.val();
        self.feeder.bus.join(&mut self.fifo.bus_write);
        self.reader.bus.join(&mut self.fifo.bus_read);
    }
}

impl FIFOTestFixture {
    pub fn new(data: &[Bits<8>]) -> FIFOTestFixture {
        FIFOTestFixture {
            feeder: LazyFIFOFeeder::new(
                data.clone(),
                &(0..data.len())
                    .map(|_| fifo_tester::bursty_rand())
                    .collect::<Vec<_>>(),
            ),
            fifo: SyncFIFO::default(),
            reader: LazyFIFOReader::new(
                data.clone(),
                &(0..data.len())
                    .map(|_| fifo_te


#Inicializa a lista de inventário e a variável de resposta
inventario = []
resposta = "S"

#Loop para adicionar equipamentos ao inventário
while resposta == "S":

    #Solicita ao usuário que insira detalhes do equipamento
    equipamento = [input("Equipamento: "),
                   float(input("Valor: ")),
                   int(input("Número Serial: ")),
                   input("Departamento: ")]

    #Adiciona o equipamento ao inventário
    inventario.append(equipamento)

    #Pergunta ao usuário se deseja continuar
    resposta = input("Digite \"S\" para continuar: ").upper()

#Imprime todos os equipamentos no inventário
for elemento in inventario:
    print("Nome.........: ", elemento[0])
    print("Valor........: ", elemento[1])
    print("Serial.......: ", elemento[2])
    print("Departamento.: ", elemento[3])

#Solicita ao usuário que digite o nome do equipamento que deseja buscar
busca = input("\nDigite o nome do equipamento que deseja buscar: ")

#Busca o equipamento no inventário
for elemento in inventario:
    if busca == elemento[0]:
        print("Valor..: ", elemento[1])
        print("Serial.: ", elemento[2])

#Solicita ao usuário que digite o nome do equipamento que será depreciado
depreciacao = input("\nDigite o nome do equipamento que será depreciado: ")

#Deprecia o equipamento no inventário
for elemento in inventario:
    if busca == elemento[0]:
        print("Valor antigo: ", elemento[1])
        elemento[1] = elemento[1] * 0.9
        print("Novo valor: ", elemento[1])

#Solicita ao usuário que digite o serial do equipamento que será excluído
serial = int(input("\nDigite o serial do equipamento que será excluido: "))

#Exclui o equipamento do inventário
for elemento in inventario:
    if elemento[2] == serial:
        inventario.remove(elemento)

#Imprime todos os equipamentos restantes no inventário após a exclusão
for elemento in inventario:
    print("Nome.........: ", elemento[0])
    print("Valor........: ", elemento[1])
    print("Serial.......: ", elemento[2])
    print("Departamento.: ", elemento[3])

#Calcula e imprime o valor do equipamento mais caro, o mais barato
#e o total de equipamentos no inventário
valores = []
for elemento in inventario:
    valores.append(elemento[1])
if len(valores) > 0:
    print("O equipamento mais caro custa: ", max(valores))
    print("O equipamento mais barato custa: ", min(valores))
    print("O total de equipamento é de: ", sum(valores))


 #0
	# d8 := acc01
	VMOV.I16  d8, #0
	# d9 := acc02
	VMOV.I16  d9, #0

	# d10 := acc10
	VMOV.I16 d10, #0
	# d11 := acc11
	VMOV.I16 d11, #0
	# d12 := acc12
	VMOV.I16 d12, #0

	# d13 := acc20
	VMOV.I16 d13, #0
	# d14 := acc21
	VMOV.I16 d14, #0
	# d15 := acc22
	VMOV.I16 d15, #0

	.align 4
0:
	# Load a0, a1, a2
	# - d0 = a0
	# - d1 = a1
	# - d2 = a2
	VLD1.16 {d0-d2}, [r2:64]!

	# Load b0, b1, b2
	# - d4 = b0
	# - d5 = b1
	# - d6 = b2
	VLD1.16 {d4-d6}, [r3:64]!

	# VFMA.F16  d7, d0, d4
	.word 0xF2107C14
	# VFMA.F16 d10, d1, d4
	.word 0xF211AC14
	# VFMA.F16 d13, d2, d4
	.word 0xF212DC14

	# VFMA.F16  d8, d0, d5
	.word 0xF2108C15
	# VFMA.F16 d11, d1, d5
	.word 0xF211BC15
	# VFMA.F16 d14, d2, d5
	.word 0xF212EC15

	# VFMA.F16  d9, d0, d6
	.word 0xF2109C16
	# VFMA.F16 d12, d1, d6
	.word 0xF211CC16
	# VFMA.F16 d15, d2, d6
	.word 0xF212FC16

	SUBS r0, r0, #1
	BNE 0b

	# Load arguments:
	# - r2 = c
	# - r3 = row_stride_c
	LDRD r2, r3, [sp, #64]
	# Check if c is updated (r1 != 0) or overwritten (r1 == 0)
	CMP r1, #0
	# Convert row_stride_c (stride in elements) to stride in bytes
	ADD r3, r3, r3
	# Skip to label 1 to update c
	BNE 1f

	##### Overwrite c matrix with results in acc[0:3][0:16]

	# Overwrite c[0][0:12] = acc[0][0:12]
	VST1.16   {d7-d9}, [r2:64], r3

	# Overwrite c[1][0:12] = acc[1][0:12]
	VST1.16 {d10-d12}, [r2:64], r3

	# Overwrite c[2][0:12] = acc[2][0:12]
	VST1.16 {d13-d15}, [r2:64]

	VPOP {d8-d15}
	BX lr

1:
	##### Accumulate c matrix with results in acc[0:3][0:12]

	# Accumulate c[0][0:12] += acc[0][0:12]
	VLD1.16 {d0-d2}, [r2:64]
	# VADD.F16 d0, d0, d7
	.word 0xF2100D07
	# VADD.F16 d1, d1


iption',
    icon: Icons.bug_report,
    color: Colors.teal,
  ),
  'special.moderator': BadgeInfo(
    type: 'special.moderator',
    name: 'moderatorBadgeName',
    description: 'moderatorBadgeDescription',
    icon: Icons.construction,
    color: Colors.indigo,
  ),
  'special.developer': BadgeInfo(
    type: 'special.developer',
    name: 'developerBadgeName',
    description: 'developerBadgeDescription',
    icon: Icons.code,
    color: Colors.indigo,
  ),
  'special.translator': BadgeInfo(
    type: 'special.translator',
    name: 'translatorBadgeName',
    description: 'translatorBadgeDescription',
    icon: Icons.code,
    color: Colors.grey,
  ),
};
// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'chat.dart';

// **************************************************************************
// JsonSerializableGenerator
// **************************************************************************

_SnChatRoom _$SnChatRoomFromJson(Map<String, dynamic> json) => _SnChatRoom(
  id: json['id'] as String,
  name: json['name'] as String?,
  description: json['description'] as String?,
  type: (json['type'] as num).toInt(),
  isPublic: json['is_public'] as bool? ?? false,
  isCommunity: json['is_community'] as bool? ?? false,
  picture:
      json['picture'] == null
          ? null
          : SnCloudFile.fromJson(json['picture'] as Map<String, dynamic>),
  background:
      json['background'] == null
          ? null
          : SnCloudFile.fromJson(json['background'] as Map<String, dynamic>),
  realmId: json['realm_id'] as String?,
  realm:
      json['realm'] == null
          ? null
          : SnRealm.fromJson(json['realm'] as Map<String, dynamic>),
  createdAt: DateTime.parse(json['created_at'] as String),
  updatedAt: DateTime.parse(json['updated_at'] as String),
  deletedAt:
      json['deleted_at'] == null
          ? null
          : DateTime.parse(json['deleted_at'] as String),
  members:
      (json['members'] as List<dynamic>?)
          ?.map((e) => SnChatMember.fromJson(e as Map<String, dynamic>))
          .toList(),
);

Map<String, dynamic> _$SnChatRoomToJson(_SnChatRoom instance) =>
    <String, dynamic>{
      'id': instance.id,
      'name': instance.name,
      'description': instance.description,
      'type': instance.type,
      'is_public': instance.isPublic,
      'is_community': instance.isCommunity,
      'picture': instance.picture?.toJson(),
      'background': instance.background?.toJson(),
      'realm_id': instance.realmId,
      'realm': instance.realm?.toJson(),
      'created_at': instance.createdAt.toIso8601String(),
      'updated_at': instance.updatedAt.toIso8601String(),
      'deleted_at': instance.deletedAt?.toIso8601String(),
      'members': instance.members?.map((e) => e.toJson()).toList(),
    };

_SnChatMessage _$SnChatMessageFromJson(Map<String, dynamic> json) =>
    _SnChatMessage(
      createdAt: DateTime.parse(json['created_at'] as String),
      updatedAt: DateTime.parse(json['updated_at'] as String),
      deletedAt:
          json['deleted_at'] == null
              ? null
              : DateTime.parse(json['deleted_at'] as String),


multiclass MLModel uses the F1 score
/// technique to measure performance.
///

///

/// For more information about performance metrics, please see the Amazon Machine
/// Learning Developer Guide.
class PerformanceMetrics {
  final Map<String, String>? properties;

  PerformanceMetrics({
    this.properties,
  });

  factory PerformanceMetrics.fromJson(Map<String, dynamic> json) {
    return PerformanceMetrics(
      properties: (json['Properties'] as Map<String, dynamic>?)
          ?.map((k, e) => MapEntry(k, e as String)),
    );
  }

  Map<String, dynamic> toJson() {
    final properties = this.properties;
    return {
      if (properties != null) 'Properties': properties,
    };
  }
}

class PredictOutput {
  final Prediction? prediction;

  PredictOutput({
    this.prediction,
  });

  factory PredictOutput.fromJson(Map<String, dynamic> json) {
    return PredictOutput(
      prediction: json['Prediction'] != null
          ? Prediction.fromJson(json['Prediction'] as Map<String, dynamic>)
          : null,
    );
  }

  Map<String, dynamic> toJson() {
    final prediction = this.prediction;
    return {
      if (prediction != null) 'Prediction': prediction,
    };
  }
}

/// The output from a Predict operation:
///
///

///

/// Details - Contains the following attributes:
/// DetailsAttributes.PREDICTIVE_MODEL_TYPE - REGRESSION | BINARY |
/// MULTICLASS DetailsAttributes.ALGORITHM - SGD
///

///

/// PredictedLabel - Present for either a BINARY or
/// MULTICLASS MLModel request.
///

///

/// PredictedScores - Contains the raw classification score
/// corresponding to each label.
///

///

/// PredictedValue - Present for a REGRESSION
/// MLModel request.
///

///

class Prediction {
  final Map<DetailsAttributes, String>? details;

  /// The prediction label for either a BINARY or
  /// MULTICLASS MLModel.
  final String? predictedLabel;
  final Map<String, double>? predictedScores;

  /// The prediction value for REGRESSION MLModel.
  final double? predictedValue;

  Prediction({
    this.details,
    this.predictedLabel,
    this.predictedScores,
    this.predictedValue,
  });

  factory Prediction.fromJson(Map<String, dynamic> json) {
    return Prediction(
      details: (json['details'] as Map<String, dynamic>?)?.map(
          (k, e) => MapEntry(DetailsAttributes.fromString(k), e as String)),
      predictedLabel: json['predictedLabel'] as String?,
      predictedScores: (json['predictedScores'] as Map<String, dynamic>?)
          ?.map((k, e) => MapEntry(k, e as double)),
      predictedValue: json['predictedValue'] as double?,
    );
  }

  Map<String, dynamic> toJson() {
    final details = this.details;
    final predictedLabel = this.predictedLabel;
    final predictedScores = this.predictedScores;
    final predictedValue = this.predictedValue;
    return {
      if (details != null)
        'details': details.map((k, e) => MapEntry(k.value, e)),
      if (predictedLabel != null) 'predictedLabel': predictedLabel,
      if (predictedScores != null) 'predictedScores': predictedScores


#!/usr/bin/env python3
'''Task 12's module.
'''
from typing import List, Tuple

def zoom_array(lst: Tuple, factor: int = 2) -> List:
    '''
    creates multiple copies of items in a tuple.
    '''

    zoomed_in: List = [
        item for item in lst
        for i in range(int(factor))
    ]
    return zoomed_in

array = (12, 72, 91)

zoom_2x = zoom_array(array)

zoom_3x = zoom_array(array, 3)


['name'];
          });
      } else {
        if (roomname == roomBC.extra['name']) {
          if (mounted)
            setState(() {
              roomname = "";
            });
        }
      }
    });

    // ciziten.glb holds all the animations so load the actor without adding to the scene yet so can share animations with other actors
    Group seller =
    await OPENWORLD.Actor.createActor('assets/actors/citizen/citizen.glb',
        texture: "assets/actors/citizen/bodyc4.png",
        z: actoroffset);

    // Load shofar actor using the sellers animations
    _shofar = await OPENWORLD.Actor.createActor(
        'assets/actors/shofar/shofar.glb',
        z: actoroffset,
        shareanimations: seller,
        randomduration: 0.1);

    // Have the shofar wield a horn
    var horn = await OPENWORLD.Model.createModel(
        'assets/actors/shofar/horn.glb');

    OPENWORLD.Actor.wield(_shofar, horn, "Bip01_R_Hand");

    // Set the shofar to be the default size
    setActorSize(_shofar);

    // Set the position of the shofar
    OPENWORLD.Space.worldToLocalSurfaceObjHide(
        _shofar, 7.7, 1.8, 0, 3, lerpopacity: 1); //7.7, 2.0, 0, 3);  //3.42);
    scene.add(_shofar);
    // Set the direction the shofar is facing
    OPENWORLD.Space.objTurn(_shofar, 180); // south
    // When player goes near the shofar and the player has gabriels prayer then remind player to say the prayer at the perpetual flame
    OPENWORLD.BaseObject.setDistanceTrigger(_shofar, dist: 1.5);
    _shofar.extra['trigger'].addEventListener('trigger',
            (THREE.Event event) async {
          if (event.action) {
            if (hasprayer && !inprayer && !_canfly) {
              var speech = [
                "Say the prayer at the eternal flame"
              ];
              OPENWORLD.Mob.setSpeech(
                  _shofar,
                  speech,
                  z: 90,
                  //scale: 0.3,
                  width: 300);
            }
          }
        });

    // Define the joystick
    _joystick = OPENWORLD.VirtualJoystick();
    _joystick?.joysticksize = 200;

    var fpsControl = PointerLockControls(camera, _globalKey);

    fpsControl.domElement.addEventListener('keyup', (event) {
      _joystick?.keyboard.onKeyChange(event, 'keyup');
    }, false);
    fpsControl.domElement.addEventListener('keydown', (event) {
      _joystick?.keyboard.onKeyChange(event, 'keydown');
    }, false);
    fpsControl.domElement.addEventListener('pointerdown', (event) {
      pointerdowntick = OPENWORLD.System.currentMilliseconds();
      _joystick?.onTouchDown(event.clientX, event.clientY);
    }, false);
    fpsControl.domElement.addEventListener('pointerup', (event) {
      var numpoints;
      numpoints = 2;

      if (!OPENWORLD.BaseObject.touchup(
          pointerdowntick, event, scene, width, height, numpoints)) {
        //   OPENWORLD.BaseObject.setHighLights(scale:1.000005,opacity:0.5);//hidehighlights();
        OPENWORLD.BaseObject.deselectHighLights(); //hidehighlights();
        setState(() {
          menuposx = -1;
        });
      }
    }, false);
    fpsControl.domElement.addEventListener('pointerdown', (event) {
      _joystick?.onTouchDown(event.clientX, event.clientY);
    }, false);

    fpsControl.domElement.addEv


ectionChanged += (_, __) => MoveToResource_PreferedReplacementPatternIndex_Changed();
        MoveToResourcePreferedReplacementPatternIndex.PropertyChanged += (_, __) => MoveToResource_PreferedReplacementPatternIndex_Changed();

        MoveToResourcePreferedKeyPatternIndex.CollectionChanged += (_, __) => MoveToResource_PreferedKeyPatternIndex_Changed();
        MoveToResourcePreferedKeyPatternIndex.PropertyChanged += (_, __) => MoveToResource_PreferedKeyPatternIndex_Changed();
    }

    public ObservableIndexer<string, int> MoveToResourcePreferedReplacementPatternIndex { get; } = new(_ => 0);

    public ObservableIndexer<string, int> MoveToResourcePreferedKeyPatternIndex { get; } = new(_ => 0);

    private void MoveToResource_PreferedReplacementPatternIndex_Changed()
    {
        MoveToResourcePreferedReplacementPatterns = JsonConvert.SerializeObject(MoveToResourcePreferedReplacementPatternIndex);
    }

    private void MoveToResource_PreferedKeyPatternIndex_Changed()
    {
        MoveToResourcePreferedKeyPatterns = JsonConvert.SerializeObject(MoveToResourcePreferedKeyPatternIndex);
    }
}


#pragma once

#include "f4se_common/Relocation.h"
#include "f4se/GameEvents.h"
#include "f4se/GameInput.h"
#include "f4se/NiTypes.h"

class NiNode;
class TESCameraState;

// 24
class TESCameraState : public BSIntrusiveRefCounted, public BSInputEventUser
{
public:
	virtual ~TESCameraState();

	virtual void Unk_09();
	virtual void Unk_0A();
	virtual void Unk_0B(void * arg);
	virtual void GetRotation(NiQuaternion * out);
	virtual void GetPosition(NiPoint3 * out);
	virtual void Unk_0E();
	virtual void Unk_0F();
	virtual void Unk_10();

	void	* unk18;	// 18
	UInt32	stateID;	// 20
	UInt32	pad24;		// 24
};

STATIC_ASSERT(sizeof(TESCameraState) == 0x28);

// 138
class ThirdPersonState : public TESCameraState
{
public:
	virtual ~ThirdPersonState();

	virtual void UpdateMode(bool weaponDrawn);
	virtual bool Unk_12();
	virtual void Unk_13();
	virtual void Unk_14();
	virtual void Unk_15();
};

// 38
class TESCamera
{
public:
	virtual ~TESCamera();

	virtual void SetCameraNode(NiNode * node);
	virtual void Unk_02(UInt8 unk1); // Sets 0x30
	virtual void Unk_03();

	float	unk08;	// 08
	float	unk0C;	// 0C
	float	unk10;	// 10
	float	unk14;	// 14
	float	unk18;	// 18
	UInt32	unk1C;	// 1C
	NiNode			* cameraNode;	// 20
	TESCameraState	* cameraState;	// 28
	UInt8	unk30;		// 30
	UInt8	unk31;		// 31
	UInt16	unk32;		// 32
	UInt32	unk34;		// 34

	MEMBER_FN_PREFIX(TESCamera);
	DEFINE_MEMBER_FN(SetCameraState, void, 0x007D4340, TESCameraState * cameraState);
};

class PlayerCamera : public TESCamera
{
public:
	virtual ~PlayerCamera();

	enum
	{
		kCameraState_FirstPerson = 0,
		kCameraState_AutoVanity,
		kCameraState_VATS,
		kCameraState_Free,
		kCameraState_IronSights,
		kCameraState_Transition,
		kCameraState_TweenMenu,
		kCameraState_ThirdPerson1,
		kCameraState_ThirdPerson2,
		kCameraState_Furniture,
		kCameraState_Horse,
		kCameraState_Bleedout,
		kCameraState_Dialogue,
		kNumCameraStates
	};

	BSInputEventReceiver				inputEventReceiver;				// 38
	BSTEventSink<void>					idleInputSink;					// 48
	BSTEventSink<UserEventEnabledEvent>	userEventEnabledSink;			// 50
	BSTEventSink<void>					otherEventEnabledSink;			// 58

	UInt32	unk60;	// 60
	UInt32	unk64;	// 64 - Handle
	UInt32	unk68;	// 68
	UInt32	unk6C;	// 6C

	UInt64	unk70[(0xE0 - 0x70) >> 3];

	TESCameraState * cameraStates[kNumCameraStates];	// E0
	UInt64			unk148;								// 148
	UInt64			unk150;								// 150 - hknpSphereShape
	UInt64			unk158;								// 158 - hknpBSWorld
	UInt32			unk160;								// 160
	UInt32			unk164;								// 164 - Handle
	float			fDefaultWorldFov;					// 168 - fDefaultWorldFOV:Display
	float			fDefault1stPersonFOV;				// 16C - fDefault1stPersonFOV:Display
	UInt64			unk170;								// 170
	UInt64			unk178;								// 178
	float			unk180;								// 180
	float			unk184;								// 184
	float			unk188;								// 188
	float			unk18C;								// 18C
	float			unk190;								// 190
	float			unk194;								// 194
	float			unk198;								// 198
	float			unk19C;								// 19C
	SInt32			unk1A0;								// 1A0
	UInt8			unk1A4;								// 1A4
	UInt8			unk1A5;								// 1A5
	UInt8			unk1A6;								// 1A6
	UInt8			unk1A7;								// 1A7
	UInt8			unk1A8;								// 1A8
	UInt8			unk1A9;								// 1A9

	SInt32 GetCameraStateId(TESCameraState * state);
};
STATIC_ASSERT(offsetof(PlayerCamera, cameraStates) == 0xE0);
STATIC_ASSERT(offsetof(PlayerCamera, unk148) == 0x148);

extern RelocPtr <PlayerCamera *> g_playerCamera;


; - - - - - - - - - - - - -
	Rbsr	L_GetScreen0
	moveq	#0,d3
	move.w	EcTy(a0),d3
	Ret_Int
; - - - - - - - - - - - - -
	Lib_Par	FnScreenHeight1
; - - - - - - - - - - - - -
	move.l	d3,d1
	Rbsr	L_CheckScreenNumber
	EcCall	AdrEc
	Rbeq	L_ScNOp
	move.l	d0,a0
	moveq	#0,d3
	move.w	EcTy(a0),d3
	Ret_Int
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; 					SCREEN WIDTH
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	Lib_Par	FnScreenWidth0
; - - - - - - - - - - - - -
	Rbsr	L_GetScreen0
	moveq	#0,d3
	move.w	EcTx(a0),d3
	Ret_Int
; - - - - - - - - - - - - -
	Lib_Par	FnScreenWidth1
; - - - - - - - - - - - - -
	move.l	d3,d1
	Rbsr	L_CheckScreenNumber
	EcCall	AdrEc
	Rbeq	L_ScNOp
	move.l	d0,a0
	moveq	#0,d3
	move.w	EcTx(a0),d3
	Ret_Int
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; 					SCREEN BASE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	Lib_Par	FnScreenBase
; - - - - - - - - - - - - -
	Rbsr	L_GetScreen0
	move.l	a0,d3
	Ret_Int
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; 					SCREEN COLOUR
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	Lib_Par	FnScreenColour
; - - - - - - - - - - - - -
	Rbsr	L_GetScreen0
	moveq	#0,d3
	move.w	EcNbCol(a0),d3
	btst	#3,EcCon0(a0)
	beq.s	.Skip
	move.l	#4096,d3
.Skip	Ret_Int
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; 					SCREEN MODE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	Lib_Par	FnScreenMode
; - - - - - - - - - - - - -
	Rbsr	L_GetScreen0
	moveq	#0,d3
	move.w	EcCon0(a0),d3
	and.l	#$00008004,d3
	rts
; - - - - - - - - - - - - -
	Lib_Def	GetScreen0
; - - - - - - - - - - - - -
	move.l	ScOnAd(a5),d0
	Rbe


ு உண்மைகள் ":  {" கார்போஹைட்ரேட்டுகள் ":" 17 கிராம் "," புரதங்கள் ":" 0.6 கிராம் "," கொழுப்புகள் ":" 0.4 கிராம் "," ஆற்றல் ":" 67 கிலோகலோரி "}}];

// List p = [

// {"name": "துவரம்பருப்பு", "image": "lib/assets/Legume/1.jpg", "use": "இது தமிழ்நாட்டில் துவாரம் பருப்பு என்றும், கேரளாவில் துவாரா பரிப்பு என்றும் அழைக்கப்படுகிறது, மேலும் இது முக்கிய மூலப்பொருள் டிஷ் சாம்பார். கர்நாடகாவில் இது டோகரி பீல் என்றும் பிசி பீல் குளியல் ஒரு முக்கிய மூலப்பொருள் என்றும் அழைக்கப்படுகிறது. இது தெலுங்கில் காந்தி பப்பு என்று அழைக்கப்படுகிறது மற்றும் இது ஒரு பிரதான டிஷ் பப்பு சாரு தயாரிப்பில் பயன்படுத்தப்படுகிறது. "," ஊட்டச்சத்து உண்மைகள் ":  { "கார்போஹைட்ரேட்டுகள்": "93 கிராம்", "புரதங்கள்": "15 கிராம்", "கொழுப்புகள்": "1 கிராம்", "ஆற்றல்": "400 கிலோகலோரி"}},

// {"name": "கடலைபருப்பு","image": "lib/assets/Legume/2.jpg", "use": "வங்காள


from arabic_reshaper.reshaper_config import default_config
from django.contrib import admin
from django.contrib.admin.apps import AdminConfig

from employee.admin.employee.extra_url.formal_view import EmployeeNearbySummery

from employee.models import BookConferenceRoom

class CustomAdminSite(admin.AdminSite):
    def each_context(self, request):
        employee_formal_summery = EmployeeNearbySummery()
        context = dict(
            super().each_context(request),
            leaves=employee_formal_summery.employee_leave_nearby,
            birthdays=employee_formal_summery.birthdays,
            increments=employee_formal_summery.increments,
            increments=employee_formal_summery.last_salary_change,
            permanents=employee_formal_summery.permanents,
            anniversaries=employee_formal_summery.anniversaries,
            conference_room_bookings=BookConferenceRoom.objects.all()
        )
        return context

class MyAdminConfig(AdminConfig):
    default_site = CustomAdminSite

admin_site = CustomAdminSite(name='myadmin')