f(AUGM_IDWRAP) &&
                 pWrap->tag == AUGM_WRAPTAG &&
                 pWrap->version == nVersion) ?
            S_OK : E_UNEXPECTED;         //BUGBUG: better error code for version mismatch?
    }
    else
    {
        return E_INVALIDARG;
    }
}

//  Retrieves the number of source namespace pidls in the wrap.
//  If the pidl was not wrapped, the return value is -1.
ULONG AugMergeISF_GetSourceCount(IN LPCITEMIDLIST pidl)
{
    ASSERT(SUCCEEDED(AugMergeISF_IsWrap(pidl)));
    return AugMergeISF_GetWrap(pidl)->cSrcs;
}

//  Creates an IDLIST wrapper object based on the indicated source pidl.
HRESULT AugMergeISF_CreateWrap(
    IN LPCITEMIDLIST pidlSrc,
    IN UINT nSrcID,
    OUT LPITEMIDLIST* ppidlWrap)
{
    ASSERT(ppidlWrap);
    ASSERT(IS_VALID_PIDL(pidlSrc) && INVALID_NAMESPACE_INDEX != nSrcID);

    *ppidlWrap = NULL;

    //  Allocate a header and terminator
    LPBYTE pBuf = NULL;
    WORD   cbAlloc = sizeof(AUGM_IDWRAP) +
        sizeof(AUGM_IDSRC) + pidlSrc->mkid.cb +
        // we need two terminators, one for pidlSrc and one for the wrap
        // the one for pidlSrc is necessary for the ILClone to work
        // because it gets confused with the nSrcID that follows the pidl
        CB_IDLIST_TERMINATOR +
        CB_IDLIST_TERMINATOR;

    if (NULL == (pBuf = (LPBYTE)IEILCreate(cbAlloc)))
        return E_OUTOFMEMORY;

    //  Initialize wrap header members
    PAUGM_IDWRAP pWrap = AugMergeISF_GetWrap(pBuf);
    pWrap->cb = cbAlloc - CB_IDLIST_TERMINATOR;
    pWrap->tag = AUGM_WRAPTAG;
    pWrap->version = AUGM_WRAPCURRENTVERSION;

    if (pidlSrc)
    {
        PAUGM_IDSRC pSrc = (PAUGM_IDSRC)(pBuf + sizeof(AUGM_IDWRAP));
        pSrc->nID = nSrcID;
        memcpy(pSrc->pidl, pidlSrc, pidlSrc->mkid.cb);
        pWrap->cSrcs = 1;
    }

    *ppidlWrap = (LPITEMIDLIST)pWrap;
    return S_OK;
}

BOOL WrappedPidlContainsSrcID(LPCITEMIDLIST pidlWrap, UINT uSrcID)
{
    ASSERT(SUCCEEDED(AugMergeISF_IsWrap(pidlWrap)));
    PAUGM_IDWRAP pWrap = AugMergeISF_GetWrap(pidlWrap);

    if (pWrap->cSrcs > 0)
    {
        LPBYTE       p = ((LPBYTE)pWrap) + sizeof(AUGM_IDWRAP); // position of first pidl header.
        PAUGM_IDSRC  pSrc = (PAUGM_IDSRC)p;
        // offset to next pidl header, needs terminator so that ILClone below can work
        UINT         cbPidl = ((LPITEMIDLIST)pSrc->pidl)->mkid.cb + CB_IDLIST_TERMINATOR;

        if (pSrc->nID != uSrcID && pWrap->cSrcs > 1)
        {
            pSrc = (PAUGM_IDSRC)(p + sizeof(AUGM_IDSRC) + cbPidl);
        }

        if (pSrc->nID == uSrcID)
            return TRUE;
    }

    return FALSE;
}

HRESULT AugMergeISF_WrapRemovePidl(
    IN LPITEMIDLIST pidlWrap,
    IN UINT nSrcID,
    OUT LPITEMIDLIST* ppidlRet)
{
    ASSERT(IS_VALID_WRITE_PTR(ppidlRet, LPITEMIDLIST));

    *ppidlRet = NULL;

    HRESULT hr = AugMergeISF_IsWrap(pidlWrap);
    if (SUCCEEDED(hr))
    {
        PAUGM_IDWRAP


mbol>('FailureFailure', toI(images.challengeFF), [FAILURE, FAILURE]),
  new DieSide<SwSymbol>('Threat', toI(images.challengeT), [THREAT]),
  new DieSide<SwSymbol>('Threat', toI(images.challengeT), [THREAT]),
  new DieSide<SwSymbol>('FailureThreat', toI(images.challengeFT), [FAILURE, THREAT]),
  new DieSide<SwSymbol>('FailureThreat', toI(images.challengeFT), [FAILURE, THREAT]),
  new DieSide<SwSymbol>('ThreatThreat', toI(images.challengeTT), [THREAT, THREAT]),
  new DieSide<SwSymbol>('ThreatThreat', toI(images.challengeTT), [THREAT, THREAT]),
  new DieSide<SwSymbol>('Despair', toI(images.challengeDespair), [DESPAIR]),
]);

export const SwForceDie: SwDie = new Die<SwSymbol>('force', toI(images.force), [
  new DieSide<SwSymbol>('Dark', toI(images.forceD), [DARK]),
  new DieSide<SwSymbol>('Dark', toI(images.forceD), [DARK]),
  new DieSide<SwSymbol>('Dark', toI(images.forceD), [DARK]),
  new DieSide<SwSymbol>('Dark', toI(images.forceD), [DARK]),
  new DieSide<SwSymbol>('Dark', toI(images.forceD), [DARK]),
  new DieSide<SwSymbol>('Dark', toI(images.forceD), [DARK]),
  new DieSide<SwSymbol>('DarkDark', toI(images.forceDD), [DARK, DARK]),
  new DieSide<SwSymbol>('Light', toI(images.forceL), [LIGHT]),
  new DieSide<SwSymbol>('Light', toI(images.forceL), [LIGHT]),
  new DieSide<SwSymbol>('LightLight', toI(images.forceLL), [LIGHT, LIGHT]),
  new DieSide<SwSymbol>('LightLight', toI(images.forceLL), [LIGHT, LIGHT]),
  new DieSide<SwSymbol>('LightLight', toI(images.forceLL), [LIGHT, LIGHT]),
]);

export const dice: Record<string, SwDie> = {
  ability:     SwAbilityDie,
  proficiency: SwProficiencyDie,
  boost:       SwBoostDie,
  difficulty:  SwDifficultyDie,
  challenge:   SwChallengeDie,
  setback:     SwSetbackDie,
  force:       SwForceDie,
};
import { Observable } from "tns-core-modules/data/observable";
import { Speaker, RoomInfo } from "~/shared/interfaces";
import { SpeakerData } from "~/data/speaker-data";
import { SessionData } from "~/data/session-data";

export class RoomListViewModel extends Observable {

    private _rooms: Array<RoomInfo> = new Array<RoomInfo>();
    private _addedRoom: string;
    private _isLoading: boolean = false;
    private _sessionData: SessionData;

    constructor(existingRoom: string){
        super();
        if(existingRoom)
        {
            this._addedRoom = existingRoom;
        }

        this._sessionData= new SessionData();
        this.set('isLoading',true);
    }

    public async init(){
        console.log("calling init");

        var promises = [];
        promises.push(this._sessionData.getAllRooms());

        await Promise.all(promises)
            .then(async values => {
                await this.pushRooms(values[0]);
                console.log("got rooms: " + this._rooms.length);

                this.onDataLoaded();

            })
            .catch(e => {
                console.log("error: ", e);


onLookoutMetricsConfig ClientConfig
        {
            get
            {
                return base._ClientConfig as AmazonLookoutMetricsConfig;
            }
            set
            {
                base._ClientConfig = value;
            }
        }

        protected IAmazonLookoutMetrics CreateClient(AWSCredentials credentials, RegionEndpoint region)
        {
            var config = this.ClientConfig ?? new AmazonLookoutMetricsConfig();
            if (region != null) config.RegionEndpoint = region;
            if (!string.IsNullOrEmpty(ProfileName))
            {
                config.AWSTokenProvider = new ProfileTokenProvider(ProfileName);
            }
            Amazon.PowerShell.Utils.Common.PopulateConfig(this, config);
            this.CustomizeClientConfig(config);
            var client = new AmazonLookoutMetricsClient(credentials, config);
            client.BeforeRequestEvent += RequestEventHandler;
            client.AfterResponseEvent += ResponseEventHandler;
            return client;
        }

        protected override void BeginProcessing()
        {
            base.AWSServiceId = AmazonLookoutMetricsConfig.ServiceId.ToString();

            base.BeginProcessing();
        }

        protected override void ProcessRecord()
        {
            base.ProcessRecord();

            Client = CreateClient(_CurrentCredentials, _RegionEndpoint);
        }
    }
}


8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	         http://www.springframework.org/schema/beans/spring-beans.xsd
		 http://www.springframework.org/schema/context">

    <bean class="cn.bugstack.springframework.beans.factory.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:token.properties"/>
    </bean>

    <bean id="userService" class="cn.bugstack.springframework.test.bean.UserService">
        <property name="token" value="${token}"/>
    </bean>

</beans>
```

- 加载 `classpath:token.properties` 设置占位符属性值 `${token}`

**spring-scan.xml**

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	         http://www.springframework.org/schema/beans/spring-beans.xsd
		 http://www.springframework.org/schema/context">

    <context:component-scan base-package="cn.bugstack.springframework.test.bean"/>

</beans>
```

- 添加 `component-scan` 属性，设置包扫描根路径

### 4. 单元测试(占位符)

```java
@Test
public void test_property() {
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring-property.xml");
    IUserService userService = applicationContext.getBean("userService", IUserService.class);
    System.out.println("测试结果：" + userService);
}
```

**测试结果**

```java
测试结果：UserService#token = { RejDlI78hu223Opo983Ds }

Process finished with exit code 0
```

- 通过测试结果可以看到


ttom: 0 !important;
}

div.asl_s.searchsettings .asl_option_label {
    font-size: 14px;
    line-height: 20px !important;
    margin: 0;
    width: 150px;
    text-shadow: none;
    padding: 0;
    min-height: 20px;
    border: none;
    background: transparent;
    float: none;
}

div.asl_s.searchsettings .asl_option_inner input[type=checkbox] {
    display: none !important;
}

div.asl_s.searchsettings.ie78 .asl_option_inner input[type=checkbox] {
    display: block;
}

div.asl_s.searchsettings.ie78 .asl_option_label {
    float: right !important;
}

div.asl_s.searchsettings .asl_option {
    display: flex;
    flex-direction: row;
    -webkit-flex-direction: row;
    align-items: flex-start;
    margin: 0 0 10px 0;
    cursor: pointer;
}

div.asl_s.searchsettings .asl_option.asl-o-last,
div.asl_s.searchsettings .asl_option:last-child {
    margin-bottom: 0;
}

div.asl_s.searchsettings .asl_option_inner {
    width: 17px;
    height: 17px;
    position: relative;
    flex-grow: 0;
    -webkit-flex-grow: 0;
    flex-shrink: 0;
    -webkit-flex-shrink: 0;
}

div.asl_s.searchsettings .asl_option_inner label {
    cursor: pointer;
    position: absolute;
    width: 17px;
    height: 17px;
    top: 0;
    padding: 0;
    border-radius: 2px;
    -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, .5), 0 1px 0 rgba(255, 255, 255, .2);
    -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, .5), 0 1px 0 rgba(255, 255, 255, .2);
    box-shadow: inset 0 1px 1px rgba(0, 0, 0, .5), 0 1px 0 rgba(255, 255, 255, .2);
    overflow: hidden;
    font-size: 0 !important;
    color: rgba(0, 0, 0, 0);
}

div.asl_s.searchsettings.ie78 .asl_option_inner label {
    display: none;
}

div.asl_s.searchsettings .asl_option_inner label:after {
    opacity: 0;
    font-family: 'aslsicons2';
    content: "\e800";
    font-weight: normal !important;
    background: transparent;
    border: none !important;
    box-sizing: content-box;
    color: #fff;
    height: 100%;
    width: 100%;
    padding: 0 !important;
    margin: 1px 0 0 0 !important;
    line-height: 17px;
    text-align: center;
    text-decoration: none;
    text-shadow: none;
    display: block;
    font-size: 11px !important;
    position: absolute;
    top: 0;
    left: 0;
    z-index: 1;
}

div.asl_s.searchsettings.ie78 .asl_option_inner label:after {
    display: none;
}

div.asl_s.searchsettings .asl_option_inner label:hover::after {
    opacity: .3;
}

div.asl_s.searchsettings .asl_option_inner input[type=checkbox]:checked+label:after {
    opacity: 1;
}

div.asl_s.searchsettings fieldset {
    position: relative;
    float:


Use),
        tsFinal = _objToTS2[0],
        offsetFinal = _objToTS2[1],
        inst = new DateTime({
      ts: tsFinal,
      zone: zoneToUse,
      o: offsetFinal,
      loc: loc
    }); // gregorian data + weekday serves only to validate

    if (normalized.weekday && containsGregor && obj.weekday !== inst.weekday) {
      return DateTime.invalid("mismatched weekday", "you can't specify both a weekday of " + normalized.weekday + " and a date of " + inst.toISO());
    }

    return inst;
  }
  /**
   * Create a DateTime from an ISO 8601 string
   * @param {string} text - the ISO string
   * @param {Object} opts - options to affect the creation
   * @param {string|Zone} [opts.zone='local'] - use this zone if no offset is specified in the input string itself. Will also convert the time to this zone
   * @param {boolean} [opts.setZone=false] - override the zone with a fixed-offset zone specified in the string itself, if it specifies one
   * @param {string} [opts.locale='system's locale'] - a locale to set on the resulting DateTime instance
   * @param {string} [opts.outputCalendar] - the output calendar to set on the resulting DateTime instance
   * @param {string} [opts.numberingSystem] - the numbering system to set on the resulting DateTime instance
   * @example DateTime.fromISO('2016-05-25T09:08:34.123')
   * @example DateTime.fromISO('2016-05-25T09:08:34.123+06:00')
   * @example DateTime.fromISO('2016-05-25T09:08:34.123+06:00', {setZone: true})
   * @example DateTime.fromISO('2016-05-25T09:08:34.123', {zone: 'utc'})
   * @example DateTime.fromISO('2016-W05-4')
   * @return {DateTime}
   */
  ;

  DateTime.fromISO = function fromISO(text, opts) {
    if (opts === void 0) {
      opts = {};
    }

    var _parseISODate = parseISODate(text),
        vals = _parseISODate[0],
        parsedZone = _parseISODate[1];

    return parseDataToDateTime(vals, parsedZone, opts, "ISO 8601", text);
  }
  /**
   * Create a DateTime from an RFC 2822 string
   * @param {string} text - the RFC 2822 string
   * @param {Object} opts - options to affect the creation
   * @param {string|Zone} [opts.zone='local'] - convert the time to this zone. Since the offset is always specified in the string itself, this has no effect on the interpretation of string, merely the zone the resulting DateTime is expressed in.
   * @param {boolean} [opts.setZone=false] - override the zone with a fixed-offset zone specified in the string itself, if it specifies one
   * @param {string} [opts.locale='system's locale'] - a locale to set on the resulting DateTime instance
   * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
   * @param {string} opts.numberingSystem - the numbering system to set on the resulting DateTime instance
   * @example DateTime.fromRFC2822('25 Nov 2016 13:23:12 GMT')
   * @example DateTime.fromRFC2822('Fri, 25 Nov 2016 13:23:12 +0600')
   * @example DateTime.fromRFC2822('25 Nov 2016 13:23 Z')
   * @return {DateTime}
   */
  ;

  DateTime.fromRFC2822 = function fromRFC2822(text, opts) {
    if (opts === void 0) {
      opts = {};
    }

    var _parseRFC2822Date = parseRFC2822Date(text),
        vals = _parseRFC2822Date[0],
        parsedZone = _parseRFC2822Date[1];

    return parseDataToDateTime(vals, parsedZone, opts, "RFC 2822", text);
  }
  /**
   * Create a DateTime from an HTTP header date


.getInt()
        return buildMap<{{ key_type_name }}, {{ value_type_name }}>(len) {
            repeat(len) {
                val k = {{ key_type|read_fn }}(buf)
                val v = {{ value_type|read_fn }}(buf)
                this[k] = v
            }
        }
    }

    override fun allocationSize(value: Map<{{ key_type_name }}, {{ value_type_name }}>): ULong {
        val spaceForMapSize = 4UL
        val spaceForChildren = value.map { (k, v) ->
            {{ key_type|allocation_size_fn }}(k) +
            {{ value_type|allocation_size_fn }}(v)
        }.sum()
        return spaceForMapSize + spaceForChildren
    }

    override fun write(value: Map<{{ key_type_name }}, {{ value_type_name }}>, buf: ByteBuffer) {
        buf.putInt(value.size)
        // The parens on `(k, v)` here ensure we're calling the right method,
        // which is important for compatibility with older android devices.
        // Ref https://blog.danlew.net/2017/03/16/kotlin-puzzler-whose-line-is-it-anyways/
        value.forEach { (k, v) ->
            {{ key_type|write_fn }}(k, buf)
            {{ value_type|write_fn }}(v, buf)
        }
    }
}
/* 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/. */

import uniffi.benchmarks.*
import kotlin.system.measureNanoTime

class TestCallbackObj : TestCallbackInterface {
    override fun method(a: Int, b: Int, data: TestData): String {
        return data.bar;
    }

    override fun methodWithVoidReturn(a: Int, b: Int, data: TestData) {
    }

    override fun methodWithNoArgsAndVoidReturn() {
    }

    override fun runTest(testCase: TestCase, count: ULong): ULong {
        return when (testCase) {
            TestCase.FUNCTION -> measureNanoTime {
                val data = TestData("StringOne", "StringTwo")
                for (i in 0UL..count) {
                    testFunction(10, 20, data)
                }
            }
            TestCase.VOID_RETURN -> measureNanoTime {
                for (i in 0UL..count) {
                    testVoidReturn(10, 20)
                }
            }
            TestCase.NO_ARGS_VOID_RETURN -> measureNanoTime {
                for (i in 0UL..count) {
                    testNoArgsVoidReturn()
                }
            }
        }.toULong()
    }
}

runBenchmarks("kotlin", TestCallbackObj())
/* 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/. */

import java.util.concurrent.*
import uniffi.coverall.*

// This tests the thread-safety of operations on object handles.
// The idea is to have a method call running on one thread while
// we try to destroy the object on another thread. This should
// be handled correctly at the Kotlin level, rather than triggering
// any fail-safe checks (or worse, memory unsafety!) in the underlying
// Rust code.
//
// This test was able to reproduce the concurrency issue in
// https://github.com/mozilla/uniffi-rs/issues/457, and is kept
// to prevent regressions.

// Give ourselves enough opportunity to trigger concurrency issues.
for (i in 1..1000) {
    // So we can operate concurrently.
    val executor = Executors.newFixedThreadPool(2)
    try {
        // On the main thread here, we're going to create and then destroy a `Coveralls` instance.
        val concurrentMethodCall: Future<String> = Coveralls("test_handlerace").use { coveralls ->
            /


oided_wakeups);
    pip->no_avoided_interrupts = erts_smp_atomic_read(&ps->no_avoided_interrupts);
    pip->no_interrupt_timed = erts_smp_atomic_read(&ps->no_interrupt_timed);
#endif

    ERTS_POLLSET_UNLOCK(ps);

}

/*
 * Fatal error...
 */

#ifndef ERTS_GOT_SIGUSR1
#  define ERTS_GOT_SIGUSR1 0
#endif

static void
fatal_error(char *format, ...)
{
    va_list ap;

    if (ERTS_IS_CRASH_DUMPING || ERTS_GOT_SIGUSR1) {
	/*
	 * Crash dump writing and reception of sigusr1 (which will
	 * result in a crash dump) closes all file descriptors. This
	 * typically results in a fatal error for erts_poll() (wakeup
	 * pipes and kernel poll fds are closed).
	 *
	 * We ignore the error and let the crash dump writing continue...
	 */
	return;
    }
    va_start(ap, format);
    erts_vfprintf(stderr, format, ap);
    va_end(ap);
    abort();
}

static void
fatal_error_async_signal_safe(char *error_str)
{
    if (ERTS_IS_CRASH_DUMPING || ERTS_GOT_SIGUSR1) {
	/* See comment above in fatal_error() */
	return;
    }
    if (error_str) {
	int len = 0;
	while (error_str[len])
	    len++;
	if (len)
	    (void) write(2, error_str, len); /* async signal safe */
    }
    abort();
}

/*
 * --- Debug -----------------------------------------------------------------
 */

void
ERTS_POLL_EXPORT(erts_poll_get_selected_events)(ErtsPollSet ps,
						ErtsPollEvents ev[],
						int len)
{
    int fd;
    ERTS_POLLSET_LOCK(ps);
    for (fd = 0; fd < len; fd++) {
	if (fd >= ps->fds_status_len)
	    ev[fd] = 0;
	else {
	    ev[fd] = ps->fds_status[fd].events;
#if ERTS_POLL_USE_WAKEUP_PIPE
	    if (fd == ps->wake_fds[0] || fd == ps->wake_fds[1])
		ev[fd] |= ERTS_POLL_EV_NVAL;
#endif
#if ERTS_POLL_USE_KERNEL_POLL
	    if (fd == ps->kp_fd)
		ev[fd] |= ERTS_POLL_EV_NVAL;
#endif
	}
    }
    ERTS_POLLSET_UNLOCK(ps);

}

#ifdef HARD_DEBUG

static void
check_poll_result(ErtsPollResFd pr[], int len)
{
    int i, j;

    for (i = 0; i < len; i++) {
	ASSERT(pr[i].fd >= 0);
	ASSERT(pr[i].fd < max_fds);
	for (j = 0; j < len; j++) {
	    ASSERT(i == j || pr[i].fd != pr[j].fd);
	}
    }
}

#if ERTS_POLL_USE_DEVPOLL

static void
check_poll_status(ErtsPollSet ps)
{
    int i;
    for (i = 0; i < ps->fds_status_len; i++) {
	int ires;
	struct pollfd dp_fd;
	short events = ERTS_POLL_EV_E2N(ps->fds_status[i].events);

	dp_fd.fd = i;
	dp_fd.events = (short) 0;
	dp_fd.revents = (short) 0;

	ires = ioctl(ps->kp_fd, DP_ISPOLLED, &dp_fd);

	if (ires == 0) {
	    ASSERT(!events);
	}
	else if (ires == 1) {
	    ASSERT(events);
	    ASSERT(events == dp_fd.revents);
	}
	else {
	    ASSERT(0);
	}
	ASSERT(dp_fd.fd == i);
	ASSERT(ps->fds_status[i].events == ps->fds_status[i].used_events);
    }
}

#endif /* ERTS_POLL_USE_DEVPOLL */
#endif /* HARD_DEBUG */

#ifdef ERTS_POLL_DEBUG_PRINT
static void
print_misc_debug_info(void)
{
    erts_printf("erts_poll using: %s lazy_updates:%s batch_updates:%s\n",
#if ERTS_POLL_USE_KQUEUE
		"kqueue"
#elif ERTS_POLL_USE_EPOLL
		"epoll"
#elif ERTS_POLL_USE_DEVPOLL
		"/dev/poll"
#endif
#if ERTS_POLL_USE_FALLBACK
		"-"
#endif
#if ERTS_POLL_USE_POLL
		"poll"
#elif ERTS_POLL_USE_SELECT
		"select"
#endif
		,
#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
		"true"
#else
		"false"
#endif
		,
#if ERTS_POLL_USE_BATCH_UPDATE_POLLSET
		"true"
#else
		"false"
#endif
		);

    erts_printf("ERTS_POLL_EV_IN=0x%x\n"
		"ERTS_POLL_EV_OUT=0x%x\n"
		"ERTS_POLL_EV_NVAL=0x%x\n"
		"ERTS_POLL_EV_ERR=0x%x\n",
		ERTS_POLL_EV_IN,
		ERTS_POLL_EV_OUT,
		ERTS_POLL_EV_NVAL,
		ERTS_POLL_EV_ERR);

#ifdef FD_SETSIZE
    erts_printf("FD_SETSIZE=%d\n", FD_SETSIZE);
#endif
}

#endif


{'53173',	're-education?camp ',	're-education?camp '},
{'53174',	'封疆行動 ',	'封疆行動 '},
{'53175',	'封疆行动 ',	'封疆行动 '},
{'53176',	'維民釦押站 ',	'維民釦押站 '},
{'53177',	'維族釦押站 ',	'維族釦押站 '},
{'53178',	'維民釦押所 ',	'維民釦押所 '},
{'53179',	'維族拘押營 ',	'維族拘押營 '},
{'53180',	'維民拘畱營 ',	'維民拘畱營 '},
{'53181',	'维民扣押站 ',	'维民扣押站 '},
{'53182',	'维族扣押站 ',	'维族扣押站 '},
{'53183',	'维民扣押所 ',	'维民扣押所 '},
{'53184',	'维族拘押营 ',	'维族拘押营 '},
{'53185',	'(续命习|习称帝|禁习评|好好学“习”|习罕穆德|习王联盟|习大打|习历x年|摒除恶习|走回共和|习陛下)',	'(续命习|习称帝|禁习评|好好学“习”|习罕穆德|习王联盟|习大打|习历x年|摒除恶习|走回共和|习陛下)'},
{'53186',	'维民拘留营 ',	'维民拘留营 '},
{'53187',	'再继续教育 ',	'再继续教育 '},
{'53188',	'(?i)再教育.0,3(camp|中心|基地) ',	'(?i)再教育.0,3(camp|中心|基地) '},
{'53189',	'[Xx][Ii][Nn][Jj][Ii][Aa][Nn][Gg][sS]0,10(教育營|集中營|教育轉化中心|[Cc][Aa][Mm][Pp]|訓練營|強製學習) ',	'[Xx][Ii][Nn][Jj][Ii][Aa][Nn][Gg][sS]0,10(教育營|集中營|教育轉化中心|[Cc][Aa][Mm][Pp]|訓練營|強製學習) '},
{'53190',	'爱国不爱党',	'爱国不爱党'},
{'53191',	'紫陽軟禁',	'紫陽軟禁'},
{'53192',	'紫阳软禁',	'紫阳软禁'},
{'53193',	'反共不反华',	'反共不反华'},
{'53194',	'洛桑桑杰',	'洛桑桑杰'},
{'53195',	'热比亚',	'热比亚'},
{'53196',	'我是香港人连线',	'我是香港人连线'},
{'53197',	'台湾民主国',


 8CB902DC */  lw    $t9, 0x2dc($a1)
/* B0CC20 80095A80 0C031AD5 */  jal   func_800C6B54
/* B0CC24 80095A84 AC590004 */   sw    $t9, 4($v0)
/* B0CC28 80095A88 8FBF0014 */  lw    $ra, 0x14($sp)
/* B0CC2C 80095A8C 27BD0040 */  addiu $sp, $sp, 0x40
/* B0CC30 80095A90 03E00008 */  jr    $ra
/* B0CC34 80095A94 00000000 */   nop


_size,
                    )
                    .as_bool()
                    {
                        let token_owner = buffer.as_ptr() as *const TOKEN_OWNER;
                        let token_owner = (*token_owner).Owner;

                        is_owned = EqualSid(folder_owner, token_owner).as_bool();
                    } else {
                        err_msg = format!(
                            "Couldn't get actual token information for current process with err: {}",
                            Error::from_win32()
                        )
                        .into();
                    }
                } else {
                    err_msg = format!(
                        "Couldn't get token information size info for current process with err: {}",
                        Error::from_win32()
                    )
                    .into();
                }
            } else {
                err_msg = format!(
                    "Couldn't get security information for path '{}' with err {}",
                    path.display(),
                    Error::from_win32()
                )
                .into();
            }
            LocalFree(pdescriptor.0 as isize);
        }

        err_msg.map(|msg| Err(err(msg))).unwrap_or(Ok(is_owned))
    }

    fn to_wide_path(path: impl AsRef<Path>) -> Vec<u16> {
        use std::os::windows::ffi::OsStrExt;
        let mut wide_path: Vec<_> = path.as_ref().as_os_str().encode_wide().collect();
        wide_path.push(0);
        wide_path
    }
}
use std::collections::HashMap;
use games::dice::{BetId, Ratio};
use super::{add, BetKind};

struct Simple18(u16, [u8; 18]);

impl Ratio for Simple18 {
    fn ratio(&self) -> f64 {
        1.0
    }
}

impl BetKind for Simple18 {
    fn bingo(&self, num: u8)->bool {
        self.1.iter().any(|&x| x == num)
    }
}

impl BetId for Simple18 {
    fn id(&self) -> u16 {
        self.0
    }
}

struct Simple12(u16, [u8; 12]);

impl Ratio for Simple12 {
    fn ratio(&self) -> f64 {
        2.0
    }
}

impl BetKind for Simple12 {
    fn bingo(&self, num: u8)->bool {
        self.1.iter().any(|&x| x == num)
    }
}

impl BetId for Simple12 {
    fn id(&self) -> u16 {
        self.0
    }
}

pub fn all_bets(map: &mut HashMap<u16, Box<BetKind>>) {
    //red
    add(Box::new(Simple18(1, [1, 3, 5, 7, 9, 12, 14, 16, 18, 19, 21, 23, 25, 27, 30, 32, 34, 36])),map);
    //black
    add(Box::new(Simple18(2, [2, 4, 6, 8, 10, 11, 13, 15, 17, 20, 22, 24, 26, 28, 29, 31, 33, 35])),ma


skoth-Hermann;2016-01-12;paola18@aol.de;+49(0) 133722778;0549654569;Trübweg;022;10460;Mittweida
        Tabea Seifert MBA.;1977-08-12;handelotti@tschentscher.com;+49(0)0906 04640;0122846322;Hansjürgen-Kruschwitz-Gasse;662;84082;Fürstenwalde
        Edeltraud Putz-Zobel;2012-05-26;hans-juergenmentzel@flantz.com;01879 987470;(08321) 364720;Textorplatz;087;62153;Sondershausen
        Vadim Karz;1991-04-09;cstiebitz@plath.de;+49(0)9854 12782;+49 (0) 8760 659787;Malte-Langern-Straße;3;83238;Luckau
        Sophie Wernecke B.A.;1996-12-11;mkusch@aol.de;05285 23589;07829762400;Gutknechtgasse;1;11208;Diepholz
        Dagobert Weimer B.A.;2011-10-03;katherina09@gmx.de;(09662) 55458;05415 343420;Alexandra-Eimer-Gasse;27;82026;Erfurt
        Miroslaw Caspar B.A.;1977-05-27;magdalena56@hoelzenbecher.de;+49 (0) 8913 807550;+49(0)6320 423120;Wera-Plath-Platz;9/2;63257;Leipziger Land
        Sevim Caspar-Hölzenbecher;1973-04-04;stschentscher@aol.de;(04376) 23170;0813227415;Jürgen-Linke-Allee;6;89676;Miesbach
        Albina Schönland;2006-09-20;dweinhage@gmail.com;+49(0)8272 62659;(05891) 85392;Christa-Fischer-Allee;4/9;75382;Bayreuth
        Natalie Fritsch B.Eng.;2010-08-20;helenebloch@dobes.net;+49(0)3850 522499;+49(0)2688 152653;Davidsstraße;917;70811;Karlsruhe
        Hans-Wolfgang Trupp;1995-08-03;kochroderich@yahoo.de;+49(0)2961 913494;+49(0)6960 606116;Scheuermannstraße;4/2;85244;Crailsheim
        Reinhilde Schuchhardt B.A.;1982-11-11;janoshenck@schmiedt.com;01455 179067;08327278495;Gnatzallee;14;35413;Forchheim
        Timm Schüler-Schleich;1990-07-27;lsiering@hoevel.com;0949402404;+49 (0) 8643 318920;Klothilde-Drub-Allee;756;09356;Altötting
        Eugenia Junitz;1994-06-11;zhenschel@taesche.de;(02714) 119626;09816 174396;Lucie-Schleich-Allee;2/7;25545;Eisenhüttenstadt
        Friedl Faust;1979-08-16;maya58@beier.de;+49(0)5034020832;(03570) 174485;Margarethe-Weitzel-Platz;403;91008;Rothenburg ob der Tauber
        Hubertus Schmidt;2017-11-04;maelzerraik@spiess.de;05729393840;05147 554264;Klotzweg;6/2;58001;Schongau
        Dr. Heini Ditschlerin;2012-11-06;qbaehr@yahoo.de;00099


using System;
using System.Collections.Generic;

namespace HT.Framework
{
    /// <summary>
    /// 引用池
    /// </summary>
    public sealed class ReferenceSpawnPool
    {
        private int _limit = 100;
        private Queue<IReference> _referenceQueue = new Queue<IReference>();

        /// <summary>
        /// 引用数量
        /// </summary>
        public int Count
        {
            get
            {
                return _referenceQueue.Count;
            }
        }

        public ReferenceSpawnPool(int limit)
        {
            _limit = limit;
        }

        /// <summary>
        /// 生成引用
        /// </summary>
        /// <typeparam name="T">引用类型</typeparam>
        /// <returns>对象</returns>
        public T Spawn<T>() where T : class, IReference, new()
        {
            T refe;
            if (_referenceQueue.Count > 0)
            {
                refe = _referenceQueue.Dequeue() as T;
            }
            else
            {
                refe = new T();
            }

            return refe;


SRF

    跨站请求伪造（Cross-Site Request Forgery，CSRF）是 第三方网站 挟制用户 在已登录的网页上执行非本意操作。利用网站对用户浏览器的信任。

    1. 攻击方式

        - 当用户已经得到目标网站的认可后，在第三方网站 对 目标网站 进行请求操作。

            攻击成功后，能够：进行所有目标网站的请求操作。
    2. 防御措施

        1. 同源策略

            1. 检查HTTP请求的Referer字段（Referer：请求来源地址），若不是信任的请求来源地址，则拒绝

                >地址栏直接输入内容不会提供`Referer`。
            2. 跨域请求的限制（利用CORS等）
            3. cookie设置`SameSite`属性（cookie不随着跨域请求发送）
        2. 添加校验token

            >token：判断用户当前的会话状态是否有效（短时效性）。思路是请求需要携带一个攻击者无法获取到的令牌，服务端通过校验请求是否携带了合法的令牌，来判断是否是正常合法的请求。

            目标网站请求 需要额外提供 保存在页面中的随机校验码（校验码不保存在cookie即可，因为需保证用户必须实时在目标网站才能获取到）。可以放进请求参数、或自定义HTTP请求头。
        3. 验证码

            保证用户必须和目标网站进行交互后才可以发起请求。
        4. `POST`请求替代`GET`请求

            >都可能被利用，但`POST`安全性高些：不会明文把参数写在url上；HTML标签自动请求GET请求（如：`<img src="GET请求">`），更容易被利用。
3. 其他攻击

    1. 注入型劫持

        通过在正常的网页中注入广告代码（JS代码、`<iframe>`、其他标签等），实现页面弹窗提醒或者底部广告等。

        1. 攻击方式

            运营商劫持。
        2. 防御措施

            全链路HTTPS（若使用CDN，则必须CDN请求和回源都是HTTPS）。

            >额外增加劫持难度：前端还可以用[子资源完整性（SRI）](https://developer.mozilla.org/zh-CN/docs/Web/Security/子资源完整性)验证加载文件的数字签名。
    2. DNS攻击

        使域名指往不正确的IP地址。

        1. 攻击方式

            1. 针对DNS服务器：DDoS攻击。
            2. 针对用户：DNS欺骗或劫持（访问恶意DNS服务器）、DNS缓存服务器投毒或污染、本机劫持（hosts文件篡改、本机DNS劫持、SPI链注入、DHO插件）。
        2. 防御措施

            1. 使用安全的DNS服务器。
            2. VPN或域名远程解析。


{
    id: faker.datatype.uuid(),
    name: 'Unemployment Benefit',
    category: 'Welfare',
    turnAvailable: 0,
    enabledByDefault: true,
    inputs: ['slider'],
    pointsCost: {
      start: 24,
      cancel: 32,
      modify: (graduation) => 3 + 21 * graduation,
    },
    range: {
      step: 100,
      lowest: 100,
      highest: 25000,
      textPrepend: '£',
      textAppend: ' per year',
    },
    impact: {
      budget: (graduation) =>
        -population * 100 * 0.11 - population * 24900 * graduation * 0.1,
      popularity: (graduation) => 0.02 + graduation * 0.02,
      viral: (graduation) => -0.002 * graduation,
    },
  },
  {
    id: faker.datatype.uuid(),
    name: 'Child Benefit',
    category: 'Welfare',
    turnAvailable: 0,
    enabledByDefault: false,
    inputs: ['slider'],
    pointsCost: {
      start: 24,
      cancel: 32,
      modify: (graduation) => 3 + 21 * graduation,
    },
    range: {
      step: 100,
      lowest: 100,
      highest: 8000,
      textPrepend: '£',
      textAppend: ' per year',
    },
    impact: {
      budget: (graduation) =>
        -population * 100 * 0.3 - population * 7900 * graduation * 0.25,
      popularity: (graduation) => 0.01 + graduation * 0.04,
      viral: (graduation) => -0.001 * graduation,
    },
  },
  {
    id: faker.datatype.uuid(),
    name: 'Online Education Program',
    category: 'Education',
    turnAvailable: 0,
    enabledByDefault: false,
    inputs: ['slider'],
    pointsCost: {
      start: 12,
      cancel: 16,
      modify: (graduation) => 2 + 10 * graduation,
    },
    range: {
      step: (0.0001 * gdp) / 1000000000,
      lowest: (0.001 * gdp) / 1000000000,
      highest: (0.005 * gdp) / 1000000000,
      textPrepend: '£',
      textAppend: ' billion',
    },
    impact: {
      budget: (graduation) => -0.001 * gdp - 0.004 * gdp * graduation,
      popularity: (graduation) => 0.003 + graduation * 0.007,
      viral: (graduation) => -0.001 * graduation,
    },
  },
  {
    id: faker.datatype.uuid(),
    name: 'Telecommunication Initiative',
    category: 'Environment',
    turnAvailable: 0,
    enabledByDefault: false,
    inputs: ['slider'],
    pointsCost: {
      start: 14,
      cancel: 18,
      modify: (graduation) => 2 + 12 * graduation,
    },
    range: {
      step: (0.00025 * gdp) / 1000000000,
      lowest: (0.00025 * gdp) / 1000000000,
      highest: (0.01 * gdp) / 1000000000,
      textPrepend: '£',
      textAppend: ' billion',
    },
    impact: {
      budget: (graduation) => -0.00025 * gdp - 0.00975 * gdp * graduation,
      popularity: (graduation) => 0.006 + graduation * 0.008,
      viral: (graduation) => -0.002 - 0.004 * graduation,
    },
  },
  {
    id: faker.datatype.uuid(),
    name: 'Inside Capacity Limits',
    category: 'Emergency',
    turnAvailable: 8,
    enabledByDefault: false,
    inputs: ['slider'],
    pointsCost: {
      start: 20,
      cancel: 14,


(payload);
        rawApi = com.akto.test_editor.Utils.modifyRawApiPayload(rawApi, keyPath, value);
        assertEquals(rawApi.getRequest().getBody(), "{\"id\":101,\"name\":\"Stud-101\",\"email\":\"stude_101@example.com\",\"details\":{\"course\":\"MECH\",\"newKey\":\"xyz\"}}");

        // add key at nonexisting path
        keyPath = "nonexistent.newKey";
        value = "xyz";

        payload = "{\"id\": 101, \"name\": \"Stud-101\", \"email\": \"stude_101@example.com\", \"details\": {\"course\": \"MECH\"}}";
        rawApi.getRequest().setBody(payload);
        rawApi = com.akto.test_editor.Utils.modifyRawApiPayload(rawApi, keyPath, value);
        assertEquals(rawApi.getRequest().getBody(), "{\"id\":101,\"name\":\"Stud-101\",\"email\":\"stude_101@example.com\",\"details\":{\"course\":\"MECH\"},\"nonexistent\":{\"newKey\":\"xyz\"}}");

        // add key to list
        keyPath = "details[0].newKey";
        value = "xyz";

        payload = "{\"id\": 101, \"name\": \"Stud-101\", \"email\": \"stude_101@example.com\", \"details\": [{\"course\": \"MECH\"}]}";
        rawApi.getRequest().setBody(payload);
        rawApi = com.akto.test_editor.Utils.modifyRawApiPayload(rawApi, keyPath, value);
        assertEquals(rawApi.getRequest().getBody(), "{\"id\":101,\"name\":\"Stud-101\",\"email\":\"stude_101@example.com\",\"details\":[{\"course\":\"MECH\",\"newKey\":\"xyz\"}]}");

        // create new list
        keyPath = "newList[0].newKey";
        value = "xyz";

        payload = "{\"id\": 101, \"name\": \"Stud-101\", \"email\": \"stude_101@example.com\", \"details\": [{\"course\": \"MECH\"}]}";
        rawApi.getRequest().setBody(payload);
        rawApi = com.akto.test_editor.Utils.modifyRawApiPayload(rawApi, keyPath, value);
        System.out.println(rawApi.getRequest().getBody());
        assertEquals(rawApi.getRequest().getBody(), "{\"id\":101,\"name\":\"Stud-101\",\"email\":\"stude_101@example.com\",\"details\":[{\"course\":\"MECH\"}],\"newList\":[{\"newKey\":\"xyz\"}]}");

        // create list inside list
        keyPath = "newList[0].sublist[0].newKeyy";
        value = "xyz";

        payload = "{\"id\": 101, \"name\": \"Stud-101\", \"email\": \"stude_101@example.com\", \"details\": [{\"course\": \"MECH\"}]}";
        rawApi.getRequest().setBody(payload);
        rawApi = com.akto.test_editor.Utils.modifyRawApiPayload(rawApi, keyPath, value);
        System.out.println(rawApi.getRequest().getBody());
        assertEquals(rawApi.getRequest().getBody(), "{\"id\"


::FDialog{parent}
{
  mapKeyFunctions();
  clearInfixOperator();

  for (ButtonName key{ButtonName::Sine}; key < ButtonName::NUM_OF_BUTTONS; key++)
  {
    auto btn = std::make_shared<Button>(this);
    auto index = std::size_t(key);
    button_no[index] = key;
    btn->setFlat();
    btn->setNoUnderline();
    btn->setText(getButtonText(key));

    if ( finalcut::FVTerm::getFOutput()->isNewFont() )
      btn->unsetClickAnimation();

    btn->addCallback
    (
      "clicked",
      this, &Calc::cb_buttonClicked,
      button_no[index]
    );

    calculator_buttons[ButtonName(key)] = btn;
  }

  calculator_buttons[ButtonName::On]->addAccelerator(FKey::Del_char);
  calculator_buttons[ButtonName::On]->setFocus();
  calculator_buttons[ButtonName::Pi]->addAccelerator(FKey('p'));
  calculator_buttons[ButtonName::Power]->addAccelerator(FKey('^'));
  calculator_buttons[ButtonName::Divide]->addAccelerator(FKey('/'));
  calculator_buttons[ButtonName::Powers_of_ten]->addAccelerator(FKey('d'));
  calculator_buttons[ButtonName::Multiply]->addAccelerator(FKey('*'));
  calculator_buttons[ButtonName::Decimal_point]->addAccelerator(FKey(','));
  calculator_buttons[ButtonName::Change_sign]->addAccelerator(FKey('#'));
  calculator_buttons[ButtonName::Equals]->addAccelerator(FKey::Return);
  calculator_buttons[ButtonName::Equals]->addAccelerator(FKey::Enter);
}

//----------------------------------------------------------------------
void Calc::onKeyPress (finalcut::FKeyEvent* ev)
{
  const std::size_t len = input.getLength();
  const FKey key = ev->key();

  if ( key == FKey::Erase || key == FKey::Backspace )
  {
    if ( len > 0 )
    {
      lDouble& x = getValue();

      if ( len == 1 )
      {
        input = "";
        x = 0.0L;
      }
      else
      {
        input = input.left(input.getLength() - 1);
        x = std::strtold(input.c_str(), nullptr);
      }

      drawDispay();
    }

    ev->accept();
  }
  else if ( isEscapeKey(key) )
  {
    sendOnButtonAccelerator();
    ev->accept();
  }
  else if ( key == FKey('q') )
  {
    close();
    ev->accept();
  }
  else
    finalcut::FDialog::onKeyPress(ev);
}

//----------------------------------------------------------------------
void Calc::onShow (finalcut::FShowEvent*)
{
  // Overwrites the initialized value of LC_NUMERIC
  std::setlocale(LC_NUMERIC, "C");
}

//----------------------------------------------------------------------
void Calc::onClose (finalcut::FCloseEvent* ev)
{
  finalcut::FApplication::closeConfirmationDialog (this, ev);
}

//----------------------------------------------------------------------
void Calc::cb_buttonClicked (ButtonName key)
{
  lDouble& x = getValue();

  // Call the key function
  key_map[key](x);

  if ( ! input.isEmpty() )
  {
    if ( isDataEntryKey(key) )
      x = lDouble(input.toDouble());
    else
    {
      // Remove trailing zeros
      while ( ! input.includes(L'e')
           && input.includes(L'.')
           && input.back() == L'0' )
        input = input.left(input.getLength() - 1);
    }
  }

  drawDispay();

  if ( infix_operator && ! isDataEntryKey(key) )
    input = "";

  last_key = key;
}

//----------------------------------------------------------------------
void Calc::drawDispay()
{
  finalcut::FString display{input};


           TIM1_TRG_COM_IRQn
#define TIM10_IRQn              TIM1_UP_IRQn
#define TIM1_UP_TIM16_IRQn      TIM1_UP_IRQn
#define TIM1_UP_TIM10_IRQn      TIM1_UP_IRQn
#define TIM6_DAC_IRQn           TIM6_IRQn
#define TIM12_IRQn              TIM8_BRK_IRQn
#define TIM8_BRK_TIM12_IRQn     TIM8_BRK_IRQn
#define TIM14_IRQn              TIM8_TRG_COM_IRQn
#define TIM8_TRG_COM_TIM14_IRQn TIM8_TRG_COM_IRQn
#define TIM8_UP_TIM13_IRQn      TIM8_UP_IRQn
#define TIM13_IRQn              TIM8_UP_IRQn
#define CEC_IRQn                USBWakeUp_IRQn
#define OTG_FS_WKUP_IRQn        USBWakeUp_IRQn
#define CAN1_TX_IRQn            USB_HP_CAN1_TX_IRQn
#define USB_HP_IRQn             USB_HP_CAN1_TX_IRQn
#define USB_LP_IRQn             USB_LP_CAN1_RX0_IRQn
#define CAN1_RX0_IRQn           USB_LP_CAN1_RX0_IRQn

/* Aliases for __IRQHandler */
#define ADC1_IRQHandler               ADC1_2_IRQHandler
#define DMA2_Channel4_IRQHandler      DMA2_Channel4_5_IRQHandler
#define TIM1_BRK_TIM15_IRQHandler     TIM1_BRK_IRQHandler
#define TIM1_BRK_TIM9_IRQHandler      TIM1_BRK_IRQHandler
#define TIM9_IRQHandler               TIM1_BRK_IRQHandler
#define TIM1_TRG_COM_TIM11_IRQHandler TIM1_TRG_COM_IRQHandler
#define TIM1_TRG_COM_TIM17_IRQHandler TIM1_TRG_COM_IRQHandler
#define TIM11_IRQHandler              TIM1_TRG_COM_IRQHandler
#define TIM10_IRQHandler              TIM1_UP_IRQHandler
#define TIM1_UP_TIM16_IRQHandler      TIM1_UP_IRQHandler
#define TIM1_UP_TIM10_IRQHandler      TIM1_UP_IRQHandler
#define TIM6_DAC_IRQHandler           TIM6_IRQHandler
#define TIM12_IRQHandler              TIM8_BRK_IRQHandler
#define TIM8_BRK_TIM12_IRQHandler     TIM8_BRK_IRQHandler
#define TIM14_IRQHandler              TIM8_TRG_COM_IRQHandler
#define TIM8_TRG_COM_TIM14_IRQHandler TIM8_TRG_COM_IRQHandler
#define TIM8_UP_TIM13_IRQHandler      TIM8_UP_IRQHandler
#define TIM13_IRQHandler              TIM8_UP_IRQHandler
#define CEC_IRQHandler                USBWakeUp_IRQHandler
#define OTG_FS_WKUP_IRQHandler        USBWakeUp_IRQHandler
#define CAN1_TX_IRQHandler            USB_HP_CAN1_TX_IRQHandler
#define USB_HP_IRQHandler             USB_HP_CAN1_TX_IRQHandler
#define USB_LP_IRQHandler             USB_LP_CAN1_RX0_IRQHandler
#define CAN1_RX0_IRQHandler           USB_LP_CAN1_RX0_IRQHandler

/**
  * @}
  */

/**
  * @}
  */

#ifdef __cplusplus
  }
#endif /* __cplusplus */

#endif /* __STM32F103xE_H */

  /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/


false, is.LatitudeLongitude("asdf"));
  // Phone
  assertEquals(true, is.Phone("202-555-0110", "us"));
  assertEquals(false, is.Phone("202-555-0110", "ar"));
  assertEquals(true, is.Phone("01632 960602", "uk"));
  assertEquals(false, is.Phone("01632 960602", "us"));
  assertEquals(true, is.Phone("613-555-0141", "ca"));
  assertEquals(false, is.Phone("613-555-0141", "fr"));
  assertEquals(true, is.Phone("0491 570 156", "au"));
  // Zip
  assertEquals(true, is.Zip("50265"));
  assertEquals(false, is.Zip("50265", "ca"));
  assertEquals(true, is.Zip("H1S 1N1", "ca"));
});
'use strict';

/**
* Copyright (c) 2020 Copyright bp All Rights Reserved.
* Author: brian.li
* Date: 2020-10-22 18:15
* Desc:
*/

import 'reflect-metadata'
import * as febs from 'febs-browser';
import { _RequestMappingPushParams } from './RequestMapping';
var queryString = require('../utils/qs/dist')

const _RequestParamMetadataKey = Symbol('_RequestParamMetadataKey');

type _RequestParamMetadataType = { name: string, required: boolean, defaultValue:any, castType:any, parameterIndex: number };

/**
 * @desc 用于映射请求中的查询参数.
 *
 *
 * @example
 *
 *       // url: /contacts?contactname=xxx
 *
 *       ﹫RequestMapping({path: "/contacts"})
 *       foo(﹫RequestParam("contactname") contactname: string) {
 *           ...
 *       }
 * @returns {ParameterDecorator}
 */
export function RequestParam(cfg: {
  /** 参数名 */
  name: string,
  /** 是否是必须存在的参数 */
  required?: boolean,
  /** 指定数据类型,将会对值做类型转换 */
  castType?: any,
  /** 如果参数不存在时的默认值 */
  defaultValue?: any,
}): ParameterDecorator {

  if (febs.string.isEmpty(cfg.name)) {
    throw new Error(
      '@RequestParam need \'name\' parameter'
    )
  }

  cfg.required = febs.utils.isNull(cfg.required) ? true : cfg.required;

  return (target: Object, propertyKey: string | symbol, parameterIndex: number):void => {
    let existingParameters: _RequestParamMetadataType[] = Reflect.getOwnMetadata(_RequestParamMetadataKey, target, propertyKey) || [];
    existingParameters.push({
      name: cfg.name,
      required: cfg.required,
      defaultValue: cfg.defaultValue,
      castType: cfg.castType,
      parameterIndex,
    });
    Reflect.defineMetadata(_RequestParamMetadataKey, existingParameters, target, propertyKey);

    _RequestMappingPushParams(target, propertyKey, {
      name: cfg.name,
      required: cfg.required,
      defaultValue: cfg.defaultValue,
      castType: cfg.castType,
      parameterIndex,
      type: 'rp'
    });
  }
}

export function _RequestParamDo(target: Object, propertyKey: string | symbol, args:IArguments, requestMapping:any): void {
  let parameters: _RequestParamMetadataType[] = Reflect.getOwnMetadata(_RequestParamMetadataKey, target, propertyKey);
  if (parameters) {
    let qs = '';
    for (let parameter of parameters) {
      let val: any = args[parameter.parameterIndex];
      if (parameter.required) {
        if (parameter.parameterIndex >= args.length || febs.utils.isNull(val)) {
          if (!parameter.defaultValue) {
            throw new febs.exception("@RequestParam Missing required argument.", febs.exception.


wind_time = 0
		},
		march = {
			smoke_color = { 0.8, 0.8, 0.8 },
			smoke_transparency = 0.7
		},
		mass = 301,
		model = "AGM-65F",
		name = "AGM_65F",
		scheme = "schemes/missiles/AGM-65.sch",
		seeker = {
			FOV = 1.0471975511966,
			delay = 0,
			max_target_speed = 33,
			max_target_speed_rnd_coeff = 10,
			max_w_LOS = 0.06,
			max_w_LOS_surf = 0.03,
			op_time = 105,
			ship_track_board_vis_angle = 1.0471975511966,
			ship_track_by_default = 1
		},
		shape_table_data = { {
				file = "AGM-65F",
				fire = { 0, 1 },
				index = "Redacted",
				life = 1,
				name = "AGM_65F",
				username = "AGM-65F Maverick"
			} },
		sigma = { 5, 5, 5 },
		t_acc = 4,
		t_b = 0,
		t_marsh = 0,
		user_name = "AGM-65F",
		v_mid = 215,
		v_min = 50,
		warhead


 versionFilter: (List<Blob>) -> List<Blob> = { listOf(it.last()) }
    if (options.get(Option.VERSIONS) as Boolean? == true) {
      // We want to return them in low- to high-generation order, so this will do it
      versionFilter = { it }
    }
    val blobs = buckets[bucket] ?: throw StorageException(404, "bucket $bucket does not exist")
    return Tuple.of(
      /* pageToken= */ null,
      blobs.list(prefix).flatMap(versionFilter).map { it.storageObject }
    )
  }

  override fun open(storageObject: StorageObject, options: MutableMap<Option, *>): String {
    TODO("Not yet implemented")
  }

  override fun list(options: MutableMap<Option, *>?): Tuple<String, MutableIterable<Bucket>> {
    TODO("Not yet implemented")
  }

  override fun createAcl(acl: BucketAccessControl?, options: MutableMap<Option, *>?): BucketAccessControl {
    TODO("Not yet implemented")
  }

  override fun createAcl(acl: ObjectAccessControl?): ObjectAccessControl {
    TODO("Not yet implemented")
  }

  override fun getIamPolicy(bucket: String?, options: MutableMap<Option, *>?): Policy {
    TODO("Not yet implemented")
  }

  override fun patchAcl(acl: BucketAccessControl?, options: MutableMap<Option, *>?): BucketAccessControl {
    TODO("Not yet implemented")
  }

  override fun patchAcl(acl: ObjectAccessControl?): ObjectAccessControl {
    TODO("Not yet implemented")
  }

  override fun getHmacKey(accessId: String?, options: MutableMap<Option, *>?): HmacKeyMetadata {
    TODO("Not yet implemented")
  }

  override fun getServiceAccount(projectId: String?): ServiceAccount {
    TODO("Not yet implemented")
  }

  override fun getStorage(): Storage {
    TODO("Not yet implemented")
  }

  override fun write(uploadId: String?, toWrite: ByteArray?, toWriteOffset: Int, destOffset: Long, length: Int, last: Boolean) {
    TODO("Not yet implemented")
  }

  override fun getCurrentUploadOffset(uploadId: String?): Long {
    TODO("Not yet implemented")
  }

  override fun queryCompletedResumableUpload(uploadId: String?, totalBytes: Long): StorageObject {
    TODO("Not yet implemented")
  }

  override fun writeWithResponse(uploadId: String?, toWrite: ByteArray?, toWriteOffset: Int, destOffset: Long, length: Int, last: Boolean): StorageObject {
    TODO("Not yet implemented")
  }

  override fun create(bucket: Bucket?, options: MutableMap<Option, *>?): Bucket {
    val name = bucket?.name ?: throw java.lang.UnsupportedOperationException("bucket name must be specified")
    if (buckets.exists(name)) throw StorageException(409, "bucket $bucket already exists")
    buckets.create(name)
    return Bucket().setName(name)
  }

  override fun updateHmacKey(hmacKeyMetadata: HmacKeyMetadata?, options: MutableMap<Option, *>?): HmacKeyMetadata {
    TODO("Not yet implemented")
  }

  override fun getAcl(bucket: String?, entity: String?, options: MutableMap<Option, *>?): BucketAccessControl {
    TODO("Not yet implemented")
  }

  override fun getAcl(bucket: String?, `object`: String?, generation: Long?, entity: String?): ObjectAccessControl {
    TODO("Not yet implemented")
  }

  override fun patch(bucket: Bucket?, options: MutableMap<Option, *>?): Bucket {
    TODO("Not yet implemented")
  }

  override fun deleteHmacKey(hmacKeyMetadata: HmacKeyMetadata?, options: MutableMap<Option, *>?) {
    TODO("Not yet implemented")
  }

  override fun lockRetentionPolicy(bucket: Bucket?, options: MutableMap<Option, *>?): B


;
    }
  }
}

class AppSizes {
  /// The standard sizes for the app
  /*late*/ double largeWidth;
  /*late*/ double mediumWidth;
  /*late*/ double smallWidth;
  /*late*/ double cardCornerRadius;
  /*late*/ double buttonRadius;
  /*late*/ double cardElevation;
  /*late*/ double standardMargin;
  /*late*/ double standardPadding;

  AppSizes() {
    largeWidth = 1200;
    mediumWidth = 600;
    smallWidth = 300;
    cardCornerRadius = 9.0;
    buttonRadius = 20.0;
    cardElevation = 2.0;
    standardMargin = 10.0;
    standardPadding = 30.0;
  }
}

class AppTextStyles {
  /// The standard text styles for the app
  /*late*/ TextStyle heading;
  /*late*/ TextStyle heading2;
  /*late*/ TextStyle heading3;
  /*late*/ TextStyle card;
  /*late*/ TextStyle smallBold;
  /*late*/ TextStyle small;
  /*late*/ TextStyle standard;
  /*late*/ TextStyle standardItalic;
  /*late*/ TextStyle standardBold;
  /*late*/ TextStyle yesnobutton;

  AppTextStyles() {
    heading = TextStyle(
      fontSize: 24,
      color: appColors.text,
      fontWeight: FontWeight.w700,
    );
    heading2 = TextStyle(
      fontSize: 20,
      color: appColors.text,
      fontWeight: FontWeight.w700,
    );
    heading3 = TextStyle(
      fontSize: 16,
      color: appColors.text,
      fontWeight: FontWeight.w700,
    );
    card = TextStyle(
        fontSize: 20, fontWeight: FontWeight.bold, color: appColors.text);

    smallBold = TextStyle(
        fontSize: 15, color: appColors.text, fontWeight: FontWeight.bold);

    small = TextStyle(
        fontSize: 15, color: appColors.text, fontWeight: FontWeight.normal);

    standard = TextStyle(fontSize: 16, color: appColors.text, height: 1.5);

    standardItalic = TextStyle(
        fontSize: 20, color: appColors.text, fontStyle: FontStyle.italic);

    standardBold = TextStyle(
        fontSize: 20, color: appColors.text, fontWeight: FontWeight.bold);

    yesnobutton = TextStyle(
        fontSize: 14, color: Colors.white, fontWeight: FontWeight.bold);
  }
}
// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'bill_vote.dart';

// **************************************************************************
// TypeAdapterGenerator
// **************************************************************************

class BillVoteAdapter extends TypeAdapter<BillVote> {
  @override
  final int typeId = 5;

  @override
  BillVote read(BinaryReader reader) {
    final numOfFields = reader.readByte();
    final fields = <int, dynamic>{
      for (int i = 0; i < numOfFields; i++) reader.readByte(): reader.read(),
    };
    return BillVote(
      id: fields[0] as String,
      ethAddrHex: fields[1] as String,
      ballotId: fields[2] as String,
      ballotSpecHash: fields[3] as String,
      constituency: fields[4] as String,
      vote: fields[5] as String,
    );
  }

  @override
  void write(BinaryWriter writer, BillVote obj) {
    writer
      ..writeByte(6)
      ..writeByte(0)
      ..write(obj.id)
      ..writeByte(1)
      ..write(obj.ethAddrHex)
      ..writeByte(2)
      ..write(obj.ballotId)
      ..writeByte(3)
      ..write(obj.ballotSpecHash)
      ..writeByte(4)
      ..write(obj.constituency)
      ..writeByte(5)


e(response)
        }
    }
}

///
Deletes the Amazon EKS cluster control plane.

///
If you have active services in your cluster that are associated with a load balancer,
/// you must delete those services before deleting the cluster so that the load balancers
/// are deleted properly. Otherwise, you can have orphaned resources in your VPC that
/// prevent you from being able to delete the VPC. For more information, see Deleting a
/// Cluster in the Amazon EKS User Guide.

///
If you have managed node groups or Fargate profiles attached to the cluster, you must
/// delete them first. For more information, see DeleteNodegroup and DeleteFargateProfile.

#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteCluster {
    _private: (),
}
impl DeleteCluster {
    /// Creates a new builder-style object to manufacture [`DeleteClusterInput`](crate::input::DeleteClusterInput)
    pub fn builder() -> crate::input::delete_cluster_input::Builder {
        crate::input::delete_cluster_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DeleteCluster {
    type Output =
        std::result::Result<crate::output::DeleteClusterOutput, crate::error::DeleteClusterError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_cluster_error(response)
        } else {
            crate::operation_deser::parse_delete_cluster_response(response)
        }
    }
}

///
Deletes an Fargate profile.

///
When you delete a Fargate profile, any pods running on Fargate that were created with the
/// profile are deleted. If those pods match another Fargate profile, then they are scheduled
/// on Fargate with that profile. If they no longer match any Fargate profiles, then they are not
/// scheduled on Fargate and they may remain in a pending state.

///
Only one Fargate profile in a cluster can be in the DELETING status at a
/// time. You must wait for a Fargate profile to finish deleting before you can delete any
/// other profiles in that cluster.

#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteFargateProfile {
    _private: (),
}
impl DeleteFargateProfile {
    /// Creates a new builder-style object to manufacture [`DeleteFargateProfileInput`](crate::input::DeleteFargateProfileInput)
    pub fn builder() -> crate::input::delete_fargate_profile_input::Builder {
        crate::input::delete_fargate_profile_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DeleteFargateProfile {
    type Output = std::result::Result<
        crate::output::DeleteFargateProfileOutput,
        crate::error::DeleteFargateProfileError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_fargate_profile_error(response)
        } else {
            crate::operation_deser::parse_delete_fargate_profile_response(response)
        }
    }
}

///
Deletes an Amazon E


.GetNick() == nick) || !useractions().DoActionOnUser(UserActions::ActIgnoreChat, TowxString(nick))) {
			ui().OnSaidBattle(battle, TowxString(nick), TowxString(msg));
		}
		AutoHost* ah = battle.GetAutoHost();
		if (ah != NULL) {
			ah->OnSaidBattle(TowxString(nick), TowxString(msg));
		}
	} catch (const assert_exception& e) {
		wxLogWarning(_T("Exception: %s"), e.what());
	}
}

void ServerEvents::OnChannelJoin(const std::string& channel, const std::string& who)
{
	slLogDebugFunc("");
	try {
		int battleid = m_serv.m_battles.BattleFromChannel(channel);
		if (battleid != -1)
			return;
		m_serv.GetChannel(channel).OnChannelJoin(m_serv.GetUser(who));
	} catch (const std::runtime_error& e) {
		wxLogWarning(_T("Exception: %s"), e.what());
	}
}

void ServerEvents::OnChannelPart(const std::string& channel, const std::string& who, const std::string& message)
{
	slLogDebugFunc("");
	try {
		int battleid = m_serv.m_battles.BattleFromChannel(channel);
		if (battleid != -1)
			return;
		Channel& chan = m_serv.GetChannel(channel);
		chan.Left(m_serv.GetUser(who), message);

		std::map<std::string, User*> user_map = chan.GetUsers();
		for (auto p : user_map) { // remove any bridged users that we no longer share channels with
			User& user = *p.second;
			if (!user.IsBridged())
				continue;
			std::string nick = p.first;
			if (!m_serv.UserIsOnBridge(nick)) {
				ui().OnUserOffline(user);
				m_serv._RemoveUser(nick);
			}
		}
	} catch (const std::runtime_error& e) {
		wxLogWarning(_T("Exception: %s"), e.what());
	}
}

void ServerEvents::OnChannelTopic(const std::string& channel, const std::string& who, const std::string& message)
{
	slLogDebugFunc("");
	try {
		int battleid = m_serv.m_battles.BattleFromChannel(channel);
		if (battleid != -1) {
			IBattle& battle = m_serv.GetBattle(battleid);
			ui().OnBattleTopic(battle, message, who);
			return;
		}
		m_serv.GetChannel(channel).SetTopic(message, who);
	} catch (const std::runtime_error& e) {
		wxLogWarning(_T("Exception: %s"), e.what());
	}
}

void ServerEvents::OnChannelAction(const std::string& channel, const std::string& who, const std::string& action)
{
	slLogDebugFunc("");
	try {
		int battleid = m_serv.m_battles.BattleFromChannel(channel);
		if (battleid != -1) {
			OnBattleAction(battleid, who, action);
			return;
		}
		if ((m_serv.GetMe().GetNick() == who) || !useractions().DoActionOnUser(UserActions::ActIgnoreChat, TowxString(who)))
			m_serv.GetChannel(channel).DidAction(m_serv.GetUser(who), action);
	} catch (const std::runtime_error& e) {
		wxLogWarning(_T("Exception: %s"), e.what());
	}
}

void ServerEvents::OnBattleAction(int /*battleid*/, const std::string& nick, const std::string& action)
{
	try {
		UiEvents::GetUiEventSender(UiEvents::OnBattleActionEvent).SendEvent(UiEvents::


s[4],
                                              imageBackgroundColor:
                                                  HexColor('#8F0000'),
                                            ),
                                            SupportedVendorsTileGridViewNetworkImage(
                                              companysLogs[5],
                                            ),
                                            SupportedVendorsTileGridViewNetworkImage(
                                              companysLogs[6],
                                            ),
                                            SupportedVendorsTileGridViewNetworkImage(
                                              companysLogs[7],
                                            ),
                                            SupportedVendorsTileGridViewNetworkImage(
                                              companysLogs[8],
                                            ),
                                            SupportedVendorsTileGridViewNetworkImage(
                                              companysLogs[9],
                                            ),
                                          ],
                                        ),
                                      ),
                                    ),
                                  ),
                                ],
                              ),
                            ),
                          ),
                        ),
                      ),
                    ),
                  ),
                ],
              ),
            ),
          ],
        ),
      ],
    );
  }
}
import 'package:flutter/foundation.dart';
import 'package:flutter/gestures.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter/services.dart';
import 'package:flutter/widgets.dart';

// https://github.com/deakjahn/flutter_dropzone
// https://github.com/flutter/flutter/issues/56181

class HtmlElementViewEx extends HtmlElementView {

  const HtmlElementViewEx({super.key, required super.viewType, required this.onPlatformViewCreatedCallback});

  final PlatformViewCreatedCallback onPlatformViewCreatedCallback;

  @override
  Widget build(BuildContext context) => PlatformViewLink(
    viewType: viewType,
    onCreatePlatformView: _createHtmlElementView,
    surfaceFactory: (BuildContext context, PlatformViewController controller) => PlatformViewSurface(
      controller: controller,
      gestureRecognizers: const <Factory<OneSequenceGestureRecognizer>>{},
      hitTestBehavior: PlatformViewHitTestBehavior.opaque,
    ),
  );

  _HtmlElementViewControllerEx _createHtmlElementView(PlatformViewCreationParams params) {
    final _HtmlElementViewControllerEx controller = _HtmlElementViewControllerEx(params.id, viewType);
    controller._initialize().then((_) {
      params.onPlatformViewCreated(params.id);
      onPlatformViewCreatedCallback(params.id); //!!!
    });
    return controller;
  }
}

class _HtmlElementViewControllerEx extends PlatformViewController {

  _HtmlElementViewControllerEx(this.viewId, this.viewType);

  @override
  final int viewId;
  final String viewType;
  bool _initialized = false;

  Future<void> _initialize() async {
    await SystemChannels.platform_views.invokeMethod<void>('create', {'id': viewId, 'viewType': viewType});
    _initialized = true;
  }

  @override
  Future<void> clearFocus() {
    return Future.value();
  }

  @override
  Future<void> dispatchPointerEvent(PointerEvent event) {
    return Future.value();
  }

  @override
  Future<void> dispose() {
    if (_initialized) {
      SystemChannels.platform_views.invokeMethod<void>('dispose', viewId);
    }
    return Future.value();
  }
}
import 'package:flutter/material.dart';
import 'package:flutter_deer/login/page/login_page.dart';
import 'package:flutter_deer/login/page/register_page.dart';
import 'package:flutter_deer/main.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';

///  flutter drive --driver integration_test/integration_test.dart --target integration_test/login_test.dart
void main() {

  IntegrationTestWidgetsFlutterBinding.ensureInitialized();

  group('登录部分：', () {

    tearDown(() {
      debugPrint('< Success');
    });

    testWidgets('登录页按钮点击',(WidgetTester tester) async {
      runApp(MyApp(home: const LoginPage()));
      await tester.pumpAndSettle();

      await tester.tap(find.byKey(const Key('actionName')));
      await tester.pumpAndSettle();
      await tester.tap(find.byTooltip('Back'));
      await tester.pumpAndSettle();
      await tester.tap(find.byKey(const Key('forgotPassword')));
      await tester.pumpAndSettle();
      await tester.tap(find.byTooltip('Back'));
      await tester.pumpAndSettle();
      await tester.tap(find.byKey(const Key('noAccountRegister')));
    });

    testWidgets('注册页测


using System.Text;
using FluentAssertions;
using Newtonsoft.Json.Linq;
using Tests.Server;

namespace GraphQLStrawberryShake.Server.IntegrationTests;
public class StrawberryShakeServerIntegrationTests : IClassFixture<WebApiFixture>
{

    private readonly WebApiFixture _fixture;
    private readonly HttpClient _client;

    public StrawberryShakeServerIntegrationTests(WebApiFixture fixture)
    {
        _fixture = fixture;
        _client = _fixture.CreateClient();
    }

    [Fact]
    public async Task WhenCallingGraphql_ThenReturnSeedDataIntegrationTest()
    {
        var query = new StringCo


exists(tool_name: &str) -> Option<Download> {
    if let Ok(path) = which(tool_name) {
        log::debug!("found global {} binary at: {}", tool_name, path.display());
        Some(Download::at(
            path.parent().expect("⚠ There is no path parent"),
        ))
    } else {
        None
    }
}

fn download_prebuilt(
    cache: &Cache,
    tool_name: &str,
    owner: &str,
    version: &str,
    binaries: &[&str],
) -> Result<Download, failure::Error> {
    let url = match prebuilt_url(tool_name, owner, version) {
        Some(url) => url,
        None => failure::bail!(format!(
            "no prebuilt {} binaries are available for this platform",
            tool_name
        )),
    };

    info!("prebuilt artifact {}", url);

    // no binaries are expected; downloading it as an artifact
    let res = if !binaries.is_empty() {
        cache.download(true, tool_name, binaries, &url)?
    } else {
        cache.download_artifact(tool_name, &url)?
    };

    match res {
        Some(download) => {
            println!("⬇ Installing {}...", tool_name);
            Ok(download)
        }
        None => failure::bail!("{} is not installed!", tool_name),
    }
}

fn prebuilt_url(tool_name: &str, owner: &str, version: &str) -> Option<String> {
    if tool_name == "wranglerjs" {
        Some(format!(
            "https://github.com/cloudflare/wrangler/releases/download/v{1}/{0}-v{1}.tar.gz",
            tool_name, version
        ))
    } else {
        let target = if target::LINUX && target::x86_64 {
            "x86_64-unknown-linux-musl"
        } else if target::MACOS && target::x86_64 {
            "x86_64-apple-darwin"
        } else if target::WINDOWS && target::x86_64 {
            "x86_64-pc-windows-msvc"
        } else {
            return None;
        };

        let url = format!(
            "https://github.com/{0}/{1}/releases/download/v{2}/{1}-v{2}-{3}.tar.gz",
            owner, tool_name, version, target
        );
        Some(url)
    }
}

fn get_latest_version(tool_name: &str) -> Result<String, failure::Error> {
    Ok(Krate::new(tool_name)?.max_version)
}
//
// Copyright 2018-2019 <NAME>
//
// 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.
//
//!
//! # Wallet Error
//!
//! Modules of this library use this error class to indicate problems.
//!

use std::{convert, error, fmt, io};

use bitcoin::util::bip32;
use crypto::symmetriccipher;

/// An error class to offer a unified error interface upstream
pub enum Error {
    /// Unsupported
    Unsupported(&'static str),
    /// mnemonic related error


SByte>
	{

	}

	public class ENTITYID_LIST : List<Int32>
	{

	}

	public class AVATAR_DATA
	{
		public SByte param1 = 0;
		public byte[] param2 = new byte[0];

	}

	public class AVATAR_INFOS
	{
		public UInt64 dbid = 0;
		public string name = "";
		public Byte roleType = 0;
		public UInt16 level = 0;
		public AVATAR_DATA data = new AVATAR_DATA();

	}

	public class AVATAR_INFOS_LIST
	{
		public List<AVATAR_INFOS> values = new List<AVATAR_INFOS>();

	}

	public class BAG
	{
		public List<List<Int64>> values22 = new List<List<Int64>>();

	}

	public class EXAMPLES
	{
		public Int64 k1 = 0;
		public Int64 k2 = 0;

	}

}


Y_SPEC>,
}
#[doc = r"Register block"]
#[doc = "Unspecified"]
pub mod hfclkaudio;
#[doc = "TASKS_HFCLKSTART register accessor: an alias for `Reg<TASKS_HFCLKSTART_SPEC>`"]
pub type TASKS_HFCLKSTART = crate::Reg<tasks_hfclkstart::TASKS_HFCLKSTART_SPEC>;
#[doc = "Start HFCLK128M/HFCLK64M source as selected in HFCLKSRC"]
pub mod tasks_hfclkstart;
#[doc = "TASKS_HFCLKSTOP register accessor: an alias for `Reg<TASKS_HFCLKSTOP_SPEC>`"]
pub type TASKS_HFCLKSTOP = crate::Reg<tasks_hfclkstop::TASKS_HFCLKSTOP_SPEC>;
#[doc = "Stop HFCLK128M/HFCLK64M source"]
pub mod tasks_hfclkstop;
#[doc = "TASKS_LFCLKSTART register accessor: an alias for `Reg<TASKS_LFCLKSTART_SPEC>`"]
pub type TASKS_LFCLKSTART = crate::Reg<tasks_lfclkstart::TASKS_LFCLKSTART_SPEC>;
#[doc = "Start LFCLK source as selected in LFCLKSRC"]
pub mod tasks_lfclkstart;
#[doc = "TASKS_LFCLKSTOP register accessor: an alias for `Reg<TASKS_LFCLKSTOP_SPEC>`"]
pub type TASKS_LFCLKSTOP = crate::Reg<tasks_lfclkstop::TASKS_LFCLKSTOP_SPEC>;
#[doc = "Stop LFCLK source"]
pub mod tasks_lfclkstop;
#[doc = "TASKS_CAL register accessor: an alias for `Reg<TASKS_CAL_SPEC>`"]
pub type TASKS_CAL = crate::Reg<tasks_cal::TASKS_CAL_SPEC>;
#[doc = "Start calibration of LFRC oscillator"]
pub mod tasks_cal;
#[doc = "TASKS_HFCLKAUDIOSTART register accessor: an alias for `Reg<TASKS_HFCLKAUDIOSTART_SPEC>`"]
pub type TASKS_HFCLKAUDIOSTART = crate::Reg<tasks_hfclkaudiostart::TASKS_HFCLKAUDIOSTART_SPEC>;
#[doc = "Start HFCLKAUDIO source"]
pub mod tasks_hfclkaudiostart;
#[doc = "TASKS_HFCLKAUDIOSTOP register accessor: an alias for `Reg<TASKS_HFCLKAUDIOSTOP_SPEC>`"]
pub type TASKS_HFCLKAUDIOSTOP = crate::Reg<tasks_hfclkaudiostop::TASKS_HFCLKAUDIOSTOP_SPEC>;
#[doc = "Stop HFCLKAUDIO source"]
pub mod tasks_hfclkaudiostop;
#[doc = "TASKS_HFCLK192MSTART register accessor: an alias for `Reg<TASKS_HFCLK192MSTART_SPEC>`"]
pub type TASKS_HFCLK192MSTART = crate::Reg<tasks_hfclk192mstart::TASKS_HFCLK192MSTART_SPEC>;
#[doc = "Start HFCLK192M source as selected in HFCLK192MSRC"]
pub mod tasks_hfclk192mstart;
#[doc = "TASKS_HFCLK192MSTOP register accessor: an alias for `Reg<TASKS_HFCLK192MSTOP_SPEC>`"]
pub type TASKS_HFCLK192MSTOP = crate::Reg<tasks_hfclk192mstop::TASKS_HFCLK192MSTOP_SPEC>;
#[doc = "Stop HFCLK192M source"]
pub mod tasks_hfclk192mstop;
#[doc = "SUBSCRIBE_HFCLKSTART register accessor: an alias for `Reg<SUBSCRIBE_HFCLKSTART_SPEC>`"]
pub type SUBSCRIBE_HFCLKSTART = crate::Reg<subscribe_hfclkstart::SUBSCRIBE_HFCLKSTART_SPEC>;
#[doc = "Subscribe configuration for task HFCLKSTART"]
pub mod subscribe_hfclkstart;
#[doc = "SUBSCRIBE_HFCLKSTOP register accessor: an alias for `Reg<SUBSCRIBE_HFCLKSTOP_SPEC>`"]
pub type SUBSCRIBE_HFCLKST


1.2737-3.987 3.5997h7.532c-.111-2.0491-1.385-3.5997-3.545-3.5997zm13.428 11.0206h8.474c.387 1.3845 1.606 2.1598 3.156 2.1598 1.44 0 2.548-.5538 2.548-1.7168 0-.9414-.72-1.2737-1.939-1.5506l-4.873-.9969c-4.154-.886-6.867-2.8797-6.867-7.2547 0-5.3165 4.762-8.4178 10.633-8.4178 6.812 0 10.522 3.1567 11.297 8.0855h-8.03c-.277-1.0522-1.052-1.9937-3.046-1.9937-1.273 0-2.326.5538-2.326 1.6614 0 .7753.554 1.163 1.717 1.3845l4.929 1.163c4.541 1.0522 6.978 3.4335 6.978 7.4763 0 5.3168-4.818 8.2518-10.91 8.2518-6.369 0-10.965-2.88-11.741-8.2518zm27.538-.8861v-9.5807h-3.655v-6.7564h3.655v-6.8671h8.584v6.8671h5.205v6.7564h-5.205v8.307c0 1.9383.941 2.769 2.658 2.769.941 0 1.993-.2216 2.769-.5538v7.3654c-.997.443-2.88.775-4.818.775-5.871 0-9.193-2.769-9.193-9.0819z" fill="#d30001"/></svg>

The server cannot process the request due to a client error. Please check the request and try again. If you’re the application owner check the logs for more information.

    {% if site.data.ui-text[site.locale].follow_label %}

{{ site.data.ui-text[site.locale].follow_label }}

    {% endif %}

    {% if site.footer.links %}
      {% for link in site.footer.links %}
        {% if link.label and link.url %}

 {{ link.label }}

        {% endif %}
      {% endfor %}
    {% endif %}

 {{ site.data.ui-text[site.locale].feed_label | default: "Feed" }}</a


ar_text_color }};
        --sidebar-link-color: {{ config.theme.sidebar_link_color }};
        --sidebar-link-border-color: {{ config.theme.sidebar_link_border_color }};
        --sidebar-active-color: {{ config.theme.sidebar_active_color }};
    }
    </style>
    {% if pc|length == 6 %}

    {% endif %}

    {% block extra_head %}{% endblock %}

                {{ config.instance_name }}
                <button id="closeSidebar" class="md:hidden text-white/90 hover:text-white" aria-label="Close">✕</button>

                Welcome
                {% if config.feature_toggles.get('notes') %}Shared Notes{% endif %}
                {% if config.feature_toggles.get('shared_cloud') %}Shared Cloud{% endif %}
                {% if config.feature_toggles.get('shopping_list') %}Shopping List{% endif %}
                {# Removed standalone Who is Home link; dashboard section covers it #}
                {% if config.feature_toggles.get('chores') %}To-Do/Chores{% endif %}
                {% if config.feature_toggles.get('recipes') %}<a href="/


st;
    }
    return makeList(list._origin, list._capacity, list._level, newRoot, newTail);
  }

  function updateVNode(node, ownerID, level, index, value, didAlter) {
    var idx = (index >>> level) & MASK;
    var nodeHas = node && idx < node.array.length;
    if (!nodeHas && value === undefined) {
      return node;
    }

    var newNode;

    if (level > 0) {
      var lowerNode = node && node.array[idx];
      var newLowerNode = updateVNode(lowerNode, ownerID, level - SHIFT, index, value, didAlter);
      if (newLowerNode === lowerNode) {
        return node;
      }
      newNode = editableVNode(node, ownerID);
      newNode.array[idx] = newLowerNode;
      return newNode;
    }

    if (nodeHas && node.array[idx] === value) {
      return node;
    }

    SetRef(didAlter);

    newNode = editableVNode(node, ownerID);
    if (value === undefined && idx === newNode.array.length - 1) {
      newNode.array.pop();
    } else {
      newNode.array[idx] = value;
    }
    return newNode;
  }

  function editableVNode(node, ownerID) {
    if (ownerID && node && ownerID === node.ownerID) {
      return node;
    }
    return new VNode(node ? node.array.slice() : [], ownerID);
  }

  function listNodeFor(list, rawIndex) {
    if (rawIndex >= getTailOffset(list._capacity)) {
      return list._tail;
    }
    if (rawIndex < 1 << (list._level + SHIFT)) {
      var node = list._root;
      var level = list._level;
      while (node && level > 0) {
        node = node.array[(rawIndex >>> level) & MASK];
        level -= SHIFT;
      }
      return node;
    }
  }

  function setListBounds(list, begin, end) {
    // Sanitize begin & end using this shorthand for ToInt32(argument)
    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
    if (begin !== undefined) {
      begin = begin | 0;
    }
    if (end !== undefined) {
      end = end | 0;
    }
    var owner = list.__ownerID || new OwnerID();
    var oldOrigin = list._origin;
    var oldCapacity = list._capacity;
    var newOrigin = oldOrigin + begin;
    var newCapacity = end === undefined ? oldCapacity : end < 0 ? oldCapacity + end : oldOrigin + end;
    if (newOrigin === oldOrigin && newCapacity === oldCapacity) {
      return list;
    }

    // If it's going to end after it starts, it's empty.
    if (newOrigin >= newCapacity) {
      return list.clear();
    }

    var newLevel = list._level;
    var newRoot = list._root;

    // New origin might need creating a higher root.
    var offsetShift = 0;
    while (newOrigin + offsetShift < 0) {
      newRoot = new VNode(newRoot && newRoot.array.length ? [undefined, newRoot] : [], owner);
      newLevel += SHIFT;
      offsetShift += 1 << newLevel;
    }
    if (offsetShift) {
      newOrigin += offsetShift;
      oldOrigin += offsetShift;
      newCapacity += offsetShift;
      oldCapacity += offsetShift;
    }

    var oldTailOffset = getTailOffset(oldCapacity);
    var newTailOffset = getTailOffset(newCapacity);

    // New size might need creating a higher root.
    while (newTailOffset >= 1 << (newLevel + SHIFT)) {
      newRoot = new VNode(newRoot && newRoot.array.length ? [newRoot] : [], owner);
      newLevel += SHIFT;
    }

    // Locate


itor.Sigma.SynchronisationHandler.AddSynchronisationSource(valueHook);
				Trainers.Add(Trainer);

				valueHook = new ValueSourceReporter(TimeStep.Every(1, TimeScale.Iteration), "iteration");
				_trainer.AddLocalHook(valueHook);
				Monitor.Sigma.SynchronisationHandler.AddSynchronisationSource(valueHook);
			}

			//TODO: style?
			_playbackControl = new SigmaPlaybackControl { Trainer = Trainer, Margin = new Thickness(0, 0, 0, 20), HorizontalAlignment = HorizontalAlignment.Center };

			Content.Children.Add(_playbackControl);

			_parameterView = new ParameterView(Monitor.Sigma, window);

			SigmaTextBlock timeBox = (SigmaTextBlock) _parameterView.Add(Properties.Resources.RunningTime, typeof(object), _trainer.Operator.Registry, "runtime_millis");
			timeBox.AutoPollValues(_trainer, TimeStep.Every(1, TimeScale.Epoch));
			timeBox.Postfix = " ms";

			UserControlParameterVisualiser epochBox = (UserControlParameterVisualiser) _parameterView.Add(Properties.Resources.CurrentEpoch, typeof(object), _trainer.Operator.Registry, "epoch");
			epochBox.AutoPollValues(_trainer, TimeStep.Every(1, TimeScale.Epoch));

			UserControlParameterVisualiser iterationBox = (UserControlParameterVisualiser) _parameterView.Add(Properties.Resources.CurrentIteration, typeof(object), _trainer.Operator.Registry, "iteration");
			iterationBox.AutoPollValues(_trainer, TimeStep.Every(1, TimeScale.Iteration));

			IRegistry registry = new Registry
			{
				{ "operator", Trainer.Operator.GetType().Name },
				{ "optimiser", Trainer.Optimiser.GetType().Name }
			};
			_parameterView.Add(Properties.Resources.CurrentOperator, typeof(object), registry, "operator");
			_parameterView.Add(Properties.Resources.CurrentOptimiser, typeof(object), registry, "optimiser");
			//TODO: completely hardcoded activation function
			UserControlParameterVisualiser activationBox = (UserControlParameterVisualiser) _parameterView.Add(Properties.Resources.CurrentActivationFunction, typeof(object), _trainer.Operator.Registry, "network.layers.2-fullyconnected.activation");
			activationBox.AutoPollValues(_trainer, TimeStep.Every(1, TimeScale.Start));

			Trainer.AddGlobalHook(new LambdaHook(TimeStep.Every(1,TimeScale.Reset), (registry1, resolver) =>
			{
				epochBox.Read();
				iterationBox.Read();
			}));

			Content.Children.Add(_parameterView);
		}
	}
}


/*
 * MIT License
 *
 * Copyright (C) 2024, DragonDreams GmbH (info@dragondreams.ch)
 *
 * 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.
 */

#ifndef _IGDENATIVEFOXRESIZER_H_
#define _IGDENATIVEFOXRESIZER_H_

#include "foxtoolkit.h"

/**
 * \brief FOX toolkit Native resizer.
 *
 * When dragged sends SEL_COMMAND with the drag distance as integer parameter.
 * The receiver is responsible to resize according to the dragged distance.
 */
class igdeNativeFoxResizer : public FXWindow{
	FXDECLARE( igdeNativeFoxResizer )
protected:
	   igdeNativeFoxResizer();

private:
	bool pIsDragging;
	FXCursor *pCursor;
	int pGripSize;
	int pGripWidth;
	FXColor pActiveColor;

public:
	/** \name Constructors and Destructors */
	/*@{*/
	/** \brief Create resizer. */
	igdeNativeFoxResizer( FXComposite *parent, FXObject *target, FXSelector selector );

	/** \brief Clean up resizer. */
	virtual ~igdeNativeFoxResizer();
	/*@}*/

	/** \name Management */
	/*@{*/
	/** \brief Default height. */
	virtual FXint getDefaultHeight();

	/** \brief Dragged distance from SEL_COMMAND event data object. */
	static int SelCommandDraggedDistance( void *data );
	/*@}*/

	/** \name Events */
	/*@{*/
	long onPaint( FXObject*, FXSelector, void* );
	long onEnter( FXObject*, FXSelector, void* );
	long onLeave( FXObject*, FXSelector, void* );
	long onLeftMouseDown( FXObject*, FXSelector, void* );
	long onLeftMouseUp( FXObject*, FXSelector, void* );
	long onMouseMoved( FXObject*, FXSelector, void* );
	/*@}*/
};

#endif


class Hex {
	// Defines the graphical height/width of all hexagons in game
	height: number = glbHHeight;
	width: number = glbHWidth;

	scale: number = 0.2;

	// Axial column and axial row define individual hexagon position, parentID stores
	//  the landID for the parent land
	hexID: number;
	parentID: number;
	axialRow: number;
	axialCol: number;

	constructor(arraySpot: number, setPos: [number, number]) {
		this.hexID = arraySpot;
		this.parentID = currLand.landID;
		this.axialRow = setPos[0];
		this.axialCol = setPos[1];
	}

	// Method to return the expected axial coordinates of the instance's six neighbors.
	//  Axial coordinates of non-existant tiles are included in this.  The method starts
	//  with the north-east neightbor and proceeds clockwise
	getNeighbors() {
		let aNeighbors = [];
		aNeighbors[0] = [(this.axialRow-1), (this.axialCol+1)];
		aNeighbors[1] = [this.axialRow, (this.axialCol+1)];
		aNeighbors[2] = [(this.axialRow+1), this.axialCol];
		aNeighbors[3] = [(this.axialRow+1), (this.axialCol-1)];
		aNeighbors[4] = [this.axialRow, (this.axialCol-1)];
		aNeighbors[5] = [(this.axialRow-1), this.axialCol];
		return aNeighbors;
	}

	// Method to return the expected axial coordinates of the instance, using the given
	//  radius. Axial coordinates of non-existant tiles are included in this.  The method
	//  starts with the north-east ring member and proceeds clockwise
	getRing(radius) {
		let ringMembers = [];

		if (radius === 0) {
			console.log ("Error: radius cannot equal 0.");
			return ringMembers;
		}

		// Begin in the North East corner of the ring
		let tAxial = [-radius, radius];
		// Move in six directions, corresponding to the six sides of the ring
		for (var tDirec=0; tDirec < 6; tDirec++) {
			// The number of ring members on each side equals the radius of the ring
			for (var tFace=0; tFace < radius; tFace++) {
				ringMembers.push(tAxial);
				// Move one hex around the current face of the ring
				tAxial = moveHex(tAxial, tDirec, 1);
			}
		}

		return ringMembers;
	}

	// Returns the distance between this Hex and a specified target Hex
	getDistance(targetHex) {
		return (Math.abs(this.axialCol - targetHex.axialCol) +
						Math.abs(this.axialCol + this.axialRow -
							targetHex.axialCol - targetHex.axialCol) +
						Math.abs(this.axialRow - targetHex.axialRow)) / 2;
	}
}

class Tile extends Hex {
	// Landscape and development define the contents of the hexagon, these use Enums
	landscape: number = 0;
	development: number = null;
	ownedBy: number = null;
	selected: boolean = false;

	reDrawTile() {
		let arraySpot = currLand.getID([this.axialRow, this.axialCol]);
		let tSprite = currLand.spriteArray[arraySpot];
		let tBSprite = currLand.sprBorderArray[arraySpot];
		let tDevSpr = currLand.sprDevArray[arraySpot];
		tSprite.texture = sprMed[lscpArray[this.landscape].sprID];
		if (this.ownedBy != null) {
			tBSprite.alpha = 1;
			tBSprite.tint = rgbToHclr(cPlayerArray[this.ownedBy].color);
		}
		else {
			tBSprite.alpha = 0;
		}
		if (this.development != null) {
			tDevSpr.texture = sprMed[develArray[this.development].sprID[0]];
		}
		else {
			tDevSpr


1);
    sender.flush().expect("unable to flush serial port");

    // port 2 should now be readable
    common::expect_events(
        &mut poll,
        &mut events,
        vec![common::ExpectEvent::new(TOKEN2, Interest::READABLE)],
    );

    // read data on port 2
    common::checked_read(&mut cloned_receiver, &mut buf, DATA1);

    // port 2 should then return to blocking
    common::assert_would_block(cloned_receiver.read(&mut buf));

    // port 1 should be blocking on read for the reply
    common::assert_would_block(sender.read(&mut buf));
}
use crate::core::connection::connection::Port;
use crate::core::contexts::EventHandleContext;
use crate::core::events::event::Event;
use crate::core::id_mngmnt::id_registrar::IdRegistrar;
use crate::core::id_mngmnt::id_types::{GateId, ModuleId, ModuleTypeId, PortId};
use crate::core::messages::message::Message;
use crate::core::modules::module::{FinalizeResult, HandleResult, Module};

pub struct ModuleContainer {
    pub type_id: ModuleTypeId,
    pub id: ModuleId,
    pub inner_to_outer_gates: std::collections::HashMap<GateId, GateId>,
    pub outer_to_inner_gates: std::collections::HashMap<GateId, GateId>,

    name: String,
}

pub static TYPE_STR: &str = "ModuleContainer";

pub fn register(id_reg: &mut IdRegistrar) {
    id_reg.register_type(TYPE_STR.to_owned());
}

pub fn new_module_container(
    id_reg: &mut IdRegistrar,
    name: String,
    gates: Vec<(GateId, GateId)>,
) -> ModuleContainer {
    let mut container = ModuleContainer {
        id: id_reg.new_module_id(),
        type_id: id_reg.lookup_module_id(TYPE_STR.to_owned()).unwrap(),
        inner_to_outer_gates: std::collections::HashMap::new(),
        outer_to_inner_gates: std::collections::HashMap::new(),

        name: name,
    };

    for (outer, inner) in gates {
        container.inner_to_outer_gates.insert(inner, outer);
        container.outer_to_inner_gates.insert(outer, inner);
    }

    container
}

impl ModuleContainer {
    fn redirect_message(
        &mut self,
        msg: Box<Message>,
        gate: GateId,
        port: PortId,
        ctx: &mut EventHandleContext,
    ) {
        let inner = self.outer_to_inner_gates.get(&gate);
        let redirect_gate = match inner {
            Some(inner_gate) => Some(inner_gate),
            None => match self.inner_to_outer_gates.get(&gate) {
                Some(outer_gate) => Some(outer_gate),
                None => None,
            },
        };

        match redirect_gate {
            Some(redirect_gate) => {
                ctx.msgs_to_send.push_back((msg, *redirect_gate, port));
            }
            None => {
                panic!("No gate found");
            }
        }
    }
}

impl Module for ModuleContainer {
    fn get_gate_ids(&self) -> Vec<GateId> {
        let mut gates = Vec::with_capacity(self.inner_to_outer_gates.len() * 2);
        for (i, o) in &self.inner_to_outer_gates {
            gates.push(*i);
            gates.push(*o);
        }

        gates
    }

    fn name(&self) -> String {


(full_name, decoder, pluginGlobals)
		self.allDecodersLock.Lock()
		self.allDecoders = append(self.allDecoders, dRunner)
		self.allDecodersLock.Unlock()
		self.decodersWg.Add(1)
		dRunner.Start(self, &self.decodersWg)
	}
	return
}

// Stops and unregisters the provided DecoderRunner.
func (self *PipelineConfig) StopDecoderRunner(dRunner DecoderRunner) (ok bool) {
	self.allDecodersLock.Lock()
	defer self.allDecodersLock.Unlock()
	for i, r := range self.allDecoders {
		if r == dRunner {
			close(dRunner.InChan())
			self.allDecoders = append(self.allDecoders[:i], self.allDecoders[i+1:]...)
			ok = true
			break
		}
	}
	return
}

// Instantiates and returns an Encoder of the specified name.
func (self *PipelineConfig) Encoder(base_name, full_name string) (
	encoder Encoder, ok bool) {

	var wrapper *PluginWrapper
	if wrapper, ok = self.encoderWrappers[base_name]; ok {
		encoder = wrapper.Create().(Encoder)
		if wantsName, ok2 := encoder.(WantsName); ok2 {
			wantsName.SetName(full_name)
		}
		self.allEncodersLock.Lock()
		self.allEncoders[full_name] = encoder
		self.allEncodersLock.Unlock()
	}
	return
}

// Returns a FilterRunner with the given name, or nil and ok == false if no
// such name is registered.
func (self *PipelineConfig) Filter(name string) (fRunner FilterRunner, ok bool) {
	self.filtersLock.Lock()
	defer self.filtersLock.Unlock()
	fRunner, ok = self.FilterRunners[name]
	return
}

// Returns the specified StatAccumulator input plugin, or an error if it can't
// be found.
func (self *PipelineConfig) StatAccumulator(name string) (statAccum StatAccumulator,
	err error) {

	self.inputsLock.Lock()
	defer self.inputsLock.Unlock()
	iRunner, ok := self.InputRunners[name]
	if !ok {
		err = fmt.Errorf("No Input named '%s", name)
		return
	}
	input := iRunner.Input()
	if statAccum, ok = input.(StatAccumulator); !ok {
		err = fmt.Errorf("Input '%s' is not a StatAccumulator", name)
	}
	return
}

// Starts the provided FilterRunner and adds it to the set of running Filters.
func (self *PipelineConfig) AddFilterRunner(fRunner FilterRunner) error {
	self.filtersLock.Lock()
	defer self.filtersLock.Unlock()
	self.FilterRunners[fRunner.Name()] = fRunner
	self.filtersWg.Add(1)
	if err := fRunner.Start(self, &self.filtersWg); err != nil {
		self.filtersWg.Done()
		return fmt.Errorf("AddFilterRunner '%s' failed to start: %s",
			fRunner.Name(), err)
	} else {
		self.router.AddFilterMatcher() <- fRunner.MatchRunner()
	}
	return nil
}

// Removes the specified FilterRunner from the configuration and the
// MessageRouter which signals the filter to shutdown by closing the input
// channel. Returns true if the filter was removed.
func (self *PipelineConfig) RemoveFilterRunner(name string) bool {
	if Globals().Stopping {
		return false
	}

	self.filtersLock.Lock()
	defer self.filtersLock.Unlock()
	if fRunner, ok := self.FilterRunners[name]; ok {
		self.router.RemoveFilterMatcher() <- fRunner.MatchRunner()
		delete(self.FilterRunners, name)
		return true
	}
	return false
}

// Starts the provided InputRunner and adds it to the set of running Inputs.
func (self *PipelineConfig) AddInputRunner(iRun


ropdown-button-icon-tooltip__content {
    max-width: 160px;
}
// (C) 2022-2025 GoodData Corporation
.gd-attribute-filter-dropdown-actions__next {
    border-top: 1px solid var(--gd-palette-complementary-3, #dde4eb);
    text-align: right;
    display: flex;
    justify-content: space-between;
    align-items: center;
    margin: 0 10px;
    padding: 10px 0;
}

.gd-attribute-filter-dropdown-actions-left-content__next,
.gd-attribute-filter-dropdown-actions-right-content__next {
    display: flex;
    align-items: center;

    .gd-ui-kit-tooltip__anchor {
        .gd-attribute-filter-apply-button__next {
            margin-left: 10px;
        }
    }
}

.gd-is-mobile {
    .gd-attribute-filter-dropdown-actions__next {
        display: flex;
        align-items: stretch;
        height: 52px;
        margin: 0 10px;
        padding: 10px 0;
    }

    .gd-attribute-filter-cancel-button__next,
    .gd-attribute-filter-apply-button__next,
    .gd-attribute-filter-close-button__next {
        text-align: center;
        flex: 1;
        height: 32px;
        font-size: 14px;
    }
}
// (C) 2007-2018 GoodData Corporation
// Here we define the breakpoints which will become the upper border for each media size.
// The function em-calc() calculates the em-value from a px-value.

$include-html-classes: false;
$include-html-global-classes: false;

$small-breakpoint: em-calc(640) !default;
$medium-breakpoint: em-calc(1024) !default;
$large-breakpoint: em-calc(1440) !default;
$xlarge-breakpoint: em-calc(1920) !default;

// Here we define the lower and upper bounds for each media size
$small-range: (0, $small-breakpoint) !default; /* 0, 640px */
$medium-range: ($small-breakpoint + em-calc(1), $medium-breakpoint) !default; /* 641px, 1024px */
$large-range: ($medium-breakpoint + em-calc(1), $large-breakpoint) !default; /* 1025px, 1440px */
$xlarge-range: ($large-breakpoint + em-calc(1), $xlarge-breakpoint) !default; /* 1441px, 1920px */
$xxlarge-range: ($xlarge-breakpoint + em-calc(1), em-calc(99999999)) !default; /* 1921px, ... */

// Media Queries
@function lower-bound($range) {
    @if length($range) <= 0 {
        @return 0;
    }
    @return nth($range, 1);
}

@function upper-bound($range) {
    @if length($range) < 2 {
        @return 999999999999;
    }
    @return nth($range, 2);
}

$screen: "only screen" !default;

$landscape: "#{$screen} and (orientation: landscape)" !default;
$portrait: "#{$screen} and (orientation: portrait)" !default;

$small-up: $screen !default;
$small-only: "#{$screen} and (max-width: #{upper-bound($small-range)})" !default;

$medium-up: "#{$screen} and (min-width:#{lower-bound($medium-range)})" !default;
$medium-only: "#{$screen} and (min-width:#{lower-bound($medium-range)}) and (max-width:#{upper-bound($medium-range)})" !default;

$large-up: "#{$screen} and (min-width:#{lower-bound($large-range)})" !default;
$large-only: "#{$screen} and (min-width:#{lower-bound($large-range)}) and (max-width:#{upper-bound($large-range)})" !default;

$xlarge-up: "#{$screen} and (min-width:#{lower-bound($xlarge-range)})" !default;
$xlarge-


1、调整gpt代理默认为空。

🌟Fay-agent版：

1、去除语音输出工具，改为语音输出只受“语音合成”按钮影响。

🌟Fay-助理版：

1、调整gpt代理默认为空；

2、去除funasr_wss方法；

3、rasa 支持llma3并优化接口；

4、rasa支持通过vllm部署大模型；

5、支持通过vllm部署的本地模型启动项目；

6、采用fastchat既可以降低显存，又能提升响应速度，支持主流模型部署；

7、修复类 GPT调用失败问题；

8、新增metahuman-stream对接示例 https://qqk9ntwbcit.feishu.cn/wiki/Ik1kwO9X5iilnGkFwRhcnmtvn3e

🌟Fay-UE5：

1、增加文本输入框（与Fay会同步消息），方便网页端和移动端操作。

FFay数字人2024.05.15更新：

🌟Fay-带货版：

1、新增baidu情绪分析秘钥为空时不使用情绪分析；

2、去除讯飞nlp。

🌟Fay-助理版：

1、新增baidu情绪分析秘钥为空时不使用情绪分析。

🌟Fay-UE5：

1、增加语音按钮，方便网页端和移动端操作;

2、修复ue4男模工程。

✨本期推荐学习：

1、metahuman-stream对接Fay：

https://qqk9ntwbcit.feishu.cn/wiki/Ik1kwO9X5iilnGkFwRhcnmtvn3e

FFay数字人2024.05.08更新：

🌟Fay-agent版：

1、配置项新增gpt模型配置、gpt代理默认空；

本期推荐学习：

1、【在Fay接入ufo执行任务】 https://www.bilibili.com/video/BV1rJ4m1P7Ee/

文档：https://qqk9ntwbcit.feishu.cn/wiki/BX2gw9r8JicKLukGbOZcs9YdnGh

FFay数字人2024.04.22更新：

🌟Fay-带货版：

1、使用百度情感分析替换讯飞；

 2、优化白屏问题。

🌟Fay-助理版：

1、使用百度情感分析替换讯飞；

2、优化白屏问题。

3、利用vllm对大模型进行加速推理，提升响


2, r2), y2 && y2.m(n2, null), (0, a.R3I)(n2, i3), (0, a.R3I)(n2, c2);
              for (var w3 = 0; w3 < h2.length; w3 += 1)
                h2[w3].m(c2, null);
              (0, a.R3I)(n2, u2), (0, a.R3I)(n2, s2), (0, a.yef)(l2, s2, null), d2 = true, v2 || (p2 = (0, a.oLt)(n2, "click", t2[5]), v2 = true);
            }, p: function(t3, u3) {
              t3[0].groupLevel ? m3 ? m3.p(t3, u3) : ((m3 = nn(t3)).c(), m3.m(n2, e2)) : m3 && (m3.d(1), m3 = null), t3[2] > 0 ? _2 || ((_2 = on(t3)).c(), _2.m(n2, o2)) : _2 && (_2.d(1), _2 = null), t3[1] ? b2 ? b2.p(t3, u3) : ((b2 = rn(t3)).c(), b2.m(n2, r2)) : b2 && (b2.d(1), b2 = null), t3[0].repeated ? y2 ? y2.p(t3, u3) : ((y2 = an(t3)).c(), y2.m(n2, i3)) : y2 && (y2.d(1), y2 = null), 17 & u3 && (w2 = t3[0].data, (0, a.dvw)(), h2 = (0, a.GQg)(h2, u3, E2, 1, t3, w2, g2, c2, a.cly, sn, null, Jt), (0, a.gbL)()), (!d2 || 1 & u3 && f2 !== (f2 = "vc-log-row vc-log-" + t3[0].type)) && (0, a.Ljt)(n2, "class", f2), 1 & u3 && (0, a.VHj)(n2, "vc-log-input", "input" === t3[0].cmdType), 1 & u3 && (0, a.VHj)(n2, "vc-log-output", "output" === t3[0].cmdType), 5 & u3 && (0, a.VHj)(n2, "vc-log-group", t3[2] > 0), 5 & u3 && (0, a.VHj)(n2, "vc-toggle", 1 === t3[2]);
            }, i: function(t3) {
              if (!d2) {
                for (var n3 = 0; n3 < w2.length; n3 += 1)
                  (0, a.Ui)(h2[n3]);
                (0, a.Ui)(l2.$$.fragment, t3), d2 = true;
              }
            }, o: function(t3) {
              for (var n3 = 0; n3 < h2.length; n3 += 1)
                (0, a.etI)(h2[n3]);
              (0, a.etI)(l2.$$.fragment, t3), d2 = false;
            }, d: function(t3) {
              t3 && (0, a.ogt)(n2), m3 && m3.d(), _2 && _2.d(), b2 && b2.d(), y2 && y2.d();
              for (var e3 = 0; e3 < h2.length; e3 += 1)
                h2[e3].d();
              (0, a.vpE)(l2), v2 = false, p2();
            } };
          }
          function nn(t2) {
            for (var n2, e2 = new Array(t2[0].groupLevel), o2 = [], r2 = 0; r2 < e2.length; r2 += 1)
              o2[r2] = en(Qt(t2, e2, r2));
            return { c: function() {
              for (var t3 = 0; t3 < o2.length; t3 += 1)
                o2[t3].c();
              n2 = (0, a.cSb)(