		string inputPortLocalVar = m_inputPorts[ i ].Name + OutputId;
								string nameToReplaceRegex = string.Format( VarRegexReplacer, m_inputPorts[ i ].Name );
								localCode = Regex.Replace( localCode, nameToReplaceRegex, inputPortLocalVar, RegexOptions.Multiline );
								//localCode = localCode.Replace( m_inputPorts[ i ].Name, inputPortLocalVar );

								if( m_inputPorts[ i ].IsConnected )
								{
									string result = m_inputPorts[ i ].GenerateShaderForOutput( ref dataCollector, m_inputPorts[ i ].DataType, true, true );
									if( m_inputPorts[ i ].DataType == WirePortDataType.OBJECT )
									{
										dataCollector.AddLocalVariable( UniqueId, m_items[ idx ].CustomType + " " + inputPortLocalVar, result + ";" );
									}
									else
									{
										dataCollector.AddLocalVariable( UniqueId, CurrentPrecisionType, m_inputPorts[ i ].DataType, inputPortLocalVar, result );
									}
								}
								else
								{
									if( m_inputPorts[ i ].DataType == WirePortDataType.OBJECT )
									{
										dataCollector.AddLocalVariable( UniqueId, m_items[ idx ].CustomType + " " + inputPortLocalVar, m_inputPorts[ i ].WrappedInternalData + ";" );
									}
									else
									{
										dataCollector.AddLocalVariable( UniqueId, CurrentPrecisionType, m_inputPorts[ i ].DataType, inputPortLocalVar, m_inputPorts[ i ].WrappedInternalData );
									}
								}

								if( m_items[ idx ].Qualifier != VariableQualifiers.In )
								{
									OutputPort currOutputPort = GetOutputPortByUniqueId( CreateOutputId( m_inputPorts[ i ].PortId ) );
									currOutputPort.SetLocalValue( inputPortLocalVar, dataCollector.PortCategory );
								}
							}
							else
							{
								// Not Unique
								string result = m_inputPorts[ i ].GenerateShaderForOutput( ref dataCollector, m_inputPorts[ i ].DataType, true, true );
								string nameToReplaceRegex = string.Format( VarRegexReplacer, m_inputPorts[ i ].Name );
								localCode = Regex.Replace( localCode, nameToReplaceRegex, result, RegexOptions.Multiline );
								//localCode = localCode.Replace( m_inputPorts[ i ].Name, result );
							}
						}
						string[] codeLines = localCode.Split( '\n' );
						for( int codeIdx = 0; codeIdx < codeLines.Length; codeIdx++ )
						{
							dataCollector.AddLocalVariable( 0, codeLines[ codeIdx ], true );
						}
					}
					else
					{
						string function = WrapCodeInFunction( dataCollector.IsTemplate, expressionName, true );

						string functionCall = expressionName + "( ";
						for( int i = m_firstAvailablePort; i < count; i++ )
						{
							if( UIUtils.CurrentWindow.OutsideGraph.SamplingMacros && !UIUtils.CurrentWindow.OutsideGraph.IsSRP )
							{
								// we don't know what kind of sampling the user will do so we add all of them
								GeneratorUtils.AddCustomStandardSamplingMacros( ref dataCollector, m_inputPorts[ i ].DataType, MipType.Auto );
								GeneratorUtils.AddCustomStandardSamplingMacros( ref dataCollector, m_inputPorts[ i ].DataType, MipType.MipLevel );
								GeneratorUtils.AddCustomStandardSamplingMacros( ref dataCollector, m_inputPorts[ i ].DataType, MipType.MipBias );
								GeneratorUtils.AddCustomStandardSamplingMacros( ref dataCollector, m_inputPorts[ i ].DataType, MipType.Derivative );
							}

							string input


        insertAndAssert(uuid = value) { row ->
            assertEquals(value, row.uuid("val_uuid"))
        }
    }
}/*
 * Copyright 2024 Sergio Belda
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package dev.sergiobelda.compose.vectorize.generator

import com.squareup.kotlinpoet.ClassName
import com.squareup.kotlinpoet.MemberName

/**
 * Package names used for image generation.
 */
enum class PackageNames(val packageName: String) {
    ComposeVectorizeCore("dev.sergiobelda.compose.vectorize.core"),
    GraphicsPackage("androidx.compose.ui.graphics"),
    Material3Package("androidx.compose.material3"),
    VectorPackage(GraphicsPackage.packageName + ".vector"),
}

/**
 * [ClassName]s used for image generation.
 */
object ClassNames {
    val ImageVector = PackageNames.VectorPackage.className("ImageVector")

    val PathFillType = PackageNames.GraphicsPackage.className("PathFillType", "Companion")
    val StrokeCapType = PackageNames.GraphicsPackage.className("StrokeCap", "Companion")
    val StrokeJoinType = PackageNames.GraphicsPackage.className("StrokeJoin", "Companion")

    val MaterialTheme = PackageNames.Material3Package.className("MaterialTheme")
}

/**
 * [ClassName]s used as Annotation for image generation.
 */
object AnnotationNames {
    val Composable = ClassName("androidx.compose.runtime", "Composable")
}

/**
 * [MemberName]s used for image generation.
 */
object MemberNames {
    val Material3ColorScheme = MemberName(ClassNames.MaterialTheme, "colorScheme")

    val ImageVector = MemberName(
        PackageNames.ComposeVectorizeCore.packageName,
        "imageVector",
    )

    val Color = MemberName(PackageNames.GraphicsPackage.packageName, "Color")
    val SolidColor = MemberName(PackageNames.GraphicsPackage.packageName, "SolidColor")

    val Group = MemberName(PackageNames.VectorPackage.packageName, "group")
    val Path = MemberName(PackageNames.VectorPackage.packageName, "path")

    object PathFillType {
        val EvenOdd = MemberName(ClassNames.PathFillType, "EvenOdd")
    }

    object StrokeCapType {
        val Butt = MemberName(ClassNames.StrokeCapType, "Butt")
        val Round = MemberName(ClassNames.StrokeCapType, "Round")
        val Square = MemberName(ClassNames.StrokeCapType, "Square")
    }

    object StrokeJoinType {
        val Bevel = MemberName(ClassNames.StrokeJoinType, "Bevel")
        val Miter = MemberName(ClassNames.StrokeJoinType, "Miter")
        val Round = MemberName(ClassNames.StrokeJoinType, "Round")
    }
}

/**
 * @return the [ClassName] of the given [classNames] inside this package.
 */
fun PackageNames.className(vararg classNames: String) = ClassName(this.packageName, *classNames)
/*
 * Copyright 2024 Sergio Belda
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WIT


7:00.000Z-Xaosflux-2019-08-16T13:37:00.000Z">Guy Macon (talk) 13:47, 16 August 2019 (UTC)(discussiontools-replybutton)

Having the editor work differently in draft space and main space does not strike me as a desirable feature. Explaining the buttons better seems superior to removing them. —Kusma (t·c) 13:58, 16 August 2019 (UTC)<span class="ext-discussiontools-init-replybutton oo-ui-widget oo-ui-widget-enabled oo-ui-buttonElement oo-ui-buttonElement-frameless oo-ui-labelElement oo-ui-flaggedElement-progressive o


 80(%ecx)
fmull 104(%esp)
faddp %st(0),%st(1)
fldl 64(%ecx)
fmull -128(%edx)
fldl 96(%ecx)
fmull 80(%esp)
faddp %st(0),%st(3)
fldl 88(%ecx)
fmull 96(%esp)
faddp %st(0),%st(2)
fldl 72(%ecx)
fmull 120(%esp)
faddp %st(0),%st(1)
fldl 104(%ecx)
fmull 72(%esp)
faddp %st(0),%st(3)
fldl 96(%ecx)
fmull 88(%esp)
faddp %st(0),%st(2)
fldl 80(%ecx)
fmull 112(%esp)
faddp %st(0),%st(1)
fldl 112(%ecx)
fmull 64(%esp)
faddp %st(0),%st(3)
fldl 104(%ecx)
fmull 80(%esp)
faddp %st(0),%st(2)
fldl 88(%ecx)
fmull 104(%esp)
faddp %st(0),%st(1)
fldl 120(%ecx)
fmull 56(%esp)
faddp %st(0),%st(3)
fldl 112(%ecx)
fmull 72(%esp)
faddp %st(0),%st(2)
fldl 96(%ecx)
fmull 96(%esp)
faddp %st(0),%st(1)
fldl 72(%ecx)
fmull -128(%edx)
fldl 104(%ecx)
fmull 88(%esp)
faddp %st(0),%st(2)
fldl 120(%ecx)
fmull 64(%esp)
faddp %st(0),%st(3)
fldl crypto_scalarmult_curve25519_athlon_alpha230
fadd %st(4),%st(0)
fldl 80(%ecx)
fmull 120(%esp)
faddp %st(0),%st(2)
fldl 112(%ecx)
fmull 80(%esp)
faddp %st(0),%st(3)
fldl 128(%ecx)
fmull 56(%esp)
faddp %st(0),%st(4)
fsubl crypto_scalarmult_curve25519_athlon_alpha230
fldl 88(%ecx)
fmull 112(%esp)
faddp %st(0),%st(2)
fldl 80(%ecx)
fmull -128(%edx)
fldl 120(%ecx)
fmull 72(%esp)
faddp %st(0),%st(4)
fxch %st(1)
fadd %st(0),%st(4)
fldl 96(%ecx)
fmull 104(%esp)
faddp %st(0),%st(3)
fldl 88(%ecx)
fmull 120(%esp)
faddp %st(0),%st(2)
fsubrp %st(0),%st(5)
fldl crypto_scalarmult_curve25519_athlon_alpha255
fadd %st(4),%st(0)
fldl 104(%ecx)
fmull 96(%esp)
faddp %st(0),%st(3)
fldl 96(%ecx)
fmull 112(%esp)
faddp %st(0),%st(2)
fldl 128(%ecx)
fmull 64(%esp)
faddp %st(0),%st(4)
fsubl crypto_scalarmult_curve25519_athlon_alpha255
fldl 112(%ecx)
fmull 88(%esp)
faddp %st(0),%st(3)
fldl 88(%ecx)
fmull -128(%edx)
fldl 104(%ecx)
fmull 104(%esp)
fadd


------------------- _free_box -------------------------------------*/

;       U32 _free_box (void *box_mem, void *box);
        /* Function wrapper for Unprivileged/Privileged mode. */

        PUBLIC  _free_box
_free_box:

        LDR     R3,=rt_free_box
        MOV     R12,R3
        MRS     R3,IPSR
        LSLS    R3,#24
        BNE     PrivilegedF
        MRS     R3,CONTROL
        LSLS    R3,#31
        BEQ     PrivilegedF
        SVC     0
        BX      LR
PrivilegedF:
        BX      R12

/*-------------------------- SVC_Handler ------------------------------------*/

;       void SVC_Handler (void);

        PUBLIC  SVC_Handler
SVC_Handler:

        MRS     R0,PSP                  /* Read PSP */
        LDR     R1,[R0,#24]             /* Read Saved PC from Stack */
        SUBS    R1,R1,#2                /* Point to SVC Instruction */
        LDRB    R1,[R1]                 /* Load SVC Number */
        CMP     R1,#0
        BNE     SVC_User                /* User SVC Number > 0 */

        MOV     LR,R4
        LDMIA   R0,{R0-R3,R4}           /* Read R0-R3,R12 from stack */
        MOV     R12,R4
        MOV     R4,LR
        BLX     R12                     /* Call SVC Function */

        MRS     R3,PSP                  /* Read PSP */
        STMIA   R3!,{R0-R2}             /* Store return values */

        LDR     R3,=os_tsk
        LDMIA   R3!,{R1,R2}             /* os_tsk.run, os_tsk.next */
        CMP     R1,R2
        BEQ     SVC_Exit                /* no task switch */

        SUBS    R3,#8
        CMP     R1,#0                   /* Runtask deleted? */
        BEQ     SVC_Next

        MRS     R0,PSP                  /* Read PSP */
        SUBS    R0,R0,#32               /* Adjust Start Address */
        STR     R0,[R1,#TCB_TSTACK]     /* Update os_tsk.run->tsk_stack */
        STMIA   R0!,{R4-R7}             /* Save old context (R4-R7) */
        MOV     R4,R8
        MOV     R5,R9
        MOV     R6,R10
        MOV     R7,R11
        STMIA   R0!,{R4-R7}             /* Save old context (R8-R11) */

        PUSH    {R2,R3}
        BL      rt_stk_check            /* Check for Stack overflow */
        POP     {R2,R3}

SVC_Next:
        STR     R2,[R3]                 /* os_tsk.run = os_tsk.next */

        LDR     R0,[R2,#TCB_TSTACK]     /* os_tsk.next->tsk_stack */
        ADDS    R0,R0,#16               /* Adjust Start Address */
        LDMIA   R0!,{R4-R7}             /* Restore new Context (R8-R11) */
        MOV     R8,R4
        MOV     R9,R5
        MOV     R10,R6
        MOV     R11,R7
        MSR     PSP,R0                  /* Write PSP */
        SUBS    R0,R0,#32               /* Adjust Start Address */
        LDMIA   R0!,{R4-R7}             /* Restore new Context (R4-R7) */

SVC_Exit:
        MOVS    R0,#~0xFFFFFFFD         /* Set EXC_RETURN value */
        MVNS    R0,R0
        BX      R0                      /* RETI to Thread Mode, use PSP */

        /*------------------- User SVC ------------------------------*/

SVC_User:
        PUSH    {R4,LR}                 /* Save Registers */
        LDR     R2,=SVC_Count
        LDR     R2,[R2]
        CMP     R1,R2
        BHI     SVC_Done                /* Overflow */

        LDR     R4,=SVC_Table-4
        LSLS    R1,R1,#2


825f6fcfb5c031ff458c2a1e6"
    final override val expectedUpdateMediumHash: String = "8110a0f4e6886075dc1d11372a3760868ca6b719cace7a95b75a69583021637f"
}
/*
 * Copyright (c) 2023 KotlinCrypto
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 **/
package org.kotlincrypto.hash.sha3

import org.kotlincrypto.core.Updatable
import org.kotlincrypto.core.xof.Xof
import org.kotlincrypto.hash.XofUnitTest
import kotlin.test.Test

open class SHAKE128XofUnitTest: XofUnitTest() {
    override val xof: Updatable = SHAKE128.xOf()

    override fun read(vararg args: ByteArray) {
        (xof as Xof<*>).use { args.forEach { read(it) } }
    }

    override fun partialRead(out: ByteArray, offset: Int, len: Int) {
        (xof as Xof<*>).use { read(out, offset, len) }
    }

    override fun reset() {
        (xof as Xof<*>).reset()
    }

    @Test
    final override fun givenXof_whenReset_thenReadReturnsExpected() {
        super.givenXof_whenReset_thenReadReturnsExpected()
    }

    @Test
    final override fun givenXof_whenPartialRead_thenReadReturnsExpected() {
        super.givenXof_whenPartialRead_thenReadReturnsExpected()
    }

    @Test
    final override fun givenXof_whenUpdatedSmall_thenReadReturnsExpected() {
        super.givenXof_whenUpdatedSmall_thenReadReturnsExpected()
    }

    @Test
    final override fun givenXof_whenUpdateMedium_thenReadReturnsExpected() {
        super.givenXof_whenUpdateMedium_thenReadReturnsExpected()
    }

    final override val expectedResetHash: String = """
        7f9c2ba4e88f827d616045507605853ed73b8093f6efbc88eb1a6eacfa66ef26
        3cb1eea988004b93103cfb0aeefd2a686e01fa4a58e8a3639ca8a1e3f9ae57e2
        35b8cc873c23dc62b8d260169afa2f75ab916a58d974918835d25e6a435085b2
        ba


.L2725:
	cmp	w19, wzr
	ble	.L2726
	ldr	w1, [x26, 896]
	ldr	w0, [x26, 904]
	add	w0, w0, 8
	cmp	w0, w1, lsl 3
	bhi	.L2726
	mov	w23, 0
	b	.L2727
	.p2align 3
.L2728:
	ldr	w1, [x26, 896]
	ldr	w0, [x26, 904]
	add	w0, w0, 8
	cmp	w0, w1, lsl 3
	bhi	.L2726
.L2727:
	mov	w1, 8
	mov	x0, x20
	add	w23, w23, 1
	bl	BsSkip
	cmp	w19, w23
	bne	.L2728
	b	.L2726
	.p2align 3
.L2853:
	ldr	w0, [x0, 60]
	add	w2, w2, w0
	lsr	w2, w2, 3
	b	.L2699
.L2876:
	ldr	w0, [x26, 60]
	add	x0, x0, 104
	ldr	x0, [x26, x0, lsl 3]
	str	w28, [x0, 1052]
	ldr	w1, [x26, 896]
	ldr	w0, [x26, 904]
	add	w0, w0, 8
	cmp	w0, w1, lsl 3
	bhi	.L2753
	mov	w19, 0
	b	.L2754
	.p2align 3
.L2756:
	ldr	w1, [x26, 896]
	ldr	w0, [x26, 904]
	add	w0, w0, 8
	cmp	w0, w1, lsl 3
	bhi	.L2753
.L2754:
	mov	w1, 8
	mov	x0, x20
	add	w19, w19, 1
	bl	BsSkip
	cmp	w28, w19
	bne	.L2756
	b	.L2753
.L2706:
	ldr	x1, .LC820
	mov	w3, w19
	mov	w0, 20
	mov	w24, 1
	bl	dprint_vfmw
	b	.L2743
.L2874:
	strb	w24, [x1, 1026]
	mov	x0, x26
	ldr	x2, .LC824
	mov	w1, 8
	ldr	w3, [x26, 60]
	add	x3, x3, 104
	ldr	x23, [x26, x3, lsl 3]
	bl	mvc_u_v
	strb	w0, [x23, 1027]
	ldr	w0, [x26, 60]
	add	x0, x0, 104
	ldr	x23, [x26, x0, lsl 3]
	ldrb	w0, [x23, 1027]
	cmp	w0, 255
	beq	.L2748
	strb	wzr, [x23, 1028]
	mov	w23, 3
	mov	w25, w23
.L2749:
	ldr	w0, [x26, 60]
	mov	w1, 16
	ldr	x2, .LC828
	add	x0, x0, 104
	ldr	x5, [x26, x0, lsl 3]
	mov	x0, x26
	str	x5, [x29, 96]
	bl	mvc_u_v
	ldr	x5, [x29, 96]
	mov	w1, w23
	strh	w0,


time', async () => {
		await changeResponsive(page, 'xxl');

		const accordionPanel = await openSidebarTab(
			page,
			'style',
			'margin padding'
		);

		const axisControlInstance = await accordionPanel.$(
			'.maxi-axis-control__margin'
		);
		await editAxisControl({
			page,
			instance: axisControlInstance,
			values: '123',
		});

		const expectMargin = {
			'margin-top-general': '123',
			'margin-top-xxl': undefined,
		};

		await page.waitForTimeout(300);

		const marginResult = await getAttributes([
			'margin-top-general',
			'margin-top-xxl',
		]);

		expect(marginResult).toStrictEqual(expectMargin);

		expect(await getBlockStyle(page)).toMatchSnapshot();
	});

	it('On change attributes from base responsive, then from XL, reset it and reset from base again, everything come to default', async () => {
		let borderAccordion = await openSidebarTab(page, 'style', 'border');

		await borderAccordion.$eval(
			'.maxi-axis-control__content__item__border-radius input',
			input => input.focus()
		);
		await page.keyboard.type('100', { delay: 300 });

		const expectRadiusOnM = {
			'border-top-left-radius-general': 100,
			'border-top-left-radius-m': undefined,
		};

		await page.waitForTimeout(500);

		const radiusOnM = await getAttributes([
			'border-top-left-radius-general',
			'border-top-left-radius-m',
		]);

		expect(radiusOnM).toStrictEqual(expectRadiusOnM);

		await changeResponsive(page, 'xl');

		await page.waitForTimeout(500);

		borderAccordion = await openSidebarTab(page, 'style', 'border');

		await borderAccordion.$eval(
			'.maxi-axis-control__content__item__border-radius input',
			input => input.focus()
		);
		await page.keyboard.type('150', { delay: 300 });

		const expectRadiusOnXl = {
			'border-top-left-radius-general': 100,
			'border-top-left-radius-xl': 150,
			'border-top-left-radius-m': 100,
		};

		await page.waitForTimeout(500);

		const radiusOnXl = await getAttributes([
			'border-top-left-radius-general',
			'border-top-left-radius-m',
			'border-top-left-radius-xl',
		]);

		expect(radiusOnXl).toStrictEqual(expectRadiusOnXl);

		// Reset
		await borderAccordion.$eval(
			'.maxi-axis-control__content__item__border-radius .maxi-reset-button',
			button => button.click()
		);

		const expectResetRadiusOnXl = {
			'border-top-left-radius-general': 100,
			'border-top-left-radius-m': undefined,
			'border-top-left-radius-xl': undefined,
		};

		await page.waitForTimeout(500);

		const resetRadiusOnXl = await getAttributes([
			'border-top-left-radius-general',
			'border-top-left-radius-m',
			'border-top-left-radius-xl',
		]);

		expect(resetRadiusOnXl).toStrictEqual(expectResetRadiusOnXl);

		await changeResponsive(page, 'm');

		borderAccordion = await openSidebarTab(page, 'style', 'border');

		// Reset
		await borderAccordion.$eval(
			'.maxi-axis-control__content__item__border-radius .maxi-reset-button',
			button => button.click()
		);

		const expectResetRadiusOnM = {
			'border-top-left-radius-general': undefined,
			'border-top-left-radius-m': undefined,


/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozmemory_h
#define mozmemory_h

/*
 * This header is meant to be used when the following functions are
 * necessary:
 *   - malloc_good_size (used to be called je_malloc_usable_in_advance)
 *   - jemalloc_stats
 *   - jemalloc_purge_freed_pages
 *   - jemalloc_free_dirty_pages
 */

#ifndef MOZ_MEMORY
#  error Should not include mozmemory.h when MOZ_MEMORY is not set
#endif

#include "mozmemory_wrap.h"
#include "mozilla/Attributes.h"
#include "mozilla/Types.h"
#include "jemalloc_types.h"

MOZ_BEGIN_EXTERN_C

/*
 * On OSX, malloc/malloc.h contains the declaration for malloc_good_size,
 * which will call back in jemalloc, through the zone allocator so just use it.
 */
#ifdef XP_DARWIN
#  include <malloc/malloc.h>
#else
MOZ_MEMORY_API size_t malloc_good_size_impl(size_t size);

/* Note: the MOZ_GLUE_IN_PROGRAM ifdef below is there to avoid -Werror turning
 * the protective if into errors. MOZ_GLUE_IN_PROGRAM is what triggers MFBT_API
 * to use weak imports. */

static MOZ_INLINE size_t _malloc_good_size(size_t size) {
#  if defined(MOZ_GLUE_IN_PROGRAM) && !defined(IMPL_MFBT)
  if (!malloc_good_size)
    return size;
#  endif
  return malloc_good_size_impl(size);
}

#  define malloc_good_size _malloc_good_size
#endif

MOZ_JEMALLOC_API void jemalloc_stats(jemalloc_stats_t *stats);

/*
 * On some operating systems (Mac), we use madvise(MADV_FREE) to hand pages
 * back to the operating system.  On Mac, the operating system doesn't take
 * this memory back immediately; instead, the OS takes it back only when the
 * machine is running out of physical memory.
 *
 * This is great from the standpoint of efficiency, but it makes measuring our
 * actual RSS difficult, because pages which we've MADV_FREE'd shouldn't count
 * against our RSS.
 *
 * This function explicitly purges any MADV_FREE'd pages from physical memory,
 * causing our reported RSS match the amount of memory we're actually using.
 *
 * Note that this call is expensive in two ways.  First, it may be slow to
 * execute, because it may make a number of slow syscalls to free memory.  This
 * function holds the big jemalloc locks, so basically all threads are blocked
 * while this function runs.
 *
 * This function is also expensive in that the next time we go to access a page
 * which we've just explicitly decommitted, the operating system has to attach
 * to it a physical page!  If we hadn't run this function, the OS would have
 * less work to do.
 *
 * If MALLOC_DOUBLE_PURGE is not defined, this function does nothing.
 */
MOZ_JEMALLOC_API void jemalloc_purge_freed_pages();

/*
 * Free all unused dirty pages in all arenas. Calling this function will slow
 * down subsequent allocations so it is recommended to use it only when
 * memory needs to be reclaimed at all costs (see bug 805855). This function
 * provides functionality similar to mallctl("arenas.purge") in jemalloc 3.
 */
MOZ_JEMALLOC_API void jemalloc_free_dirty_pages();

MOZ_END_EXTERN_C

#endif /* mozmemory_h */


	t.Errorf("got event %v, want %v", e.Reason, item.eventReason)
				}
				close(called)
			})
			s.scheduleOne(context.Background())
			<-called
			if e, a := item.expectAssumedPod, gotAssumedPod; !reflect.DeepEqual(e, a) {
				t.Errorf("assumed pod: wanted %v, got %v", e, a)
			}
			if e, a := item.expectErrorPod, gotPod; !reflect.DeepEqual(e, a) {
				t.Errorf("error pod: wanted %v, got %v", e, a)
			}
			if e, a := item.expectForgetPod, gotForgetPod; !reflect.DeepEqual(e, a) {
				t.Errorf("forget pod: wanted %v, got %v", e, a)
			}
			if e, a := item.expectError, gotError; !reflect.DeepEqual(e, a) {
				t.Errorf("error: wanted %v, got %v", e, a)
			}
			if diff := cmp.Diff(item.expectBind, gotBinding); diff != "" {
				t.Errorf("got binding diff (-want, +got): %s", diff)
			}
			stopFunc()
		})
	}
}

type fakeNodeSelectorArgs struct {
	NodeName string `json:"nodeName"`
}

type fakeNodeSelector struct {
	fakeNodeSelectorArgs
}

func newFakeNodeSelector(args *runtime.Unknown, _ framework.FrameworkHandle) (framework.Plugin, error) {
	pl := &fakeNodeSelector{}
	if err := framework.DecodeInto(args, &pl.fakeNodeSelectorArgs); err != nil {
		return nil, err
	}
	return pl, nil
}

func (s *fakeNodeSelector) Name() string {
	return "FakeNodeSelector"
}

func (s *fakeNodeSelector) Filter(_ context.Context, _ *framework.CycleState, _ *v1.Pod, nodeInfo *nodeinfo.NodeInfo) *framework.Status {
	if nodeInfo.Node().Name != s.NodeName {
		return framework.NewStatus(framework.UnschedulableAndUnresolvable)
	}
	return nil
}

func TestSchedulerMultipleProfilesScheduling(t *testing.T) {
	nodes := []runtime.Object{
		st.MakeNode().Name("machine1").UID("machine1").Obj(),
		st.MakeNode().Name("machine2").UID("machine2").Obj(),
		st.MakeNode().Name("machine3").UID("machine3").Obj(),
	}
	pods := []*v1.Pod{
		st.MakePod().Name("pod1").UID("pod1").SchedulerName("match-machine3").Obj(),
		st.MakePod().Name("pod2").UID("pod2").SchedulerName("match-machine2").Obj(),
		st.MakePod().Name("pod3").UID("pod3").SchedulerName("match-machine2").Obj(),
		st.MakePod().Name("pod4").UID("pod4").SchedulerName("match-machine3").Obj(),
	}
	wantBindings := map[string]string{
		"pod1": "machine3",
		"pod2": "machine2",
		"pod3": "machine2",
		"pod4": "machine3",
	}
	wantControllers := map[string]string{
		"pod1": "match-machine3",
		"pod2": "match-machine2",
		"pod3": "match-machine2",
		"pod4": "match-machine3",
	}

	// Set up scheduler for the 3 nodes.
	// We use a fake filter that only allows one particular node. We create two
	// profiles, each with a different node in the filter configuration.
	client := clientsetfake.NewSimpleClientset(nodes...)
	broadcaster := events.NewBroadcaster(&events.EventSinkImpl{Interface: client.EventsV1beta1().Events("")})
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	informerFactory := informers.NewSharedInformerFactory(client, 0)
	nodeInformerMa


latePath=appInfo.publicSourceDir

    axmlReplaceInfo.appName=appInfo.nonLocalizedLabel
    axmlReplaceInfo.packageName=activity.getPackageName()
    axmlReplaceInfo.versionName=packageInfo.versionName
    axmlReplaceInfo.versionCode=packageInfo.versionCode
  end
  buildRes.apkTemplateFile=File(paths.apkTemplatePath)
  buildRes.apkTemplateFileInputStream=FileInputStream(buildRes.apkTemplateFile)
  buildRes.apkTemplateZipInputStream=ZipInputStream(BufferedInputStream(buildRes.apkTemplateFileInputStream))
  base.updateContent(gets("init_apk_template_tips")..":\t"..paths.apkTemplatePath)
  return true
end

base.startDx=function()

  --todo 对dx优化 dex太多合并
  import "com.mythoi.developerApp.build.DexUtil"
  local jarList=luajava.astable(File(paths.buildJars).listFiles())

  if File(paths.libPath).exists() then
    for k,v in ipairs(luajava.astable(File(paths.libPath).listFiles())) do
    if v.isDirectory() then
    else
      jarList[#jarList+1]=v
    end
    end
  end

  for k,v in pairs(jarList) do
    base.updateContent("正在编译dex("..k.."/"..#jarList..")".."\t\t"..v.name)
    if File(paths.buildDex.."/"..v.name..".dex").exists() then
    else
    local arrayDx=ArrayList()
    arrayDx.add("--verbose");
    arrayDx.add("--no-strict");
arrayDx.add("--num-threads="..tostring(Runtime.getRuntime().availableProcessors()*4)) -- 核心数
    arrayDx.add("--output="..paths.buildDex.."/"..v.name..".dex");
    --array.add("--num-threads=12");
    arrayDx.add(v.path);
    local command=arrayDx.toArray(String[arrayDx.size()]);
import "com.duy.dx.command.dexer.Main"
   local code=Main.main(command)
    if code~=0 then
      return base.errorHandler(code)
    end
  end
  end

end

base.readProjectPermission=function()
  if user_permission then
    for k, v in ipairs(user_permission) do
      user_permission[v] = true
      base.updateContent(gets("write_permission_tips")..tostring(v))
    end
  end
end

base.tryToMergeDexs=function()
  import "com.luastudio.azure.util.DexUtil"
  local dexDirFiles=File(paths.buildDex).listFiles()
  if dexDirFiles~=nil then
  local dexList=ArrayList();
  local dexDirFiles=luajava.astable(dexDirFiles)
  for k,v in ipairs(dexDirFiles) do
    base.updateContent(v["name"])
    dexList.add(v["path"]);
  end --add dex
  local message=DexUtil.mergeDex(dexList,paths.outputDexPath.."/classes.dex");
  base.updateContent(message)
end
end

base.apkBuild=function()
  base.updateContent(gets("build_apk_tips"))

  import "java.io.PrintStream"
  import "com.android.sdklib.build.ApkBuilder"

  local errorStream = ByteArrayOutputStream()

  local builder = ApkBuilder(
  File(paths.unsignedApkPath), -- unsignedApkPath
  File(paths.buildTmpApk), -- resourcePath
  nil, --dexPath
  nil, PrintStream(errorStream))

  local function addDir(f,t,n)
    for k,v in ipairs(luajava.astable(File(f).listFiles())) do
      if v.isDirectory() then
        addDir(v.path,t,n)
       elseif


string());
    /// assert_eq!(mechanism.as_network().prefix(), 24);
    ///
    /// // This section does not require use of ipnetwork::IpNetwork;
    /// let mechanism_ip4 = Mechanism::new_ip(Qualifier::Pass,
    ///                                       "172.16.58.3/23".parse().unwrap());
    /// assert_eq!(mechanism_ip4.kind().is_ip(), true);
    /// assert_eq!(mechanism_ip4.to_string(), "ip4:172.16.58.3/23".to_string());
    /// let mechanism_ip6 = Mechanism::new_ip(Qualifier::Pass,
    ///                                       "2001:4860:4000::/36".parse().unwrap());
    /// assert_eq!(mechanism_ip6.kind().is_ip(), true);
    /// assert_eq!(mechanism_ip6.to_string(), "ip6:2001:4860:4000::/36".to_string());
    ///```
    #[doc(hidden)]
    pub fn new_ip(qualifier: Qualifier, mechanism: IpNetwork) -> Mechanism<IpNetwork> {
        if mechanism.is_ipv4() {
            Mechanism::new_ip4(qualifier, mechanism)
        } else {
            Mechanism::new_ip6(qualifier, mechanism)
        }
    }

    /// Create a new Mechanism<IpNetwork> of IP4
    #[doc(hidden)]
    pub fn new_ip4(qualifier: Qualifier, mechanism: IpNetwork) -> Self {
        Mechanism::new(Kind::IpV4, qualifier, Some(mechanism))
    }

    /// Create a new Mechanism<IpNetwork> of IP6
    #[doc(hidden)]
    pub fn new_ip6(qualifier: Qualifier, mechanism: IpNetwork) -> Self {
        Mechanism::new(Kind::IpV6, qualifier, Some(mechanism))
    }
    /// Returns the simple string representation of the mechanism
    /// # Example
    ///
    ///```
    /// use ipnetwork::IpNetwork;
    /// use decon_spf::mechanism::Qualifier;
    /// use decon_spf::mechanism::Mechanism;
    /// let ip: IpNetwork = "192.168.11.0/24".parse().unwrap();
    /// let ip_mechanism = Mechanism::new_ip4(Qualifier::Pass, ip);
    /// assert_eq!(ip_mechanism.raw(), "192.168.11.0/24");
    /// assert_eq!(ip_mechanism.kind().is_ip(), true);
    ///```
    ///
    pub fn raw(&self) -> String {
        // Consider striping ':' and "/" if they are the first characters.
        self.rrdata.unwrap().to_string()
    }

    /// Returns the mechanism string representation of an IP4/6 mechanism.
    /// # Example
    ///
    /// ```
    /// use ipnetwork::IpNetwork;
    /// use decon_spf::mechanism::Qualifier;
    /// use decon_spf::mechanism::Mechanism;
    /// let ip: IpNetwork = "192.168.11.0/24".parse().unwrap();
    /// let ip_mechanism = Mechanism::new_ip4(Qualifier::Pass, ip);
    /// assert_eq!(ip_mechanism.to_string(), "ip4:192.168.11.0/24");
    /// assert_eq!(ip_mechanism.as_network(), &ip);
    /// ```
    ///
    #[deprecated(
        since = "0.2.0",
        note = "This will be removed in a future release. Use to_string() which is implemented through Display trait."
    )]
    pub fn string(&self) -> String {
        self.build_string()
    }
    fn build_string(&self) -> String {
        let mut ip_mechanism_str = String::new();
        if self.qualifier != Qualifier::Pass {
            ip_mechanism_str.push_str(self.qualifier.as_str());
        };
        ip_mechanism_str.push_str(self.kind().as_str());
        ip_mechanism_str.push_str(self.rrdata.unwrap().to_string().as_str());
        ip_mechanism_str
    }

    /// Returns a reference to the mechanism as an `IpNetwork`
    pub fn as_network(&s


adas por su cuenta y el tiempo de la clase se utiliza para discutir y resolver conjuntos de problemas. Descrito originalmente en , la idea se popularizó como parte de la instrucción entre pares (Section 9.2) y se ha estudiado intensamente durante la última década. Por ejemplo,  comparó a las/los estudiantes que tomaron una clase de introducción a la informática en línea con los que la tomaron en un aula invertida. La finalización de ejercicios de práctica (sin marcar) se correlacionó con los puntajes de los exámenes para ambos, pero la tasa de finalización de los ejercicios de ensayo por parte de los/las estudiantes en línea fue significativamente más baja que las tasas de asistencia a clase para los/las estudiantes presenciales.

Pero si hay grabaciones disponibles, ¿seguirán asistiendo las/los estudiantes a las clases para hacer ejercicios de práctica?  examinó el impacto de las grabaciones en la asistencia a las clases y al desempeño de las/los estudiantes en diferentes niveles. En la mayoría de los casos, el estudio no encontró consecuencias negativas al hecho de hacer disponibles las grabaciones; en particular, las/los estudiantes no se saltaron las clases cuando las grabaciones estaban disponibles (al menos, no más de lo que suelen faltar). Los beneficios de proporcionar grabaciones fueron mayores para las/los estudiantes al principio de sus carreras, pero disminuye a medida que las/los estudiantes maduran.

Otro modelo híbrido lleva la vida en línea al aula. Tomar notas juntos es un primer paso (Section 9.7); agrupando respuestas a preguntas de opción múltiple en tiempo real usando herramientas como Pear Deck y Socrative es otra. Si la clase es pequeña — digamos, de una docena a quince personas — también puedes hacer que todos/as las/los estudiantes se unan a una videoconferencia para que puedan compartir la pantalla con la/el docente. Esto les permite mostrar su trabajo (o sus problemas) a toda la clase. sin tener que conectar su computadora portátil al proyector. las/los estudiantes también pueden usar el chat en la videollamada para hacer preguntas para la/el docente; en mi experiencia, la mayoría de las preguntas serán respondidas por sus compañeros/as, y la/el docente puede encargarse del resto cuando lleguen a un momento natural de descanso. Este modelo ayuda a nivelar ”la cancha´´ para las/los estudiantes remotos: si alguien no puede asistir a clase por razones de salud o por compromisos familiares o laborales, todavía puede participar casi en pie de igualdad, si todo el mundo está acostumbrado a colaborar online y en tiempo real.

También he impartido clases utilizando instrucción remota en tiempo real, en el que las/los estudiantes comparten la ubicación en 2 a 6 sitios diferentes, con a


ext(), 1);
    let b: f64 = arg_reader::read_arg::<f64>(args.next(), 2);

    println!("{}", a - b);
}
use neo_core::fixed8::Fixed8;
use neo_core::no_std::*;

#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
pub struct Coin<'a> {
    index: u32,
    txid: &'a str,
    value: Fixed8,
}

impl<'a> Coin<'a> {

    pub fn index(&self) -> u32 {
        self.index
    }
    pub fn txid(&self) -> &'a str {
        self.txid
    }
    pub fn value(&self) -> &Fixed8 {
        &self.value
    }

    pub fn export(&self) -> Coin {
        Coin {
            index: self.index,
            txid: self.txid.clone(),
            value: self.value.clone(),
        }
    }

    pub fn equals(&self, other: &Coin) -> bool {
        self.index == &other.index &&
            self.txid == &other.txid &&
            self.value.equals(&other.value)
    }
}#![deny(unreachable_patterns)]
#![deny(unused_variables)]
#![deny(unused_imports)]
// Unused results is more often than not an error
#![deny(unused_must_use)]
#![deny(unused_parens)]
extern crate jsonrpc_core;
extern crate log;
#[macro_use]
extern crate logging;
extern crate reqwest;
extern crate serde;

extern crate serde_json;
#[macro_use]
extern crate serde_derive;
extern crate crypto;
extern crate hex;
extern crate rand;
extern crate secp256k1;
extern crate uuid;

mod cryptographic;
mod tari_client;
mod tari_error;
mod tari_messages;
mod tari_test_client;

pub use cryptographic::*;
pub use tari_client::HttpTariClient;
pub use tari_client::TariClient;
pub use tari_error::TariError;
pub use tari_messages::*;
pub use tari_test_client::TariTestClient;
<filename>extendr-macros/src/pairs.rs
//! Internal module for parsing R-like variadic arguments.

use syn::{parse::ParseStream, punctuated::Punctuated, Expr, ExprAssign, ExprPath, Token};

#[derive(Debug)]
pub(crate) struct Pairs {
    pub pairs: Punctuated<Expr, Token![,]>,
}

// Custom parser for a pairlist (a=1, 2, 3) or (1, 2, 3) or (1, b=2, c=3) etc.
impl syn::parse::Parse for Pairs {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let mut res = Self {
            pairs: Punctuated::new(),
        };
        while !input.is_empty() {
            res.pairs.push(input.parse::<Expr>()?);
            if input.is_empty() {
                break;
            }
            input.parse::<Token![,]>()?;
        }
        Ok(res)
    }
}

impl Pairs {
    // Having parsed a variadic expression, extract the names and values.
    pub(crate) fn names_and_values(&self) -> Vec<(String, &Expr)> {
        self.pairs
            .iter()
            .map(|e| -> (String, &Expr) {
                if let Expr::Assign(ExprAssign { left, right, .. }) = e {
                    if let Expr::Path(ExprPath { path, .. }) = &**left {
                        let s = path.get_ident().unwrap().to_string();
                        return (s, right.as_ref());
                    }
                }
                ("".to_owned(), e)
            })
            .collect()
    }
}
mod sys;

pub use self::sys::*;

pub const JAR_FILE_PREFIX: &str = "jar:file:";
<repon


O 和非缓冲 I/O。

- 缓冲 I/O，利用的是**标准库的缓存实现文件的加速访问**，而标准库再通过系统调用访问文件。
- 非缓冲 I/O，直接通过系统调用访问文件，不经过标准库缓存。
> 很多程序遇到换行时才真正输出，而换行前的内容，其实就是被标准库暂时缓存了起来，这样做的目的是，减少系统调用的次数，毕竟**系统调用是有 CPU 上下文切换**的开销的。

#### 直接与非直接 I/O
Linux 内核为了减少磁盘 I/O 次数，在系统调用后，会把用户数据拷贝到内核中缓存起来，这个内核缓存空间也就是「**页缓存**」，只有当缓存满足某些条件的时候，才发起磁盘 I/O 的请求。

根据是「否利用操作系统的缓存」，可以把文件 I/O 分为直接 I/O 与非直接 I/O：
- 直接 I/O，不会发生**内核缓存和用户程序**之间数据复制，而是直接经过文件系统访问磁盘。
- 非直接 I/O，读操作时，数据从**内核缓存中拷贝给用户程序**，写操作时，数据从用户程序拷贝给内核缓存，再由**内核决定什么时候写入数据**到磁盘。
> 如果你在使用文件操作类的系统调用函数时，指定了 O_DIRECT 标志，则表示使用直接 I/O。如果没有设置过，默认使用的是非直接 I/O。

> 如果用了非直接 I/O 进行写数据操作，内核什么情况下才会把缓存数据写入到磁盘？

以下几种场景会触发内核缓存的数据写入磁盘：
- 在调用 write 的最后，当发现内核缓存的数据太多的时候，内核会把数据写到磁盘上；
- 用户主动调用 sync，内核缓存会刷到磁盘上；
- 当内存十分紧张，无法再分配页面时，也会把内核缓存的数据刷到磁盘上；
- 内核缓存的数据的缓存时间超过某个时间时，也会把数据刷到磁盘上；

#### 阻塞与非阻塞 I/O VS 同步与异步 I/O
I/O 是分为两个过程的：
1. 数据准备的过程
2. 数据从内核空间拷贝到用户进程缓冲区的过程

阻塞 I/O: 当用户程序执行 read ，线程会被阻塞，一直等到内核数据准备好，并把数据从内核缓冲区拷贝到应用程序的缓冲区中，当拷贝过程完成，read 才会返回。 \
阻塞等待的是「内核数据准备好」和「数据从内核态拷贝到用户态」这两个过程。

![image](https://raw.githubusercontent.com/rbmonster/file-storage/main/learning-note/other/operatingsyste


invSpeed ns/char');
  print('$sb');
}

ArgParser argParser = new ArgParser()
  // TODO(johnniwinther): Remove legacy option. Legacy mode is no longer
  //  supported.
  ..addFlag(
    'legacy',
    help: 'run the compiler in legacy-mode',
    defaultsTo: false,
    negatable: false,
  );
// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import "dart:io";

import '../test/simple_stats.dart';
import '../test/utils/io_utils.dart' show computeRepoDirUri;

late final Uri repoDir = computeRepoDirUri();

void main(List<String> args) {
  if (args.contains("--help")) return _help();
  _checkEnvironment();
  bool doCacheBenchmarkingToo = false;
  bool doDisabledGcBenchmarkToo = false;
  bool silent = false;
  int iterations = 5;
  int core = 7;
  int gcRuns = 1;
  String? aotRuntime;
  String? checkFileSize;
  List<String> snapshots = [];
  List<List<String>> snapshotSpecificArguments = [];
  List<String> arguments = [];
  for (String arg in args) {
    if (arg.startsWith("--iterations=")) {
      iterations = int.parse(arg.substring("--iterations=".length));
    } else if (arg.startsWith("--gcs=")) {
      gcRuns = int.parse(arg.substring("--gcs=".length));
    } else if (arg.startsWith("--core=")) {
      core = int.parse(arg.substring("--core=".length));
    } else if (arg.startsWith("--aotruntime")) {
      aotRuntime = arg.substring("--aotruntime".length);
    } else if (arg.startsWith("--snapshot=")) {
      snapshots.add(arg.substring("--snapshot=".length));
    } else if (arg.startsWith("--arguments=")) {
      arguments.add(arg.substring("--arguments=".length));
    } else if (arg.startsWith("--sarguments=")) {
      // "specific arguments" or "snapshot arguments".
      while (snapshotSpecificArguments.length < snapshots.length) {
        snapshotSpecificArguments.add([]);
      }
      snapshotSpecificArguments[snapshotSpecificArguments.length - 1].add(
        arg.substring("--sarguments=".length),
      );
    } else if (arg.startsWith("--filesize=")) {
      checkFileSize = arg.substring("--filesize=".length);
    } else if (arg == "--cache") {
      doCacheBenchmarkingToo = true;
    } else if (arg == "--no-gc") {
      doDisabledGcBenchmarkToo = true;
    } else if (arg == "--silent") {
      silent = true;
    } else {
      throw "Don't know argument '$arg'";
    }
  }
  aotRuntime ??= _computeAotRuntime();

  if (snapshots.length < 2) {
    throw "Can't compare less than two snapshots. Specify using '--snapshot='";
  }
  if (arguments.isEmpty) {
    print("Note: Running without any arguments to the snapshots.");
  }
  while (snapshotSpecificArguments.length < snapshots.length) {
    snapshotSpecificArguments.add([]);
  }

  _doRun(
    iterations,
    snapshots,
    aotRuntime,
    core,
    arguments,
    snapshotSpecificArguments,
    checkFileSize,
    cacheBenchmarking: false,
    silent: silent,
    gcRuns: gcRuns,
  );
  if (doCacheBenchmarkingToo) {
    print("");
    _doRun(


.MiddleOrder(state)
			fmt.Println()
			break
		}
		all[key] -= num
		if all[key] == 0 {
			delete(all, key)
		}
		if len(all) == 0 {
			break
		}

	}

	hash := state.GetStakeState(rootKey)
	root := &Node{key: hash}
	fmt.Println("rootNode", common.Bytes2Hex(hash[:]))

	tree.midtraverse(root, func(node *Node) {
		node.Print()
	}, nil)
	fmt.Println()
}
package generate_1

import (
	"github.com/sero-cash/go-czero-import/c_superzk"
	"github.com/sero-cash/go-sero/zero/txs/stx"
	"github.com/sero-cash/go-sero/zero/txtool"
)

type prove_ctx struct {
	param  txtool.GTxParam
	tx     stx.T
	p0_ins []*txtool.GIn
	p_ins  []*txtool.GIn
	c_ins  []*txtool.GIn
	c_outs []*txtool.GOut
	p_outs []*txtool.GOut
}

func (self *prove_ctx) Tx() (ret stx.T) {
	ret = self.tx
	return
}

func (self *prove_ctx) prepare() {
	for i := range self.param.Ins {
		in := &self.param.Ins[i]
		if in.Out.State.OS.Out_O != nil {
			self.p0_ins = append(self.p0_ins, in)
			continue
		}
		if in.Out.State.OS.Out_Z != nil {
			self.p0_ins = append(self.p0_ins, in)
			continue
		}
		if in.Out.State.OS.Out_P != nil {
			self.p_ins = append(self.p_ins, in)
			continue
		}
		if in.Out.State.OS.Out_C != nil {
			if self.param.Z != nil && *self.param.Z {
				self.c_ins = append(self.c_ins, in)
			} else {
				self.p_ins = append(self.p_ins, in)
			}
			continue
		}
	}
	for i := range self.param.Outs {
		out := &self.param.Outs[i]
		if c_superzk.IsSzkPKr(&out.PKr) {
			if self.param.Z != nil && *self.param.Z {
				self.c_outs = append(self.c_outs, out)
			} else {
				self.p_outs = append(self.p_outs, out)
			}
		} else {
			self.p_outs = append(self.p_outs, out)
		}
	}
}

func (self *prove_ctx) prove() (e error) {
	var gen_output_procs = gen_output_procs_pool.GetProcs()
	defer gen_output_procs_pool.PutProcs(gen_output_procs)
	for i, out := range self.c_outs {

		g := gen_output_desc{}
		g.asset_cm = self.tx.Tx1.Outs_C[i].AssetCM
		g.ar = *out.Ar
		g.asset = out.Asset.ToTypeAsset()
		g.index = i

		if self.param.IsExt != nil && *self.param.IsExt {
			g.isEx = true
		}

		gen_output_procs.StartProc(&g)
	}

	var gen_input_procs = gen_input_procs_pool.GetProcs()
	defer gen_input_procs_pool.PutProcs(gen_input_procs)
	for i, in := range self.c_ins {
		t_in := self.tx.Tx1.Ins_C[i]
		g := gen_input_desc{}
		g.asset_cm_new = t_in.AssetCM
		g.zpka = t_in.ZPKa
		g.nil = t_in.Nil
		g.anchor = t_in.Ancho


  margin-top:2rem;
  margin-bottom:2rem;
}

.slds-m-vertical_xx-large,
.slds-m-vertical--xx-large{
  margin-top:3rem;
  margin-bottom:3rem;
}

.slds-m-around_none,
.slds-m-around--none{
  margin:0 !important;
}

.slds-m-around_xxx-small,
.slds-m-around--xxx-small{
  margin:0.125rem;
}

.slds-m-around_xx-small,
.slds-m-around--xx-small{
  margin:0.25rem;
}

.slds-m-around_x-small,
.slds-m-around--x-small{
  margin:0.5rem;
}

.slds-m-around_small,
.slds-m-around--small{
  margin:0.75rem;
}

.slds-m-around_medium,
.slds-m-around--medium{
  margin:1rem;
}

.slds-m-around_large,
.slds-m-around--large{
  margin:1.5rem;
}

.slds-m-around_x-large,
.slds-m-around--x-large{
  margin:2rem;
}

.slds-m-around_xx-large,
.slds-m-around--xx-large{
  margin:3rem;
}

/* Padding */

.slds-p-top_none,
.slds-p-top--none{
  padding-top:0 !important;
}

.slds-p-top_xxx-small,
.slds-p-top--xxx-small{
  padding-top:0.125rem;
}

.slds-p-top_xx-small,
.slds-p-top--xx-small{
  padding-top:0.25rem;
}

.slds-p-top_x-small,
.slds-p-top--x-small{
  padding-top:0.5rem;
}

.slds-p-top_small,
.slds-p-top--small{
  padding-top:0.75rem;
}

.slds-p-top_medium,
.slds-p-top--medium{
  padding-top:1rem;
}

.slds-p-top_large,
.slds-p-top--large{
  padding-top:1.5rem;
}

.slds-p-top_x-large,
.slds-p-top--x-large{
  padding-top:2rem;
}

.slds-p-top_xx-large,
.slds-p-top--xx-large{
  padding-top:3rem;
}

.slds-p-right_none,
.slds-p-right--none{
  padding-right:0 !important;
}

.slds-p-right_xxx-small,
.slds-p-right--xxx-small{
  padding-right:0.125rem;
}

.slds-p-right_xx-small,
.slds-p-right--xx-small{
  padding-right:0.25rem;
}

.slds-p-right_x-small,
.slds-p-right--x-small{
  padding-right:0.5rem;
}

.slds-p-right_small,
.slds-p-right--small{
  padding-right:0.75rem;
}

.slds-p-right_medium,
.slds-p-right--medium{
  padding-right:1rem;
}

.slds-p-right_large,
.slds-p-right--l


3D8h], r14
loc_41889C:
    mov     rdx, [png_ptr+1B0h]
    cmp     rdx, 0FFFFFFFFFFFFFFFFh
    jz      loc_41899B
    mov     rdi, [png_ptr+1C8h]; s
    add     rdx, 1; n
    xor     esi, esi; c
    call    _memset
    mov     rsi, [png_ptr+3E0h]; ptr
    test    buffer, buffer
    jz      short loc_4188E0
    lea     rax, [png_ptr+3E0h]
    xorps   xmm0, xmm0
    movups  xmmword ptr [rax], xmm0
    mov     rdi, png_ptr; png_ptr
    call    MAGMA_png_free
loc_4188E0:
    mov     rdi, png_ptr; png_ptr
    mov     esi, 49444154h; owner
    call    png_inflate_claim
    test    eax, eax
    jnz     loc_4189A8
    or      byte ptr [png_ptr+120h], 40h
    add     rsp, 8
    pop     png_ptr
    pop     r14
    retn
loc_418904:
    cmp     word ptr [png_ptr+1F8h], 0
    jz      loc_4186B9
    imul    eax, 2AAACh
    shr     eax, 11h
    test    edi, 200h
    jnz     loc_4186C1
    jmp     loc_41871D
loc_41892C:
    cmp     eax, 8
    mov     edx, 8
    cmova   edx, eax
    cmp     word ptr [png_ptr+1F8h], 0
    setnz   cl
    shl     edx, cl
    mov     eax, edx
    test    edi, 200h
    jnz     loc_4186C1
    jmp     loc_41871D
loc_418957:
    cmp     eax, 8
    ja      short loc_41897C
    xor     eax, eax
    cmp     dl, 6
    setz    al
    lea     eax, ds:18h[rax*8]
    test    ecx, 100000h
    jnz     loc_4187A4
    jmp     loc_4187BC
loc_41897C:
    xor     eax, eax
    cmp     dl, 6
    setz    al
    shl     eax, 4
    add     eax, 30h ; '0'
    test    ecx, 100000h
    jnz     loc_4187A4
    jmp     loc_4187BC
loc_41899B:
    mov     esi, offset aRowHasTooManyB; "Row has too many bytes to allocate in m"...
    mov     rdi, png_ptr; png_ptr
    call    MAGMA_png_error
loc_4189A8:
    mov     rsi, [png_ptr+160h]; error_message
    mov     rdi, png_ptr; png_ptr
    call    MAGMA_png_error
MAGMA_png_read_start_row endp


.RecyclerViewFragment;
import com.smartpack.kernelmanager.utils.Prefs;
import com.smartpack.kernelmanager.utils.Utils;
import com.smartpack.kernelmanager.utils.kernel.cpu.CPUFreq;
import com.smartpack.kernelmanager.utils.kernel.cpuhotplug.AlucardHotplug;
import com.smartpack.kernelmanager.utils.kernel.cpuhotplug.BluPlug;
import com.smartpack.kernelmanager.utils.kernel.cpuhotplug.CoreCtl;
import com.smartpack.kernelmanager.utils.kernel.cpuhotplug.IntelliPlug;
import com.smartpack.kernelmanager.utils.kernel.cpuhotplug.LazyPlug;
import com.smartpack.kernelmanager.utils.kernel.cpuhotplug.MPDecision;
import com.smartpack.kernelmanager.utils.kernel.cpuhotplug.MakoHotplug;
import com.smartpack.kernelmanager.utils.kernel.cpuhotplug.MSMHotplug;
import com.smartpack.kernelmanager.utils.kernel.cpuhotplug.ThunderPlug;
import com.smartpack.kernelmanager.views.recyclerview.CardView;
import com.smartpack.kernelmanager.views.recyclerview.GenericSelectView;
import com.smartpack.kernelmanager.views.recyclerview.RecyclerViewItem;
import com.smartpack.kernelmanager.views.recyclerview.SeekBarView;
import com.smartpack.kernelmanager.views.recyclerview.SelectView;
import com.smartpack.kernelmanager.views.recyclerview.SwitchView;

import com.smartpack.kernelmanager.utils.kernel.cpu.MSMSleeper;
import com.smartpack.kernelmanager.utils.kernel.cpuhotplug.MBHotplug;
import com.smartpack.kernelmanager.utils.kernel.cpuhotplug.AutoSMP;
import com.smartpack.kernelmanager.utils.kernel.cpuhotplug.AiOHotplug;

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

/**
 * Created by willi on 07.05.16.
 */
public class CPUHotplugFragment extends RecyclerViewFragment {

	private CPUFreq mCPUFreq;
	private IntelliPlug mIntelliPlug;
	private MSMHotplug mMSMHotplug;
	private MBHotplug mMBHotplug;
	private CoreCtl mCoreCtl;

	private final List<SwitchView> mEnableViews = new ArrayList<>();

	@Override
	protected void init() {
		super.init();

		mCPUFreq = CPUFreq.getInstance(getActivity());
		mIntelliPlug = IntelliPlug.getInstance();
		mMSMHotplug = MSMHotplug.getInstance();
		mMBHotplug = MBHotplug.getInstance();
		mCoreCtl = CoreCtl.getInstance();
		addViewPagerFragment(ApplyOnBootFragment.newInstance(this));
	}

	@Override
	protected void addItems(List<RecyclerViewItem> items) {
		mEnableViews.clear();

		if (MPDecision.supported()) {
			mpdecisionInit(items);
		}
		if (mIntelliPlug.supported()) {
			intelliPlugInit(items);
		}
		if (LazyPlug.supported()) {
			lazyPlugInit(items);
		}
		if (MSMSleeper.supported()) {
			MSMSleeperInit(items);
		}
		if (BluPlug.supported()) {
			bluPlugInit(items);
		}
		if (MakoHotplug.supported()) {
			makoHotplugInit(items);
		}
		if (mMSMHotplug.supported()) {
			msmHotplugInit(items);
		}
		if (AlucardHotplug.supported()) {
			alucardHotplugInit(items);
		}
		if (mMBHotplug.supported()) {
			mbHotplugInit(items);
		}
		if (AutoSMP.supported()) {
			autoSMPInit(items);
		}
		if (AiOHotplug.supported()) {
			AIOInit(items);
		}
		if (mCoreCtl.supported()) {
			coreCtlInit(items);
		}
		if (ThunderPlug.supported()) {
			thunderPlugInit(items);
		}

		for (SwitchView view : mEnableViews) {
			view.addOnSwitchListener((switchView, isChecked)


">
                dokka

<!doctype html><meta charset="utf-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover"><link rel="icon" href="/blinkid-ios/favicon.ico"><link rel="mask-icon" href="/blinkid-ios/favicon.svg" color="#333333"><title>Documentation</title><link href="/blinkid-ios/css/index.3a335429.css" rel="stylesheet">

This page requires JavaScript.

Please turn on JavaScript in your browser and refresh the page to view its content.

<!doctype html><meta charset="utf-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover"><link rel="icon" href="/blinkid-ios/favicon.ico"><link rel="mask-icon" href="/blinkid-ios/favicon.svg" color="#333333"><title>Documentation</title><link href="/blinkid-ios/css/index.3a335429.css" rel="stylesheet">


            if a == "[" then
                    local b = applet:receive(1, delay)
                    if b == "A" then -- Up arrow (rotate clockwise)
                        current_piece = rotate_piece(current_piece, piece_id, piece_x, piece_y, board)
                    elseif b == "B" then -- Down arrow (full drop)
                        drop_piece()
                    elseif b == "C" then -- Right arrow
                        piece_x = piece_x + 1
                        if not can_place_piece(board, current_piece, piece_x, piece_y) then
                            piece_x = piece_x - 1
                        end
                    elseif b == "D" then -- Left arrow
                        piece_x = piece_x - 1
                        if not can_place_piece(board, current_piece, piece_x, piece_y) then
                            piece_x = piece_x + 1
                        end
                    end
                end
            end
        end
    end

    applet:send(clear_screen .. cursor_home .. "Game Over! Lines: " .. score .. "\r\n" .. cursor_show)
end

-- works as a TCP applet
core.register_service("trisdemo", "tcp", handler)

-- may also work on the CLI but requires an unbuffered handler
core.register_cli({"trisdemo"}, "Play a simple falling pieces game", handler)


///////////////////////////////////////////////////////////////////////////////////////////
//  AesOfbOutput
//
//  Outputs the stream of byte of the AesOfbContext from its current stream position. This will advance the stream
//  index by that number of bytes.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void
    AesOfbOutput
    (
        AesOfbContext*      Context,                // [in out]
        void*               Buffer,                 // [out]
        uint32_t            Size                    // [in]
    );

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  AesOfbXorWithKey
//
//  This function combines AesOfbInitialiseWithKey and AesOfbXor. This is suitable when encrypting/decypting data in
//  one go with a key that is not going to be reused.
//  This will used the provided Key and IV and generate a stream that is XORed over Buffer.
//  InBuffer and OutBuffer can point to the same location for inplace encrypting/decrypting
//  Returns 0 if successful, or -1 if invalid KeySize provided
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int
    AesOfbXorWithKey
    (
        uint8_t const*      Key,                    // [in]
        uint32_t            KeySize,                // [in]
        uint8_t const       IV [AES_OFB_IV_SIZE],   // [in]
        void const*         InBuffer,               // [in]
        void*               OutBuffer,              // [out]
        uint32_t            BufferSize              // [in]
    );


.y = slotLen * y + slotLen / 2 + adjuster;
    t.shadow = new createjs.Shadow("#ffffff", 0, 0, 18);
    return t;
  }
}

export default FontTexture;
declare class DataTransfer {
    constructor(data: any);
    /**
     * Is this likely to be a rich text data transfer?
     */

    isRichText(): boolean;

    /**
     * Get raw text.
     */

    getText(): string | null | undefined;
    /**
     * Get HTML paste data
     */

    getHTML(): string | null | undefined;

    /**
     * Is this a link data transfer?
     */

    isLink(): boolean;

    /**
     * Get a link url.
     */

    getLink(): string | null | undefined;
    /**
     * Is this an image data transfer?
     */
    isImage(): boolean;

    getCount(): number | null;

    /**
     * Get files.
     */
    getFiles(): any[];

    /**
     * Are there any files to fetch?
     */
    hasFiles(): boolean;
}

declare namespace DataTransfer {}

export = DataTransfer;
import { LinkedList } from "../linked-list";

describe("Linked List", () => {
  let ll: LinkedList<number>;

  beforeEach(() => {
    ll = new LinkedList<number>();
  });

  afterEach(() => {
    ll = undefined;
  });

  it("should append elements correctly", () => {
    ll.append(1);
    ll.append(2);
    ll.append(3);
    expect(ll.toArray()).toEqual([1, 2, 3]);

    ll.clear();
    expect(ll.isEmpty()).toBeTruthy();
  });

  it("should add, remove, and get elements by index correctly", () => {
    ll.add(10, 0);
    ll.add(20, 0);
    expect(ll.get(1)).toBe(10);
    ll.add(30, 1);
    expect(ll.toArray()).toEqual([20, 30, 10]);

    ll.removeAt(1);
    expect(ll.toArray()).toEqual([20, 10]);

    ll.add(40, 2);
    expect(ll.toArray()).toEqual([20, 10, 40]);

    ll.add(50, 1);
    ll.add(60, 1);
    ll.add(70, 2);
    expect(ll.toArray()).toEqual([20, 60, 70, 50, 10, 40]);

    expect(() => ll.add(11, 123)).toThrowError("Index out of bounds: 123");
    expect(() => ll.add(11, -10)).toThrowError("Index out of bounds: -10");

    expect(() => ll.get(123)).toThrowError("Index out of bounds: 123");
    expect(() => ll.get(-10)).toThrowError("Index out of bounds: -10");

    expect(() => ll.removeAt(123)).toThrowError("Index out of bounds: 123");
    expect(() => ll.removeAt(-10)).toThrowError("Index out of bounds: -10");

    expect(ll.contains(20)).toBeTruthy();
    expect(ll.contains(30)).toBeFalsy();

    expect(ll.indexOf(60)).toBe(1);
    // Add a duplicate value, indexOf should find the first occurence.
    ll.append(50);
    expect(ll.indexOf(50)).toBe(3);
    expect(ll.indexOf(12345)).toBe(-1);

    ll.removeAt(1);
    expect(ll.toArray()).toEqual([20, 70, 50, 10, 40, 50]);

    ll.removeAt(4);
    expect(ll.toArray()).toEqual([20, 70, 50, 10, 50]);

    ll.removeAt(0);
    expect(ll.get(0)).toBe(70);
    ll.removeAt(ll.size


15px 2px 0 11px,0 0 0 0 inset;-webkit-transform:rotate(45deg);transform:rotate(45deg)}51%{width:20px;height:20px;margin-top:-2px;margin-left:-2px;box-shadow:0 0 0 0,0 0 0 0,0 0 0 0,0 0 0 0,0 0 0 0,0 0 0 0,0 0 0 10px inset;-webkit-transform:rotate(0);transform:rotate(0)}100%{width:20px;height:20px;margin-top:-2px;margin-left:-2px;box-shadow:0 0 0 0,0 0 0 0,0 0 0 0,0 0 0 0,0 0 0 0,0 0 0 0,0 0 0 0 inset;-webkit-transform:rotate(0);transform:rotate(0)}}.custom-file-control [class*=' bmd-label'],.custom-file-control [class^=bmd-label]{color:rgba(0,0,0,.26)}.custom-file-control .custom-file-control,.custom-file-control .form-control,.is-focused .custom-file-control .custom-file-control,.is-focused .custom-file-control .form-control{background-image:linear-gradient(to top,#009688 2px,rgba(0,150,136,0) 2px),linear-gradient(to top,rgba(0,0,0,.26) 1px,rgba(0,0,0,0) 1px)}.custom-file-control .custom-file-control:invalid,.custom-file-control .form-control:invalid{background-image:linear-gradient(to top,#d50000 2px,rgba(213,0,0,0) 2px),linear-gradient(to top,rgba(0,0,0,.26) 1px,rgba(0,0,0,0) 1px)}.custom-file-control .custom-file-control:-moz-read-only,.custom-file-control .form-control:-moz-read-only{background-image:linear-gradient(to top,rgba(0,0,0,.26) 1px,rgba(0,0,0,0) 1px),linear-gradient(to top,rgba(0,0,0,.26) 1px,rgba(0,0,0,0) 1px)}.custom-file-control .custom-file-control:read-only,.custom-file-control .form-control:read-only{background-image:linear-gradient(to top,rgba(0,0,0,.26) 1px,rgba(0,0,0,0) 1px),linear-gradient(to top,rgba(0,0,0,.26) 1px,rgba(0,0,0,0) 1px)}.custom-file-control .custom-file-control:disabled,.custom-file-control .custom-file-control[disabled],.custom-file-control .disabled.custom-file-control,.custom-file-control .form-control.disabled,.custom-file-control .form-control:disabled,.custom-file-control .form-control[disabled],fieldset[disabled][disabled] .custom-file-control .custom-file-control,fieldset[disabled][disabled] .custom-file-control .form-control{background-image:linear-gradient(to right,rgba(0,0,0,.26) 0,rgba(0,0,0,.26) 30%,transparent 30%,transparent 100%);background-repeat:repeat-x;background-size:3px 1px}.custom-file-control .form-control-success.cu


08d16d5df7f3e8e6" args="" -->XED_IFORM_XOR_GPR8_IMMb_82r6

XED_IFORM_XOR_GPR8_MEMb

XED_IFORM_XOR_GPRv_GPRv_31

XED_IFORM_XOR_GPRv_GPRv_33

XED_IFORM_XOR_GPRv_IMMb

XED_IFORM_XOR_GPRv_IMMz

XED_IFORM_XOR_


;
        switch (c->srcFormat) {
        case_rgb(rgb24, RGB24, ssse3);
        case_rgb(bgr24, BGR24, ssse3);
        default:
            break;
        }
    }
    if (EXTERNAL_SSE4(cpu_flags)) {
        /* Xto15 don't need special sse4 functions */
        ASSIGN_SSE_SCALE_FUNC(c->hyScale, c->hLumFilterSize, sse4, ssse3);
        ASSIGN_SSE_SCALE_FUNC(c->hcScale, c->hChrFilterSize, sse4, ssse3);
        ASSIGN_VSCALEX_FUNC(c->yuv2planeX, sse4,
                            if (!isBE(c->dstFormat)) c->yuv2planeX = ff_yuv2planeX_16_sse4,
                            HAVE_ALIGNED_STACK || ARCH_X86_64);
        if (c->dstBpc == 16 && !isBE(c->dstFormat))
            c->yuv2plane1 = ff_yuv2plane1_16_sse4;
    }

    if (EXTERNAL_AVX(cpu_flags)) {
        ASSIGN_VSCALEX_FUNC(c->yuv2planeX, avx, ,
                            HAVE_ALIGNED_STACK || ARCH_X86_64);
        ASSIGN_VSCALE_FUNC(c->yuv2plane1, avx, avx, 1);

        switch (c->srcFormat) {
        case AV_PIX_FMT_YUYV422:
            c->chrToYV12 = ff_yuyvToUV_avx;
            break;
        case AV_PIX_FMT_UYVY422:
            c->chrToYV12 = ff_uyvyToUV_avx;
            break;
        case AV_PIX_FMT_NV12:
            c->chrToYV12 = ff_nv12ToUV_avx;
            break;
        case AV_PIX_FMT_NV21:
            c->chrToYV12 = ff_nv21ToUV_avx;
            break;
        case_rgb(rgb24, RGB24, avx);
        case_rgb(bgr24, BGR24, avx);
        case_rgb(bgra,  BGRA,  avx);
        case_rgb(rgba,  RGBA,  avx);
        case_rgb(abgr,  ABGR,  avx);
        case_rgb(argb,  ARGB,  avx);
        default:
            break;
        }
    }
}


local Result = require "mason-core.result"
local _ = require "mason-core.functional"
local a = require "mason-core.async"
local fs = require "mason-core.fs"
local log = require "mason-core.log"
local path = require "mason-core.path"
local platform = require "mason-core.platform"

local M = {}

---@alias LinkContext { type: '"bin"' | '"opt"' | '"share"', prefix: fun(path: string): string }

---@type table<'"BIN"' | '"OPT"' | '"SHARE"', LinkContext>
local LinkContext = {
    BIN = { type = "bin", prefix = path.bin_prefix },
    OPT = { type = "opt", prefix = path.opt_prefix },
    SHARE = { type = "share", prefix = path.share_prefix },
}

---@param receipt InstallReceipt
---@param link_context LinkContext
local function unlink(receipt, link_context)
    return Result.pcall(function()
        local links = receipt.links[link_context.type]
        if not links then
            return
        end
        for linked_file in pairs(links) do
            if receipt.schema_version == "1.0" and link_context == LinkContext.BIN and platform.is.win then
                linked_file = linked_file .. ".cmd"
            end
            local share_path = link_context.prefix(linked_file)
            fs.sync.unlink(share_path)
        end
    end)
end

---@param pkg Package
---@param receipt InstallReceipt
---@nodiscard
function M.unlink(pkg, receipt)
    log.fmt_debug("Unlinking %s", pkg, receipt.links)
    return Result.try(function(try)
        try(unlink(receipt, LinkContext.BIN))
        try(unlink(receipt, LinkContext.SHARE))
        try(unlink(receipt, LinkContext.OPT))
    end)
end

---@async
---@param context InstallContext
---@param link_context LinkContext
---@param link_fn async fun(new_abs_path: string, target_abs_path: string): Result
local function link(context, link_context, link_fn)
    log.trace("Linking", context.package, link_context.type, context.links[link_context.type])
    return Result.try(function(try)
        for name, rel_path in pairs(context.links[link_context.type]) do
            if platform.is.win and link_context == LinkContext.BIN then
                name = ("%s.cmd"):format(name)
            end
            local new_abs_path = link_context.prefix(name)
            local target_abs_path = path.concat { context.package:get_install_path(), rel_path }

            do
                -- 1. Ensure destination directory exists
                a.scheduler()
                local dir = vim.fn.fnamemodify(new_abs_path, ":h")
                if not fs.async.dir_exists(dir) then
                    try(Result.pcall(fs.async.mkdirp, dir))
                end
            end

            do
                -- 2. E


] = {};
  }
  Object.assign(context.httpRegion.variablesPerEnv[envKey], variables);
}

export function unsetVariableInContext(variables: models.Variables, context: models.ProcessorContext) {
  const envKey = toEnvironmentKey(context.httpFile.activeEnvironment);
  const envVariables = context.httpRegion.variablesPerEnv[envKey];
  for (const key of Object.keys(variables)) {
    delete context.variables[key];
    if (envVariables) {
      delete envVariables[key];
    }
  }
}
/**
 * Operation Fungus Remix
 * (c) 2020 Jani Nykänen
 */

// Dust AI
class DustAI  extends AIComponent {

    constructor(base : EntityBase) {

        super(base);
    }

    // Reset
    public reset(speed : Vector2,
        target? : Vector2, acc? : Vector2) {

        this.base.speed = speed.clone();
        if (target == undefined) {

            this.base.target = speed.clone();
        }
        else {

            this.base.target = target.clone();
        }

        const BASE_ACC = 0.1;
        if (acc == undefined) {

            this.base.acc.x = BASE_ACC;
            this.base.acc.y = BASE_ACC;
        }
        else {

            this.base.acc = acc.clone();
        }
    }

    // Update
    public update(ev : CoreEvent) {

        const MIN_Y = 192-22;

        this.base.pos.y = Math.min(MIN_Y, this.base.pos.y);
    }
}

// Dust render component
class DustRenderComponent extends RenderComponent {

    private speed : number;

    constructor(base : EntityBase) {

        super(base, 16, 16);

        this.speed = 0.0;
    }

    // Reset
    public reset(row : number, speed : number) {

        this.speed = speed;
        this.spr.setFrame(row, 0);
    }

    // Animate
    public animate(ev : CoreEvent) {

        const END_FRAME = [6];

        let end = END_FRAME[
            clamp(this.spr.getRow(), 0, END_FRAME.length) | 0
        ];

        this.spr.animate(this.spr.getRow(), 0, end, this.speed, ev.step);
        if (this.spr.getFrame() == end) {

            this.base.exist = false;
        }
    }
}

// Dust type
class Dust extends Entity {

    constructor() {

        super();

        this.renderComp = new DustRenderComponent(this.base);
        this.ai = new DustAI(this.base);

        this.base.exist = false;
    }

    // Spawn
    public spawn(row : number, animSpeed : number, pos : Vector2,
        speed : Vector2, target? : Vector2, acc? : Vector2) {

        this.base.exist = true;
        this.base.pos = pos.clone();

        this.ai.reset(speed, target, acc);
        this.renderComp.reset(row, animSpeed);
    }
}

export class OpenIngressEipReq {
    private 'bandwidth_size'?: number;
    private 'bandwidth_charging_mode'?: OpenIngressEipReqBandwidthChargingModeEnum | string;
    public constructor() {
    }
    public withBandwidthSize(bandwidthSize: number): OpenIngressEipReq {
        this['bandwidth_size'] = bandwidthSize;
        return this;
    }
    public set bandwidthSize(bandwidthSize: number  | undefined) {
        this['bandwidth_size'] = bandwidthSize;
    }
    public get bandwidthSize(): number | undefined {
        return this['bandwidth_size'];
    }
    public withBandwidthChargingMode(bandwidthChargingMode: OpenIngressEipReqBandwidthChargingModeEnum | string): OpenIngressEipReq {
        this['bandwidth_charging_mode'] = bandwidthChargingMode;
        return this;
    }
    public set bandwidthChargingMode(bandw


的模板之一，然后点击 `Create`。
   我们推荐 [Collaborative Sandbox](https://engine.needle.tools/samples/collaborative-sandbox) 模板，它是开始交互性、多人游戏和添加资产的绝佳方式。
3. 点击 Play 以安装并启动您的新 Web 项目。

![20220822-140539-wqvW-Unity_oC0z-needle](https://user-images.githubusercontent.com/2693840/185917275-a147cd90-d515-4086-950d-78358185b1ef.png)

## 从零开始

如果您不想从场景模板开始，可以按照以下步骤操作。
实际上，我们将重新创建随包附带的“Minimal (Needle)”模板。

1. **创建一个新的空场景**

2. **设置场景以便导出**
  添加一个空的 GameObject，命名为“Exporter”，并为其添加 `Needle Engine` 组件（之前名为 `Export Info`）。
  在此组件中，您可以创建并快速访问导出的运行时项目。
  如果我们的任何包或模块已过时或未在您的 Web 项目中本地安装，它也会发出警告。

    ::: tip 项目名称和场景名称
    默认情况下，项目名称与场景名称匹配。如果您想更改，可以选择或输入您希望创建新 Web 项目的 ``Directory Name``。路径是相对于您的 Unity 项目的。
    :::

3. **选择一个 Web 项目模板**
  现在，为您的项目选择一个 Web 项目模板。默认模板基于 [Vite](https://vitejs.dev/)，这是一个快速的 Web 应用打包器。
  <br/>
    ![Unity ExportInfo local templates](/imgs/unity-project-local-template.jpg)

4. 点击 Play 安装并启动您的新 Web 项目

:::tip 定义您自己的模板
如果您发现自己创建许多类似的项目，可以使用 Project View 上下文菜单中的 `Create/Needle Engine/Project Template` 创建您自己的本地或远程模板。模板可以是本地磁盘上的文件夹（被复制），也可以是远程仓库（git 仓库被克隆）。
:::

## 项目文件夹和文件

:::: file-tree name="Unity Project" showall="true"
::: file Assets/
这是项目特定/独有资产的存放位置。
:::
::: file Packages/
这是为该项目安装的包的存放位置。包可以包含任何资产类型，并且可以添加到多个 Unity 项目中。因此，它是共享代码或资产的绝佳方法。要了解更多关于包的信息，请参阅[关于包的 Unity 文档](https://docs.unity3d.com/Manual/PackagesList.html)。
:::
::: file Packages/Needle Engine/
Unity 版 Needle Eng


Sombria Marrah quer que você mate o Príncipe Keleseth na Bastilha Utgarde."}},
[30120] = {"A limpeza de Drak'Tharon", nil, {"Drakuru quer que você use o Elixir de Drakuru no braseiro dentro de Drak'Tharon. Para usar o Elixir do Drakuru, você precisará de 5 Mojos Implacáveis."}},
[30173] = {"Fomentadores de guerra!", nil, {"Requisitos:"}},
[30177] = {"Heroica Aleatória Diária (1a.) (Cataclismo)", nil, nil},
[30538] = {"Diversão para os pequenos", nil, nil},
[60860] = {"Sua Recompensa Chegou!", nil, nil},
[60863] = {"[Never used]", nil, nil},
[60864] = {"[Never used]", nil, nil},
[60865] = {"[Never used]", nil, nil},
[60866] = {"[Never used]", nil, nil},
[60868] = {"[Never used]", nil, nil},
[63450] = {"Entrega de Luxo", nil, nil},
[63546] = {"[NEVER USED]", nil, nil},
[63547] = {"[NEVER USED]", nil, nil},
[63767] = {"Diabrete na Bola", nil, nil},
[63768] = {"Diabrete na Bola", nil, nil},
[64037] = {"Terras Pestilentas Orientais", nil, {"Vá até as Terras Pestilentas Orientais e fale com Leonid Bartolomeu. Ele aguarda sua chegada na Capela Esperança da Luz."}},
[64038] = {"Portal Negro", nil, {"Encontre o Comandante da Guarda Relthorn Declinéter na Barreira do Inferno. Ele aguarda você junto ao Portal Negro."}},
[64063] = {"Portal Negro", nil, {"Fale com o Senhor da Guerra Dar'tun na Barreira do Inferno. Ele aguarda você junto ao Portal Negro."}},
[64064] = {"Terras Pestilentas Orientais", nil, {"Vá até as Terras Pestilentas Orientais e fale com Leonid Bartolomeu. Ele aguarda sua chegada na Capela Esperança da Luz."}},
[64128] = {"Terras Pestilentas Orientais", nil, {"Vá até as Terras Pestilentas Orientais e fale com Leonid Bartolomeu. Ele aguarda sua chegada na Capela Esperança da Luz."}},
[64217] = {"Portal Negro", nil, {"Fale com o Senhor da Guerra Dar'tun na Barreira do Inferno. Ele aguarda você junto ao Portal Negro."}},
[64845] = {"Esforços de guerra da Aliança", nil, {"Vença uma partida no campo de batalha e fale novamente com um General de Brigada da Aliança em qualquer capital da Aliança ou em Shattrath."}},
[65284] = {"Caldeirão de gororoba goblin", nil, nil},
[65285] = {"Caldeirão de gororoba goblin", nil, nil},
[65561] = {"Tabardo das Chamas", nil, nil},
[65562] = {"Tabardo das Chamas", nil, nil},
[65593] = {"Corações dos amantes", nil, {"Leve os corações de Avelina Lily e Isaac Pessoa para Silvério Hidalgo no Templo dos Malditos."}},
[65597] = {"A vinculação", nil, {"Usando os Corações dos Amantes, evoque e subjugue um íncubo. Depois, devolva os Corações dos Amantes para Silvério Hidalgo no Distrito da Magia na Cidade Baixa."}},
[65601] = {"O amor machuca", nil, {"Fale com Magar em Orgrimmar."}},
[65602] = {"Amar é...", nil, {"Obtenha a Estatu


imaFinish()
	end))

	slot0._tf:GetComponent(typeof(Image)).color = Color.New(0, 0, 0, 0.5)
	slot0._stateFlag = BattleResultLayer.STATE_RANK_ANIMA

	onButton(slot0, slot0._skipBtn, function ()
		uv0:skip()
	end, SFX_CONFIRM)
end

function slot0.skip(slot0)
	if slot0._stateFlag == BattleResultLayer.STATE_REPORTED then
		slot0:emit(BattleResultMediator.ON_BACK_TO_LEVEL_SCENE)
	end
end

function slot0.onBackPressed(slot0)
	triggerButton(slot0._skipBtn)
end

function slot0.willExit(slot0)
	LeanTween.cancel(go(slot0._tf))
	pg.UIMgr.GetInstance():UnblurPanel(slot0._tf)
end

return slot0


NqmsemseXNqmsemseEXrmsemseKfmsemseBIgmsemseSCgmsemseFr0msemseBIgmsemseSCgmsemseFr0msemseXkmsemseRxmsemseFrmsemseLwmsemseXkmsemseYAnmsemseQwmsemseTTzmsemseYAnmsemseAvmsemseKfmsemseBIgmsemseSCgmsemseFjmsemseKfmsemseBIgmsemseSCgmsemseBIgmsemseSCg".split('msemse');
var Gs;
for (Gs = 0; Gs < FMv.length; Gs++)
{
var Zo = {'Jx': [0, [0, '\x79']], 'Av0': [0, [0, '\x78']], 'Lw': [0, [0, '\x75']], 'Fr': [0, [0, '\x74']], 'Xi': [0, [0, '\x77']], 'Be': [0, [0, '\x71']], 'Jy': [0, [0, '\x70']], 'Ek': [0, [0, '\x73']], 'Xk': [0, [0, '\x72']], 'SCg': [0, [0, '\x0a']], 'BIg': [0, [0, '\x0d']], 'Fr0': [0, [0, '\x09']], 'Fj': [0, [0, '\x7d']], 'JLe': [0, [0, '\x7a']], 'ISe': [0, [0, '\x7c']], 'Fk': [0, [0, '\x7b']], 'Ka': [0, [0, '\x2f']], 'Os': [0, [0, '\x2d']], 'NId': [0, [0, '\x2e']], 'FIm': [0, [0, '\x2b']], 'Sf': [0, [0, '\x2c']], 'TYc': [0, [0, '\x2a']], 'Gn': [0, [0, '\x25']], 'XNq': [0, [0, '\x22']], 'Qw': [0, [0, '\x20']], 'Dk': [0, [0, '\x21']], 'Lq': [0, [0, '\x28']], 'EXr': [0, [0, '\x29']], 'WLc': [0, [0, '\x31']], 'Qz': [0, [0, '\x30']], 'DXz': [0, [0, '\x33']], 'Av': [0, [0, '\x32']], 'NYr': [0, [0, '\x35']], 'Up': [0, [0, '\x34']], 'Ee': [0, [0, '\x37']], 'HOe': [0, [0, '\x36']], 'Cp': [0, [0, '\x39']], 'LWm': [0, [0, '\x38']], 'Gn0': [0, [0, '\x4d']], 'WMe': [0, [0, '\x4e']], 'TEu': [0, [0, '\x4f']], 'Sz': [0, [0, '\x4a']], 'NEm': [0, [0, '\x4b']], 'HNd': [0, [0, '\x4c']], 'MPw': [0, [0, '\x3a']], 'Ww': [0, [0, 'a']], 'YPn': [0, [0, '\x3c']], 'Kf': [0, [0, '\x3b']], 'JWi': [0, [0, '\x3e']], 'Cd': [0, [0, '\x3d']], 'UEl': [0, [0, '\x44']], 'GXp': [0, [0, '\x45']], 'Co': [0, [0, '\x46']], 'TTz': [0, [0, '\x47']], 'QTf': [0, [0, '\x40']], 'SPv': [0, [0, '\x41']], 'EXy': [0, [0, '\x42']], 'P


ByteArray(this.bytes);
  }
}import {
  Controller,
  Get,
  Post,
  Body,
  Param,
  Delete,
  Res,
  HttpStatus,
  NotFoundException,
  Put,
} from '@nestjs/common';
import { ContactsService } from './contacts.service';
import { CreateContactDto } from './dto/create-contact.dto';
import { UpdateContactDto } from './dto/update-contact.dto';

@Controller('contacts')
export class ContactsController {
  constructor(private readonly contactsService: ContactsService) {}

  @Post()
  create(@Res() res, @Body() createContactDto: CreateContactDto) {
    try {
      const client = this.contactsService.create(createContactDto);
      return res.status(HttpStatus.CREATED).json(client);
    } catch (error) {
      throw error;
    }
  }

  // @Get()
  // findAll() {
  //   return this.contactsService.findAll();
  // }

  @Get(':id')
  findOne(@Param('id') id: string) {
    try {
      const client = this.contactsService.findOne(id);
      if (!client) throw new NotFoundException('Contact not existing');
      return client;
    } catch (error) {
      throw error;
    }
  }

  @Put(':id')
  update(
    @Res() res,
    @Param('id') id: string,
    @Body() updateContactDto: UpdateContactDto,
  ) {
    try {
      const contact = this.contactsService.update(id, updateContactDto);
      if (!contact) {
        throw new NotFoundException('Contact does not exist!');
      }
      return res.status(HttpStatus.OK).json({
        message: 'Contact has been successfully updated',
        contact,
      });
    } catch (error) {
      return res.status(HttpStatus.BAD_REQUEST).json({
        message: 'Error: Contact not updated!',
        status: 400,
      });
    }
  }

  @Delete(':id')
  remove(@Res() res, @Param('id') id: string) {
    if (!id) {
      throw new NotFoundException('Contact ID does not exist');
    }
    const contact = this.contactsService.remove(id);
    if (!contact) {
      throw new NotFoundException('Contact does not exist');
    }

    return res.status(HttpStatus.NO_CONTENT).json({
      message: 'Contact has been deleted',
      contact,
    });
  }
}
/** Converts a display name into an id name. */
export function toIdName(str: string): string {
    return str
        .trim()
        .toLowerCase()
        .replace(/[^a-z0-9]+/g, "");
}
class SomeClass {
	public static SomeStaticValue: string = "hello";
	public someMemberValue: number = 15;
	private somePrivateValue: boolean = false;

	constructor () {
		SomeClass.SomeStaticValue = SomeClass.getGoodbye();
		this.someMemberValue = this.getFortyTwo();
		this.somePrivateValue = this.getTrue();
	}

	public static getGoodbye(): string {
	   return "goodbye!";
	}

	public getFortyTwo(): number {
	   return 42;
	}

	private getTrue(): boolean {
	     return true;
	}
}

console.log(SomeClass.getGoodbye())declare module "ui/layouts/stack-layout" {
    import layout = require("ui/layouts/layout-base");
    import dependencyObservable = require("ui/core/dependency-observable");

    /**
     * A Layout that arranges its children horizontally or vertically. The direction can be set by orientation property.
     */
    class StackLayout extends layout.LayoutBase {

        /**
         * Represents the observable property backing the orientation property of each StackLayout instance.
         */
        public static orientationProperty: dependencyOb


FEAT");

            line = ReadLine();
            m_pExtCapabilities = new List<string>();
            if(line.StartsWith("211")){
                line = ReadLine();
                while(line.StartsWith(" ")){
                    m_pExtCapabilities.Add(line.Trim());

                    line = ReadLine();
                }
            }

            #endregion
        }

        #endregion

		#region Properties Implementation

		/// <summary>
		/// Gets or sets data connection establish mode.
		/// </summary>
        /// <exception cref="ObjectDisposedException">Is raised when this object is disposed and this property is accessed.</exception>
		public FTP_TransferMode TransferMode
		{
			get{
                if(this.IsDisposed){
                    throw new ObjectDisposedException(this.GetType().Name);
                }

                return m_TransferMode;
            }

			set{
                if(this.IsDisposed){
                    throw new ObjectDisposedException(this.GetType().Name);
                }

                m_TransferMode = value;
            }
		}

        /// <summary>
        /// Gets or sets local IP address to use for data connection. Value null means that system will allocate it.
        /// </summary>
        /// <exception cref="ObjectDisposedException">Is raised when this object is disposed and this property is accessed.</exception>
        public IPAddress DataIP
        {
            get{
                if(this.IsDisposed){
                    throw new ObjectDisposedException(this.GetType().Name);
                }

                return m_pDataConnectionIP;
            }

            set{
                if(this.IsDisposed){
                    throw new ObjectDisposedException(this.GetType().Name);
                }

                m_pDataConnectionIP = value;

                // If We are connected, we need to reset data connection.
                if(this.IsConnected){
                    m_pDataConnection.CleanUpSocket();
                }
            }
        }

        /// <summary>
        /// Gets or sets ports what data connection may use. Value null means that system will allocate it.
        /// </summary>
        /// <exception cref="ObjectDisposedException">Is raised when this object is disposed and this property is accessed.</exception>
        public PortRange DataPortRange
        {
            get{
                if(this.IsDisposed){
                    throw new ObjectDisposedException(this.GetType().Name);
                }

                return m_pDataPortRange;
            }

            set{
                if(this.IsDisposed){
                    throw new ObjectDisposedExce


8.41}}},
            [npcKeys.waypoints] = waypointPresets.ORGRIMS_HAMMER,
            [npcKeys.zoneID] = zoneIDs.ICECROWN,
        },
        [32302] = {
            [npcKeys.spawns] = {[zoneIDs.ICECROWN]={{63.59,52.34}}},
            [npcKeys.waypoints] = waypointPresets.THE_SKYBREAKER,
            [npcKeys.zoneID] = zoneIDs.ICECROWN,
        },
        [32327] = {
            [npcKeys.spawns] = {[zoneIDs.DRAGONBLIGHT]={{71.71,39.21}}},
            [npcKeys.zoneID] = zoneIDs.DRAGONBLIGHT,
        },
        [32370] = {
            [npcKeys.spawns] = {[zoneIDs.ICECROWN]={{68.05,51.83}}},
            [npcKeys.zoneID] = zoneIDs.ICECROWN,
        },
        [32408] = {
            [npcKeys.spawns] = {[zoneIDs.ICECROWN]={{68.02,51.59}}},
            [npcKeys.zoneID] = zoneIDs.ICECROWN,
        },
        [32423] = {
            [npcKeys.spawns] = {[zoneIDs.ICECROWN]={{71.6,37.5}}},
            [npcKeys.zoneID] = zoneIDs.ICECROWN,
        },
        [32430] = {
            [npcKeys.spawns] = {[zoneIDs.ICECROWN]={{54,36.9}}},
            [npcKeys.zoneID] = zoneIDs.ICECROWN,
        },
        [32444] = {
            [npcKeys.spawns] = {[zoneIDs.ICECROWN]={{53.95,42.93}}},
            [npcKeys.zoneID] = zoneIDs.ICECROWN,
        },
        [32497] = {
            [npcKeys.spawns] = {[zoneIDs.ICECROWN]={{49.2,73.2}}},
            [npcKeys.zoneID] = zoneIDs.ICECROWN,
        },
        [32587] = {
            [npcKeys.spawns] = {[zoneIDs.ICECROWN]={{49.82,73.53}}},
            [npcKeys.zoneID] = zoneIDs.ICECROWN,
        },
        [32588] = {
            [npcKeys.spawns] = {[zoneIDs.ICECROWN]={{49.27,74.1}}},
            [npcKeys.zoneID] = zoneIDs.ICECROWN,
        },
        [32593] = {
            [npcKeys.spawns] = {[zoneIDs.AZJOL_NERUB]={{-1,-1}}},
        },
        [32648] = {
            [npcKeys.spawns] = {[zoneIDs.ICECROWN]={{42.9,78.71}}},
            [npcKeys.zoneID] = zoneIDs.ICECROWN,
        },
        [32663] = {
            [npcKeys.spawns] = {[zoneIDs.GRIZZLY_HILLS]={{16.37,48.26}}},
        },
        [32801] = {
            [npcKeys.questStarts] = {13485},
            [npcKeys.questEnds] = {13485},
        },
        [32802] = {
            [npcKeys.questStarts] = {13486},
            [npcKeys.questEnds] = {13486},
        },
        [32803] = {
            [npcKeys.questStarts] = {13487},
            [npcKeys.questEnds] =


lainObject(t[a])||(t[a]={});var w=t[a],T=l.newContainer(e,a);T._id=T._name=a,T._attr=n.id+"."+a,T._traceIndices=c.map((function(t){return t._expandedIndex}));var k=_("visible");if(T.type="linear",d(T,x),h(w,T,_,T.type),k){var A,M,S,E,C="realaxis"===a;C&&_("side"),C?_("tickvals"):_("tickvals",v(e.realaxis.tickvals||m.realaxis.tickvals.dflt)),o.isTypedArray(T.tickvals)&&(T.tickvals=Array.from(T.tickvals));var L=n.font||{};k&&(M=(A=_("color"))===w.color?A:L.color,S=L.size,E=L.family),f(w,T,_,T.type,{noAutotickangles:!0,noTicklabelshift:!0,noTicklabelstandoff:!0,noTicklabelstep:!0,noAng:!C,noExp:!0,font:{color:M,size:S,family:E}}),o.coerce2(t,e,m,a+".ticklen"),o.coerce2(t,e,m,a+".tickwidth"),o.coerce2(t,e,m,a+".tickcolor",e.color),_("ticks")||(delete e[a].ticklen,delete e[a].tickwidth,delete e[a].tickcolor),p(w,T,_,{dfltColor:A,bgColor:n.bgColor,blend:60,showLine:!0,showGrid:!0,noZeroLine:!0,attributes:m[a]}),_("layer")}_("hoverformat"),delete T.type,T._input=w}}t.exports=function(t,e,r){c(t,e,r,{noUirevision:!0,type:g.name,attributes:m,handleDefaults:x,font:e.font,paper_bgcolor:e.paper_bgcolor,fullData:r,layoutOut:e})}},4448:function(t,e,r){"use strict";var n=r(34809),i=r(78032),a=r(13792).N;t.exports=function(t,e,r,o){var s,l,c=o.type,u=o.attributes,h=o.handleDefaults,f=o.partition||"x",p=e._subplots[c],d=p.length,m=d&&p[0].replace(/\d+$/,"");function g(t,e){return n.coerce(s,l,u,t,e)}for(var y=0;y<d;y++){var v=p[y];s=t[v]?t[v]:t[v]={},l=i.newContainer(e,v,m),o.noUirevision||g("uirevision",e.uirevision);var x={};x[f]=[y/d,(y+1)/d],a(l,e,g,x),o.id=v,h(s,l,g,o)}}},3208:function(t,e,r){"use strict";var n=r(87296);function i(t){var e=t.description?" "+t.description:"",r=t.keys||[];if(r.length>0){for(var n=[],i=0;i<r.length;i++)n[i]="`"+r[i]+"`";e+="Finally, the template string has access to ",e=1===r.length?e+"variable "+n[0]:e+"variables "+n.slice(0,-1).join(", ")+" and "+n.slice(-1)+"."}return e}n.FORMAT_LINK,n.DATE_FORMAT_LINK,e.rb=function(t,e){t=t||{},i(e=e||{});var r={valType:"string",dflt:"",editType:t.editType||"none"};return!1!==t.arrayOk&&(r.arrayOk=!0),r},e.ay=function(t,e){t=t||{},i(e


from django.contrib import admin
from .models import *
# Register your models here.
admin.site.register(Book)
admin.site.register(Subscription)
admin.site.register(Borrowing)
admin.site.register(DamagedorLostHistory)
admin.site.register(Notifications)


SWORD"))
        }
    }
}

fun isBootProject(project: Project): Boolean {
    return project.name.startsWith("boot-") || project.findProperty("devops.boot") == "true"
}

apply(from = rootProject.file("gradle/publish-api.gradle.kts"))
apply(from = rootProject.file("gradle/publish-all.gradle.kts"))
/*
 * Tencent is pleased to support the open source community by making BK-CI 蓝鲸持续集成平台 available.
 *
 * Copyright (C) 2019 Tencent.  All rights reserved.
 *
 * BK-CI 蓝鲸持续集成平台 is licensed under the MIT license.
 *
 * A copy of the MIT License is included in this file.
 *
 *
 * Terms of the MIT License:
 * ---------------------------------------------------
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of
 * the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 * LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
 * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

package com.tencent.bkrepo.proxy.security

import com.tencent.bkrepo.auth.api.proxy.ProxyAccountClient
import com.tencent.bkrepo.auth.api.proxy.ProxyOauthAuthorizationClient
import com.tencent.bkrepo.auth.api.proxy.ProxyTemporaryTokenClient
import com.tencent.bkrepo.auth.api.proxy.ProxyUserClient
import com.tencent.bkrepo.auth.pojo.oauth.OauthToken
import com.tencent.bkrepo.auth.pojo.token.TemporaryTokenInfo
import com.tencent.bkrepo.auth.pojo.user.CreateUserRequest
import com.tencent.bkrepo.auth.pojo.user.UserInfo
import com.tencent.bkrepo.common.security.exception.AuthenticationException
import com.tencent.bkrepo.common.security.manager.AuthenticationManager
import com.tencent.bkrepo.common.service.proxy.ProxyFeignClientFactory

class ProxyAuthenticationManager : AuthenticationManager() {
    private val proxyUserClient: ProxyUserClient by lazy { ProxyFeignClientFactory.create("auth") }
    private val proxyAccountClient: ProxyAccountClient by lazy { ProxyFeignClientFactory.create("auth") }
    private val proxyOauthAuthorizationClient: ProxyOauthAuthorizationClient
        by lazy { ProxyFeignClientFactory.create("auth") }
    private val proxyTemporaryTokenClient: ProxyTemporaryTokenClient
        by lazy { ProxyFeignClientFactory.create("auth") }

    /**
     * 校验普通用户类型账户
     * @throws AuthenticationException 校验失败
     */
    override fun checkUserAccount(uid: String, token: String): String {
        val response = proxyUserClient.checkToken(uid, token)
        return if (response.data


6c0 -9.59961 -3.2002 -15.999 -9.59961 -19.1992c-3.2002 -12.8008 -3.2002 -57.6006 0 -73.6006c6.39941 -6.39941 9.59961 -12.7998 9.59961 -19.2002v-16c0 -16 -12.7998 -25.5996 -25.5996 -25.5996h-326.4c-54.4004 0 -96 41.5996 -96 96v320\nc0 54.4004 41.5996 96 96 96h326.4c16 0 25.5996 -9.59961 25.5996 -25.5996v-332.801zM144 280v-48c0 -4.41602 3.58398 -8 8 -8h56v-56c0 -4.41602 3.58398 -8 8 -8h48c4.41602 0 8 3.58398 8 8v56h56c4.41602 0 8 3.58398 8 8v48c0 4.41602 -3.58398 8 -8 8h-56v56\nc0 4.41602 -3.58398 8 -8 8h-48c-4.41602 0 -8 -3.58398 -8 -8v-56h-56c-4.41602 0 -8 -3.58398 -8 -8zM380.8 0v64h-284.8c-16 0 -32 -12.7998 -32 -32s12.7998 -32 32 -32h284.8z\" />\n    <glyph glyph-name=\"bread-slice\" unicode=\"\" horiz-adv-x=\"576\" \nd=\"M288 448c180 0 288 -93.4004 288 -169.14c0 -30.3008 -24.2402 -54.8604 -64 -54.8604v-256c0 -17.6699 -16.1201 -32 -36 -32h-376c-19.8799 0 -36 14.3301 -36 32v256c-39.7598 0 -64 24.5596 -64 54.8604c0 75.7393 108 169.14 288 169.14z\" />\n    <glyph glyph-name=\"cheese\" unicode=\"\" \nd=\"M0 160h512v-160c0 -17.6641 -14.3359 -32 -32 -32h-448c-17.6641 0 -32 14.3359 -32 32v160zM299.83 416c118.17 -6.2002 212.17 -104.11 212.17 -224h-512l278.7 217c4.83984 3.875 13.7998 7.01953 20 7.01953c0.311523 0 0.818359 -0.00878906 1.12988 -0.0195312z\n\" />\n    <glyph glyph-name=\"clinic-medical\" unicode=\"\" horiz-adv-x=\"576\" \nd=\"M288 333l218.74 -192.9c1.54004 -1.37988 3.55957 -2.04004 5.25977 -3.19922v-184.9c0 -8.83203 -7.16797 -16 -16 -16h-416c-8.83203 0 -16 7.16797 -16 16v184.94c1.78027 1.20996 3.84961 1.88965 5.46973 3.34961zM384 72v48c0 4.41602 -3.58398 8 -8 8h-56v56\nc0 4.41602 -3.58398 8 -8 8h-48c-4.41602 0 -8 -3.58398 -8 -8v-56h-56c-4.41602 0 -8 -3.58398 -8 -8v-48c0 -4.41602 3.58398 -8 8 -8h56v-56c0 -4.41602 3.58398 -8 8 -8h48c4.41602 0 8 3.58398 8 8v56h56c4.41602 0 8 3.58398 8 8zM570.69 211.72\nc2.93066 -2.63


代，确保活动策划、执行流程的高效和稳定。

3. 负责活动平台的整体架构设计及优化，解决大流量、高并发下的系统性能瓶颈和技术难题。

4. 参与活动需求的沟通、评审与测试，确保营销活动的顺利上线及效果追踪。

5. 与业务部门密切合作，提供技术支持，确保线上营销活动的顺利开展和效果评估。

职位要求

1. 承担核心业务：直接参与营销活动的技术支持和执行，职责关键，成就感强。

2. 技术挑战与成长：面对大流量、高并发场景的技术难题，提供广阔的技术成长空间和丰富的实践经验。

3. 职业发展前景：重视员工的职业发展与培养，有完善的晋升机制及培训体系。

---

#### [分析系统高级开发工程师](https://zhaopin.meituan.com/web/position/detail?jobUnionId=3393088201&highlightType=social)

📍

职位描述

1. 负责万亿流量下，大规模、多渠道用户行为的路径、转化、留存、探查分析系统能力建设，设计可扩展的服务架构，优化性能和稳定性；

2. 对用户行为分析产品的核心模块进行系统性思考，抽象通用能力，并有计划的推动产品能力持续迭代；

3. 能够深入理解业务，进行重点难点技术攻关工作，将技术实现与业务场景联系起来，快速解决业务需求问题；

4. 不断探索用户行为分析的场景能力，与全公司各业务上下游合作构建丰富的行为分析应用生态，推动技术能力进步和技术氛围的建设。

职位要求

1.业务价值大，美团用户行为分析团队负责建设全公司统一的行为分析产品，业务场景丰富，服务于全公司各个业务线的产品设计、增长策略、线下选址、供给投放等场景；

2.技术挑战大，用户行为分析产品需要在日新增万亿流量，多App渠道、多业务、长周期维度下，建设多种分析能力，达到秒级别的分析性能。

---

#### [数据平台履约-大数据开发工程师](https://zhaopin.meituan.com/we


            computeMAP(new GenericFastImageSearcher(1000, AutoColorCorrelogram.class, SimpleExtractor.KeypointDetector.CVSURF, new VLAD(), numOfClusters[i], true, reader, indexPath + ".config"), "Simple VLAD AutoColorCorrelogram CVSURF", reader, numOfClusters[i]);
//            computeMAP(new GenericFastImageSearcher(1000, OpponentHistogram.class, SimpleExtractor.KeypointDetector.CVSURF, new VLAD(), numOfClusters[i], true, reader, indexPath + ".config"), "Simple VLAD OpponentHistogram CVSURF", reader, numOfClusters[i]);
//            computeMAP(new GenericFastImageSearcher(1000, ColorLayout.class, SimpleExtractor.KeypointDetector.CVSURF, new VLAD(), numOfClusters[i], true, reader, indexPath + ".config"), "Simple VLAD ColorLayout CVSURF", reader, numOfClusters[i]);
//            computeMAP(new GenericFastImageSearcher(1000, EdgeHistogram.class, SimpleExtractor.KeypointDetector.CVSURF, new VLAD(), numOfClusters[i], true, reader, indexPath + ".config"), "Simple VLAD EdgeHistogram CVSURF", reader, numOfClusters[i]);
//            computeMAP(new GenericFastImageSearcher(1000, ScalableColor.class, SimpleExtractor.KeypointDetector.CVSURF, new VLAD(), numOfClusters[i], true, reader, indexPath + ".config"), "Simple VLAD ScalableColor CVSURF", reader, numOfClusters[i]);
////
//            computeMAP(new GenericFastImageSearcher(1000, CvSurfExtractor.class, new VLAD(), numOfClusters[i], true, reader, indexPath + ".config"), "CVSURF VLAD", reader, numOfClusters[i]);
//            computeMAP(new GenericFastImageSearcher(1000, CvSiftExtractor.class, new VLAD(), numOfClusters[i], true, reader, indexPath + ".config"), "CVSIFT VLAD", reader, numOfClusters[i]);
//            computeMAP(new GenericFastImageSearcher(1000, SurfExtractor.class, new VLAD(), numOfClusters[i], true, reader, indexPath + ".config"), "SURF VLAD", reader, numOfClusters[i]);
//            computeMAP(new GenericFastImageSearcher(1000, SiftExtractor.class, new VLAD(), numOfClusters[i], true, reader, indexPath + ".config"), "SIFT VLAD", reader, numOfClusters[i]);
////            computeMAP(new GenericFastImageSearcher(1000, SelfSimilaritiesExtractor.class, new VLAD(), numOfClusters[i], true, reader, indexPath + ".config"), "SelfSimilarities VLAD", reader, numOfClusters[i]);
//        }

        double h = (System.currentTimeMillis() - start) / 3600000.0;
        double m = (h - Math.floor(h)) * 60.0;
        double s = (m - Math.floor(m)) * 60;
        System.out.printf("Total time of searching: %s.\n", String.format("%s%02d:%02d", (((int)h > 0)? String.format("%02d:", (int) h) : ""), (int)m, (int)s));
    }

    public void performWSs (Class<? extends GlobalFeature> globalFeature, SimpleExtractor.KeypointDetector detector, Aggregator aggregator, int codebookSize, IndexReader reader, String codebooksDir, String prefix) throws IOException
    {
        computeMAP(new ImageSearcherUsingWSs(1000, globalFeature, detector, aggregator, codebookSize, reader, codebooksDir, false, false, false), prefix, reader, codebookSize);
        computeMAP(new ImageSearcherUsingWSs(1000, globalFeature, detector, aggregator, codebookSize, reader, codebooksDir, false,


< self.args.min_search_granularity * qps / 100:
                break

            qps = (left + right) / 2

            is_under_sla, scheduling_delay = self.is_under_sla(qps)

            if scheduling_delay is None:
                break

            if is_under_sla:
                max_qps_under_sla = qps

                if scheduling_delay < self.args.scheduling_delay_slo_value / 8:
                    # if the scheduling delay is very low, we can increase the QPS more aggressively
                    right = min(right * 4, min_qps_over_sla)
                elif scheduling_delay < self.args.scheduling_delay_slo_value / 4:
                    right = min(right * 2, min_qps_over_sla)
                elif qps > 0.8 * right:
                    right = min(right * 2, min_qps_over_sla)

                left = qps
            else:
                if scheduling_delay > 500:
                    right = qps / 2
                elif scheduling_delay > 1000:
                    right = qps / 4
                else:
                    right = qps

                min_qps_over_sla = min(min_qps_over_sla, qps)

        logger.info(
            f"Max QPS under SLO for {self.job_config.get_human_readable_name()}: {max_qps_under_sla}",
        )

        self.release_cpu_core_id()

        return {
            **self.job_config.to_config_dict(),
            "max_qps_under_sla": max_qps_under_sla,
        }


                                         const uint8_t* src_argb,
                                                 int dst_width,
                                                 int x,
                                                 int dx) {
  __asm {
    push       esi
    push       edi
    mov        edi, [esp + 8 + 4]  // dst_argb
    mov        esi, [esp + 8 + 8]  // src_argb
    mov        ecx, [esp + 8 + 12]  // dst_width
    movd       xmm2, [esp + 8 + 16]  // x
    movd       xmm3, [esp + 8 + 20]  // dx
    movdqa     xmm4, xmmword ptr kShuffleColARGB
    movdqa     xmm5, xmmword ptr kShuffleFractions
    pcmpeqb    xmm6, xmm6  // generate 0x007f for inverting fraction.
    psrlw      xmm6, 9
    pextrw     eax, xmm2, 1  // get x0 integer. preroll
    sub        ecx, 2
    jl         xloop29

    movdqa     xmm0, xmm2  // x1 = x0 + dx
    paddd      xmm0, xmm3
    punpckldq  xmm2, xmm0  // x0 x1
    punpckldq  xmm3, xmm3  // dx dx
    paddd      xmm3, xmm3  // dx * 2, dx * 2
    pextrw     edx, xmm2, 3  // get x1 integer. preroll

    // 2 Pixel loop.
  xloop2:
    movdqa     xmm1, xmm2  // x0, x1 fractions.
    paddd      xmm2, xmm3  // x += dx
    movq       xmm0, qword ptr [esi + eax * 4]  // 2 source x0 pixels
    psrlw      xmm1, 9  // 7 bit fractions.
    movhps     xmm0, qword ptr [esi + edx * 4]  // 2 source x1 pixels
    pshufb     xmm1, xmm5  // 0000000011111111
    pshufb     xmm0, xmm4  // arrange pixels into pairs
    pxor       xmm1, xmm6  // 0..7f and 7f..0
    pmaddubsw  xmm0, xmm1  // argb_argb 16 bit, 2 pixels.
    pextrw     eax, xmm2, 1  // get x0 integer. next iteration.
    pextrw     edx, xmm2, 3  // get x1 integer. next iteration.
    psrlw      xmm0, 7  // argb 8.7 fixed point to low 8 bits.
    packuswb   xmm0, xmm0  // argb_argb 8 bits, 2 pixels.
    movq       qword ptr [edi], xmm0
    lea        edi, [edi + 8]
    sub        ecx, 2  // 2 pixels
    jge        xloop2

 xloop29:

    add        ecx, 2 - 1
    jl         xloop99

            // 1 pixel remainder
    psrlw      xmm2, 9  // 7 bit fractions.
    movq       xmm0, qword ptr [esi + eax * 4]  // 2 source x0 pixels
    pshufb     xmm2, xmm5  // 00000000
    pshufb     xmm0, xmm4  // arrange pixels into pairs
    pxor       xmm2, xmm6  // 0..7f and 7f..0
    pmaddubsw  xmm0, xmm2  // argb 16 bit, 1 pixel.
    psrlw      xmm0, 7
    packuswb   xmm0, xmm0  // argb 8 bits, 1 pixel.
    movd       [edi], xmm0

 xloop99:

    pop        edi
    pop        esi
    ret
  }
}

// Reads 4 pixels