_from), from);
  ParseHouseNumber(strings::MakeUniString(m_to), to);

  if (from.size() != 1 || to.size() != 1)
    return kInvalidRange;

  ASSERT(!from[0].empty() && !to[0].empty(), ());
  auto const & f = from[0][0];
  auto const & t = to[0][0];
  if (f.m_type != Token::TYPE_NUMBER || t.m_type != Token::TYPE_NUMBER)
    return kInvalidRange;

  return {ToUInt(f.m_value), ToUInt(t.m_value)};
}

std::string DebugPrint(AddressEnricher::Stats const & s)
{
  return "{ m_noStreet = " + std::to_string(s.m_noStreet) + "; m_existInterpol = " + std::to_string(s.m_existInterpol) +
         "; m_existSingle = " + std::to_string(s.m_existSingle) +
         "; m_enoughAddrs = " + std::to_string(s.m_enoughAddrs) +
         "; m_addedSingle = " + std::to_string(s.m_addedSingle) +
         "; m_addedBegEnd = " + std::to_string(s.m_addedBegEnd) +
         "; m_addedInterpol = " + std::to_string(s.m_addedInterpol) + " }";
}

AddressEnricher::AddressEnricher()
{
  auto const & cl = classif();
  m_addrType = cl.GetTypeByPath({"building", "address"});

  m_interpolType[InterpolType::Odd] = cl.GetTypeByPath({"addr:interpolation", "odd"});
  m_interpolType[InterpolType::Even] = cl.GetTypeByPath({"addr:interpolation", "even"});
  m_interpolType[InterpolType::Any] = cl.GetTypeByPath({"addr:interpolation"});
}

void AddressEnricher::AddSrc(feature::FeatureBuilder && fb)
{
  auto const osmID = fb.GetMostGenericOsmId();
  auto const & params = fb.GetParams();
  auto const & types = fb.GetTypes();

  bool const hasStreet = !params.GetStreet().empty();

  if (hasStreet && !params.house.IsEmpty())
  {
    if (fb.IsLine())
    {
      LOG(LERROR, ("Linear address FB:", osmID));
      return;
    }
    else
      TransformToPoint(fb);
  }
  else if (ftypes::IsStreetOrSquareChecker::Instance()(types))
  {
    // Skip node "squares" for matching, as far as we make addr:interpolation FBs.
    // https://www.openstreetmap.org/node/7315145526
    if (fb.IsPoint())
    {
      LOG(LWARNING, ("Point street FB:", osmID));
      return;
    }

    std::string_view name;
    if (params.name.GetString(StringUtf8Multilang::kDefaultCode, name))
      CHECK(!name.empty(), (osmID));
    else if (params.ref.empty())
      return;
  }
  else if (hasStreet && ftypes::IsAddressInterpolChecker::Instance()(types))
  {
    CHECK(!params.ref.empty(), (osmID));
  }
  else
    return;

  m_srcTree.Add(std::move(fb));
}

void AddressEnricher::ProcessRawEntries(std::string const & path, TFBCollectFn const & fn)
{
  FileReader reader(path);
  ReaderSource src(reader);
  while (src.Size())
  {
    Entry e;
    e.Load(src);

    std::vector<int64_t> iPoints;
    rw::Read(src, iPoints);

    e.m_points.reserve(iPoints.size());
    for (auto const i : iPoints)
      e.m_points.push_back(Int64ToPointObsolet


, b"u16");
pub const U32: Name = Name::new_inline_ascii(3, b"u32");
pub const U64: Name = Name::new_inline_ascii(3, b"u64");
pub const U128: Name = Name::new_inline_ascii(4, b"u128");
pub const F32: Name = Name::new_inline_ascii(3, b"f32");
pub const F64: Name = Name::new_inline_ascii(3, b"f64");
pub const BOOL: Name = Name::new_inline_ascii(4, b"bool");
pub const CHAR: Name = Name::new_inline_ascii(4, b"char");
pub const STR: Name = Name::new_inline_ascii(3, b"str");

// Special names
pub const SELF_PARAM: Name = Name::new_inline_ascii(4, b"self");
pub const SELF_TYPE: Name = Name::new_inline_ascii(4, b"Self");
pub const MACRO_RULES: Name = Name::new_inline_ascii(11, b"macro_rules");

// Components of known path (value or mod name)
pub const STD: Name = Name::new_inline_ascii(3, b"std");
pub const ITER: Name = Name::new_inline_ascii(4, b"iter");
pub const OPS: Name = Name::new_inline_ascii(3, b"ops");
pub const FUTURE: Name = Name::new_inline_ascii(6, b"future");
pub const RESULT: Name = Name::new_inline_ascii(6, b"result");
pub const BOXED: Name = Name::new_inline_ascii(5, b"boxed");

// Components of known path (type name)
pub const INTO_ITERATOR_TYPE: Name = Name::new_inline_ascii(12, b"IntoIterator");
pub const ITEM_TYPE: Name = Name::new_inline_ascii(4, b"Item");
pub const TRY_TYPE: Name = Name::new_inline_ascii(3, b"Try");
pub const OK_TYPE: Name = Name::new_inline_ascii(2, b"Ok");
pub const FUTURE_TYPE: Name = Name::new_inline_ascii(6, b"Future");
pub const RESULT_TYPE: Name = Name::new_inline_ascii(6, b"Result");
pub const OUTPUT_TYPE: Name = Name::new_inline_ascii(6, b"Output");
pub const TARGET_TYPE: Name = Name::new_inline_ascii(6, b"Target");
pub const BOX_TYPE: Name = Name::new_inline_ascii(3, b"Box");

// Builtin Macros
pub const LINE_MACRO: Name = Name::new_inline_ascii(4, b"line");
pub const STRINGIFY_MACRO: Name = Name::new_inline_ascii(9, b"stringify");
#![allow(non_snake_case, non_camel_case_types, non_upper_case_globals, clashing_extern_declarations, clippy::all)]
#[doc = "*Required features: 'ApplicationModel_ExtendedExecution_Foreground'*"]
#[repr(transparent)]
pub struct ExtendedExecutionForegroundReason(pub i32);
impl ExtendedExecutionForegroundReason {
    pub const Unspecified: Self = Self(0i32);
    pub const SavingData: Self = Self(1i32);
    pub const BackgroundAudio: Self = Self(2i32);
    pub const Unconstrained: Self = Self(3i32);
}
impl ::core::marker::Copy for ExtendedExecutionForegroundReason {}
impl ::core::clone::Clone for ExtendedExecutionForegroundReason {
    fn clone(&self) -> Self {
        *self
    }
}
#[doc = "*Required features: 'ApplicationModel_ExtendedExecution_Foreground'*"]
#[repr(transparent)]
pub struct ExtendedExecutionForegroundResult(pub i32);
impl ExtendedExecutionForegroundResult {
    pub const Allowed: Self = Self(0i32);
    pub const Denied: Self = Self(1i32);
}
impl ::core::marker::Copy for


6,%i0,%l0
	ldx	[%l0+0],%o0			! read and check our 4 test words

	setx	0x00001000,%l0,%l1
	xor	%o0,%l1,%o0
	andcc	%o0,%l4,%o0
	bnz	Test_fail
	nop

    or	%g0,0x3c0,%l6

Read_loop_end2:
	srl	%l


028A60: .word WINDOW_LIST
	arm_func_end sub_02028A08

	arm_func_start sub_02028A64
sub_02028A64: ; 0x02028A64
	stmdb sp!, {r4, r5, r6, r7, r8, sb, sl, lr}
	ldr r1, _02028DE8 ; =_020AFD4C
	movs r4, r0
#ifdef JAPAN
	strb r4, [r1, #2]
#else
	strb r4, [r1, #4]
#endif
	mov r5, #8
	beq _02028D58
	ldr r0, _02028DEC ; =_022A7A6C
	mov r1, #0
#ifdef JAPAN
	ldrsb r3, [r0, #1]
#else
	ldrsb r3, [r0, #3]
	strb r3, [r0, #5]
#endif
	strh r1, [r0, #6]
	b _02028BF4
_02028A94:
	ldr r1, _02028DF0 ; =WINDOW_LIST
	mov r0, #0xe0
	mla r6, r3, r0, r1
	ldrsb r1, [r6, #0xb6]
	ldr r2, _02028DF4 ; =_022A7B1C
#ifdef JAPAN
	mov r0, #0x2c
#else
	mov r0, #0x30
#endif
	mla r7, r3, r0, r2
	cmp r1, #0
#ifdef JAPAN
	mov r0, #0
	beq _02028BDC
#else
	beq _02028BDC
	mov r0, #0
#endif
	strb r0, [r6, #0xb7]
	ldrb r0, [r6, #8]
	mov r1, #1
	strb r1, [r7]
	cmp r0, #0
	bne _02028BC4
	ldr r0, _02028DF8 ; =_020AFD98
	ldrsb r3, [r6, #9]
	ldrb r2, [r0]
	ldr r0, _02028DEC ; =_022A7A6C
	ldr r1, _02028DFC ; =_0209ACA8
	ldrsh r0, [r0, #0x58]
	rsb r3, r3, #0
	ldrb r1, [r1, r2]
	ldr r2, _02028E00 ; =_0209AC64
	mov r3, r3, lsl #1
	ldrsb r8, [r2, r3]
	bl sub_020278A8
	mov r1, r5, lsl #1
	str r0, [r6, #0x98]
	add r0, r1, #9
	strh r0, [r6, #0x9e]
	add r0, r1, #0xa
	strh r0, [r6, #0x5e]
	cmp r8, #0
	sub r5, r5, #1
	blt _02028BC4
	ldrsh r0, [r6, #0x38]
	cmp r0, #0
	beq _02028BC4
	ldr r0, _02028E04 ; =_0209AC78
	mov r1, r8, lsl #3
	add r3, r0, r8, lsl #3
	ldrsh r1, [r0, r1]
	ldr r0, _02028DEC ; =_022A7A6C
	ldrsh r2, [r3, #2]
	strh r1, [r6, #0x8a]
	ldrsh r8, [r0, #6]
	ldrsh r1, [r3, #4]
	strh r2, [r6, #0x8c]
	ldrsh r0, [r3, #6]
	strh r1, [r6,


Nempty,S0] | E[I,VII,vN1,Ff0_II_B,fNempty,S0] CMPI E[I,VII,vN0,Ff0_II_B,fNempty,S0] | E[I,VII,vN0,Ff0_II_B,fNempty,S0] CMPI E[I,VII,vN1,Ff0_II_B,fNempty,S0] | E[I,VII,vNempty,Ff0_II_B,fNempty,S0] CMPI E[I,VII,vN0_1,Ff0_II_B,fNempty,S0] | E[I,VII,vN0_1,Ff0_II_B,fNempty,S0] EQOP E[I,VII,vNempty,Ff0_II_B,fNempty,S0] | E[B,VII,vN0_1,Ff0_II_B,fNempty,S0] EQOP E[B,VII,vNempty,Ff0_II_B,fNempty,S0] | E[I,VII,vN1,Ff0_II_B,fNempty,S0] EQOP E[I,VII,vN0,Ff0_II_B,fNempty,S0] | E[B,VII,vN1,Ff0_II_B,fNempty,S0] EQOP E[B,VII,vN0,Ff0_II_B,fNempty,S0] | E[I,VII,vN0,Ff0_II_B,fNempty,S0] EQOP E[I,VII,vN1,Ff0_II_B,fNempty,S0] | E[B,VII,vN0,Ff0_II_B,fNempty,S0] EQOP E[B,VII,vN1,Ff0_II_B,fNempty,S0] | E[I,VII,vNempty,Ff0_II_B,fNempty,S0] EQOP E[I,VII,vN0_1,Ff0_II_B,fNempty,S0] | E[B,VII,vNempty,Ff0_II_B,fNempty,S0] EQOP E[B,VII,vN0_1,Ff0_II_B,fNempty,S0] | if E[B,VII,vN0_1,Ff0_II_B,fNempty,S0] then E[B,VII,vNempty,Ff0_II_B,fNempty,S0] else E[B,VII,vNempty,Ff0_II_B,fNempty,S0] | if E[B,VII,vN0,Ff0_II_B,fNempty,S0] then E[B,VII,vN1,Ff0_II_B,fNempty,S0] else E[B,VII,vNempty,Ff0_II_B,fNempty,S0] | if E[B,VII,vN0,Ff0_II_B,fNempty,S0] then E[B,VII,vNempty,Ff0_II_B,fNempty,S0] else E[B,VII,vN1,Ff0_II_B,fNempty,S0] | if E[B,VII,vN1,Ff0_II_B,fNempty,S0] then E[B,VII,vN0,Ff0_II_B,fNempty,S0] else E[B,VII,vNempty,Ff0_II_B,fNempty,S0] | if E[B,VII,vNempty,Ff0_II_B,fNempty,S0] then E[B,VII,vN0_1,Ff0_II_B,fNempty,S0] else E[B,VII,vNempty,Ff0_II_B,fNempty,S0] | if E[B,VII,vNempty,Ff0_II_B,fNempty,S0] then


== stzg x0,  [x1, #-4096]!
0x41,0xfc,0x6f,0xd9 == stzg x1,  [x2, #4080]!
0xe2,0x1f,0x60,0xd9 == stzg x2,  [sp, #16]!
0xff,0x1f,0x60,0xd9 == stzg sp,  [sp, #16]!
0x20,0x04,0x30,0xd9 == stg x0,  [x1], #-4096
0x41,0xf4,0x2f,0xd9 == stg x1,  [x2], #4080
0xe2,0x17,0x20,0xd9 == stg x2,  [sp], #16
0xff,0x17,0x20,0xd9 == stg sp,  [sp], #16
0x20,0x04,0x70,0xd9 == stzg x0,  [x1], #-4096
0x41,0xf4,0x6f,0xd9 == stzg x1,  [x2], #4080
0xe2,0x17,0x60,0xd9 == stzg x2,  [sp], #16
0xff,0x17,0x60,0xd9 == stzg sp,  [sp], #16
0x20,0x08,0xa0,0xd9 == st2g x0,  [x1]
0x21,0x08,0xb0,0xd9 == st2g x1,  [x1, #-4096]
0x42,0xf8,0xaf,0xd9 == st2g x2,  [x2, #4080]
0xe3,0x1b,0xa0,0xd9 == st2g x3,  [sp, #16]
0xff,0x1b,0xa0,0xd9 == st2g sp,  [sp, #16]
0x20,0x08,0xe0,0xd9 == stz2g x0,  [x1]
0x21,0x08,0xf0,0xd9 == stz2g x1,  [x1, #-4096]
0x42,0xf8,0xef,0xd9 == stz2g x2,  [x2, #4080]
0xe3,0x1b,0xe0,0xd9 == stz2g x3,  [sp, #16]
0xff,0x1b,0xe0,0xd9 == stz2g sp,  [sp, #16]
0x20,0x0c,0xb0,0xd9 == st2g x0,  [x1, #-4096]!
0x41,0xfc,0xaf,0xd9 == st2g x1,  [x2, #4080]!
0xe2,0x1f,0xa0,0xd9 == st2g x2,  [sp, #16]!
0xff,0x1f,0xa0,0xd9 == st2g sp,  [sp, #16]!
0x20,0x0c,0xf0,0xd9 == stz2g x0,  [x1, #-4096]!
0x41,0xfc,0xef,0xd9 == stz2g x1,  [x2, #4080]!
0xe2,0x1f,0xe0,0xd9 == stz2g x2,  [sp, #16]!
0xff,0x1f,0xe0,0xd9 == stz2g sp,  [sp, #16]!
0x20,0x04,0xb0,0xd9 == st2g x0,  [x1], #-4096
0x41,0xf4,0xaf,0xd9 == st2g x1,  [x2], #4080
0xe2,0x17,0xa0,0xd9 == st2g


c!["hello", "n", "2"]);

        match result {
            Err(RedisError::String(s)) => {
                assert_eq!(s, "Expected hello.foo, got hello");
            }
            _ => assert!(false, "Bad result: {:?}", result),
        }

        let result = run_hello_foo(&vec!["hello.foo", "bar", "n", "2", "bad"]);

        match result {
            Err(RedisError::String(s)) => {
                assert_eq!(s, "Unexpected arg bad");
            }
            _ => assert!(false, "Bad result: {:?}", result),
        }
    }
}
// Copyright 2019 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use std::convert::TryInto;
use std::mem;

use super::bindings;
use bitflags::bitflags;
use vm_memory::ByteValued;

/// Version number of this interface.
pub const KERNEL_VERSION: u32 = 7;

/// Minor version number of this interface.
pub const KERNEL_MINOR_VERSION: u32 = 27;

/// The ID of the inode corresponding to the root directory of the file system.
pub const ROOT_ID: u64 = 1;

// Bitmasks for `fuse_setattr_in.valid`.
const FATTR_MODE: u32 = 1;
const FATTR_UID: u32 = 2;
const FATTR_GID: u32 = 4;
const FATTR_SIZE: u32 = 8;
const FATTR_ATIME: u32 = 16;
const FATTR_MTIME: u32 = 32;
pub const FATTR_FH: u32 = 64;
const FATTR_ATIME_NOW: u32 = 128;
const FATTR_MTIME_NOW: u32 = 256;
pub const FATTR_LOCKOWNER: u32 = 512;
const FATTR_CTIME: u32 = 1024;

bitflags! {
    pub struct SetattrValid: u32 {
        const MODE = FATTR_MODE;
        const UID = FATTR_UID;
        const GID = FATTR_GID;
        const SIZE = FATTR_SIZE;
        const ATIME = FATTR_ATIME;
        const MTIME = FATTR_MTIME;
        const ATIME_NOW = FATTR_ATIME_NOW;
        const MTIME_NOW = FATTR_MTIME_NOW;
        const CTIME = FATTR_CTIME;
    }
}

// Flags returned by the OPEN request.

/// Bypass page cache for this open file.
const FOPEN_DIRECT_IO: u32 = 1;

/// Don't invalidate the data cache on open.
const FOPEN_KEEP_CACHE: u32 = 2;

/// The file is not seekable.
const FOPEN_NONSEEKABLE: u32 = 4;

/// Allow caching this directory.
const FOPEN_CACHE_DIR: u32 = 8;

bitflags! {
    /// Options controlling the behavior of files opened by the server in response
    /// to an open or create request.
    pub struct OpenOptions: u32 {
        const DIRECT_IO = FOPEN_DIRECT_IO;
        const KEEP_CACHE = FOPEN_KEEP_CACHE;
        const NONSEEKABLE = FOPEN_NONSEEKABLE;
        const CACHE_DIR = FOPEN_CACHE_DIR;
    }
}

// INIT request/reply flags.

/// Asynchronous read requests.
const ASYNC_READ: u32 = 1;

/// Remote locking for POSIX file locks.
const POSIX_LOCKS: u32 = 2;

/// Kernel sends file handle for fstat, etc... (not yet supported).
const FILE_OPS: u32 = 4;

/// Handles the O_TRUNC open flag in the filesystem.
const ATOMIC_O_TRUNC: u32 = 8;

/// FileSystem handles lookups of "." and "..".
const EXPORT_SUPPORT: u32 = 16;

/// FileSystem can handle write size larger than 4kB.
const BIG_WRITES: u32 = 32;

/// Don't apply umask to file mode on create operations.


ists sAppPath & "czdemo.dec"

   'Write it out to the .co file
   iFile = FreeFile
   Open sAppPath & "czdemo.co" For Binary Access Write As #iFile
   Put #iFile, , TheBytes()
   Close #iFile

   'decompress byte array
   lR = m_cZLib.DecompressData(TheBytes(), m_cZLib.OriginalSize)

   'Write it out to the .dec file
   iFile = FreeFile
   Open sAppPath & "czdemo.dec" For Binary Access Write As #iFile
   Put #iFile, , TheBytes()
   Close #iFile

Erase TheBytes

End Sub

Private Sub cmdCompressData_Click()

Dim TheBytes() As Byte
Dim lDataSize As Long
Dim lR As Long
Dim lCnt As Long
Dim l As Long
Dim TheChar As Byte

   lDataSize = 100
   lDataSize = lDataSize * 1024

   ReDim TheBytes(0 To lDataSize - 1) 'allocate precisely 100K

'Fill our bytes from random junk.
'we use 10 bytes of one char, 10 bytes of another,
'and so on.
   lCnt = 10
   For l = 0 To UBound(TheBytes)
      If lCnt = 10 Then
         TheChar = Int((255 - 0 + 1) * Rnd + 0)
         lCnt = 0
      End If
      TheBytes(l) = TheChar
   Next l

   MsgBox "Original size: " & CStr(UBound(TheBytes) + 1) & " bytes",
    vbInformation

   lR = m_cZLib.CompressData(TheBytes())

   MsgBox "Compressed size: " & CStr(UBound(TheBytes) + 1) & " bytes",
    vbInformation

   lR = m_cZLib.DecompressData(TheBytes(), m_cZLib.OriginalSize)

   MsgBox "Decompressed (or should I say original) size: " &
    CStr(UBound(TheBytes) + 1) & " bytes", vbInformation

   'cleanup

   Erase TheBytes

End Sub

Private Sub cmdCompressString_Click()
Dim sOurString As String
Dim lR As Long

   sOurString = "This is a string. It is just a normal ordinary string."

   MsgBox "Length = " & Len(sOurString) & vbCrLf & vbCrLf & sOurString,
    vbInformation

   lR = m_cZLib.CompressString(sOurString)

   MsgBox "Length = " & Len(sOurString) & vbCrLf & vbCrLf & "Compressed string
    (may not display all characters due to Nulls): " & vbCrLf & vbCrLf &
    sOurString, vbInformation

   lR = m_cZLib.DecompressString(sOurString, m_cZLib.OriginalSize)

   MsgBox "Here it is, again, decompressed: " & vbCrLf & vbCrLf & sOurString,
    vbInformation

   'Note, if res is not 0 then it would mean an error.

End Sub

Private Sub Form_Load()
   Set m_cZLib = New CompressZIt
End Sub

Private Sub lstDirectory_Change()
   lstFiles.Path = lstDirectory.Path
End Sub

Home .&#160


                      "time": "2020-02-01T00:55:53Z"
                    },
                    {
                        "replicas": 4,
                        "time": "2020-02-01T00:56:03Z"
                    }
                ]
            }"""
    }, {
        "description":
        "Successful prediction, 15 seconds in the future",
        "expected_status_code":
        0,
        "expected_stderr":
        "",
        "expected_stdout":
        "7",
        "stdin":
        """{
                "lookAhead": 15000,
                "currentTime": "2020-02-01T00:56:12Z",
                "replicaHistory": [
                    {
                        "replicas": 1,
                        "time": "2020-02-01T00:55:33Z"
                    },
                    {
                        "replicas": 2,
                        "time": "2020-02-01T00:55:43Z"
                    },
                    {
                        "replicas": 3,
                        "time": "2020-02-01T00:55:53Z"
                    },
                    {
                        "replicas": 4,
                        "time": "2020-02-01T00:56:03Z"
                    }
                ]
            }"""
    }]

    for i, test_case in enumerate(test_cases):
        with subtests.test(msg=test_case["description"], i=i):
            result = subprocess.run(["python", "./algorithms/linear_regression/linear_regression.py"],
                                    input=test_case["stdin"].encode("utf-8"),
                                    capture_output=True,
                                    check=False)

            stderr = result.stderr
            if stderr is not None:
                stderr = stderr.decode("utf-8")

            stdout = result.stdout
            if stdout is not None:
                stdout = stdout.decode("utf-8")

            assert test_case["expected_status_code"] == result.returncode
            assert test_case["expected_stderr"] == stderr
            assert test_case["expected_stdout"] == stdout


/*
 * Copyright (c) Atmosphère-NX
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include <mesosphere/kern_select_assembly_macros.h>

/* ams::kern::svc::CallReturnFromException64(Result result) */
.section    .text._ZN3ams4kern3svc25CallReturnFromException64Ev, "ax", %progbits
.global     _ZN3ams4kern3svc25CallReturnFromException64Ev
.type       _ZN3ams4kern3svc25CallReturnFromException64Ev, %function
_ZN3ams4kern3svc25CallReturnFromException64Ev:
    /* Save registers the SVC entry handler didn't. */
    stp     x12, x13, [sp, #(EXCEPTION_CONTEXT_X12_X13)]
    stp     x14, x15, [sp, #(EXCEPTION_CONTEXT_X14_X15)]
    stp     x16, x17, [sp, #(EXCEPTION_CONTEXT_X16_X17)]
    str     x19,      [sp, #(EXCEPTION_CONTEXT_X19)]
    stp     x20, x21, [sp, #(EXCEPTION_CONTEXT_X20_X21)]
    stp     x22, x23, [sp, #(EXCEPTION_CONTEXT_X22_X23)]
    stp     x24, x25, [sp, #(EXCEPTION_CONTEXT_X24_X25)]
    stp     x26, x27, [sp, #(EXCEPTION_CONTEXT_X26_X27)]
    stp     x28, x29, [sp, #(EXCEPTION_CONTEXT_X28_X29)]

    /* Call ams::kern::arch::arm64::ReturnFromException(result). */
    bl      _ZN3ams4kern4arch5arm6419ReturnFromExceptionENS_6ResultE

0:  /* We should never reach this point. */
    b       0b

/* ams::kern::svc::CallReturnFromException64From32(Result result) */
.section    .text._ZN3ams4kern3svc31CallReturnFromException64From32Ev, "ax", %progbits
.global     _ZN3ams4kern3svc31CallReturnFromException64From32Ev
.type       _ZN3ams4kern3svc31CallReturnFromException64From32Ev, %function
_ZN3ams4kern3svc31CallReturnFromException64From32Ev:
    /* Save registers the SVC entry handler didn't. */
    /* ... */

    /* Call ams::kern::arch::arm64::ReturnFromException(result). */
    bl      _ZN3ams4kern4arch5arm6419ReturnFromExceptionENS_6ResultE

0:  /* We should never reach this point. */
    b       0b

/* ams::kern::svc::RestoreContext(uintptr_t sp) */
.section    .text._ZN3ams4kern3svc14RestoreContextEm, "ax", %progbits
.global     _ZN3ams4ker


能否告诉我您的肤质以及已使用的护肤品牌和产品，以便我可以为您提供更加个性化的美容护肤建议？                                         |
| 金融投资                                          | 您的投资目标和风险承受能力是什么？您对于股票、基金、债券等不同类别的投资工具有何了解和偏好？                                       |
| 电影推荐                                          | 您喜欢哪些类型的电影？您最近观看的一部电影是什么？对于这部电影您有何评价？                                                           |
| 社交媒体引导                                      | 您希望在社交媒体上获得哪些类型的信息？比如新闻、娱乐、时事评论等。                                                                  |
| 分类     | 这个文本属于哪个主题？                                         |
| 补全     | 给定一句话：XXX，继续这个话题的下文。                         |
| 对比编辑 | 将两篇文本进行对比，列出不同之处。                             |
| 情感分析 | 这段文字的情感是正面、负面还是中性？                         |
| 后续任务 | 结束了上一个任务后，接下来你应该做什么？                     |
| 关联问题 | 这篇文章与XXX有什么相关性？                                   |
| 翻译     | 将一段英文翻译成中文。                                         |
| 生成     | 请根据所给信息，生成一篇关于XXX的文章。                       |
| 判断     | 这个观点是否正确？                                             |
| 建议     | 根据给出的条件，您认为我应该采取什么样的行动？               |
| 股票投资 | 哪些股票适合短期交易？ |
| 餐饮业营销 | 如何在社交媒体上提高餐厅的知名度？ |
| 科技产品比较 | iPhone 和三星手机的哪些方面有所不同？ |
| 职场沟通 | 如何与上级领导有效地沟通？ |
| 政治新闻 | 美国总统最近签署了什么重要法案？ |
| 外语学习 | 学习英语听力有哪些方法？ |
| 健身锻炼 | 如何让你的腹部肌肉更加明显？ |
| 旅游攻略 | 到日本旅行应该去哪些景点？ |
| 电影推荐 | 最近哪些好看的电影值得观看？ |
| 社交礼仪 | 在聚会上如何举止得体？ |
|自然语言处理|请基于深度学习的方法简述自然语言处理的流程|
|数据分析|如何分析一个数据集，并给出至少3个常见的数据分析方法？|
|机器学习|什么是过拟合？如何避免过拟合？|
|图像处理|请解释卷积神经网络在图像处理中的作用，并结合实际案例说明|
|数据库管理|SQL中什么是外键？请给出一个使用外键的例子|
|计算机视觉|如何判断一张图片是否模糊？请给出至少两种方法，并比较其优缺点|
|推荐系统|请解释协同过滤算法的原理，并举例说明该算法的应用场景|
|时间序列预测|什么是时间序列预测？请给出至少两个时间序列预测模型，并比较其优缺点|
|文本分类|请解释朴素贝叶斯分类算法的原理，并结合实际案例说明其应用|
|神经网络|请简要介绍多层感知机（MLP）的结构和训练过程|
| 关于疫苗接种的统计数据             | 哪个国家疫苗接种率最高？哪个疫苗接种效果最好？有没有出现过疫苗副作用？如果有，是什么副作用？                                                                                |
| 电商行业竞争分析


.3059 27.2949 28.0499 26.916 27.7218 26.6053C27.4063 26.2864 27.0284 26.0362 26.6118 25.8703C26.1915 25.7038 25.7438 25.6174 25.2918 25.6153Z" fill="#C06E0D"></path><path d="M25.2968 25.2094C25.7246 25.2183 26.1444 25.0923 26.4968 24.8494C26.8449 24.619 27.1165 24.29 27.2768 23.9044C27.4295 23.5186 27.4711 23.0977 27.3968 22.6894C27.3069 22.2861 27.104 21.9166 26.8118 21.6244C26.5195 21.3322 26.1501 21.1293 25.7468 21.0394C25.3385 20.9659 24.9178 21.0074 24.5318 21.1594C24.1047 21.3196 23.7414 21.6145 23.4968 21.9994C23.2598 22.3434 23.1342 22.7518 23.1368 23.1694C23.1445 23.724 23.3683 24.2536 23.7604 24.6458C24.1526 25.0379 24.6822 25.2617 25.2368 25.2694L25.2968 25.2094Z" fill="#C06E0D"></path><path d="M34.0022 18.3698H30.2672C29.6939 18.3716 29.132 18.5306 28.6427 18.8294C28.1535 19.1283 27.7555 19.5556 27.4922 20.0648C27.9479 20.3806 28.3314 20.7897 28.6172 21.2648C28.9379 21.8546 29.0983 22.5182 29.0825 23.1893C29.0667 23.8605 28.8752 24.5158 28.5272 25.0898C29.108 25.5688 29.5787 26.1674 29.9072 26.8448C30.2353 27.5281 30.4045 28.2768 30.4022 29.0348V30.8498C30.4039 31.8402 30.1173 32.8097 29.5772 33.6398V37.1048C29.5844 37.1646 29.5844 37.225 29.5772 37.2848C29.856 37.4752 30.1846 37.5795 30.5222 37.5848H30.8372C31.0739 37.5862 31.3085 37.5405 31.5274 37.4504C31.7463 37.3603 31.9451 37.2275 32.1122 37.0598C32.2793 37.2275 32.4781 37.3603 32.6969 37.4504C32.9158 37.5405 33.1505 37.5862 33.3872 37.5848H33.7022C34.181 37.5809 34.6388 37.3879 34.9759 37.048C35.313 36.708 35.5022 36.2486 35.5022 35.7698V30.8048C36.0177 30.5399 36.4501 30.1378 36.7518 29.6429C37.0535 29.148 37.2128 28.5794 37.2122 27.9998V21.5348C37.2122 21.1154 37.1289 20.7001 36.967 20.3131C36.8052 19.9262 36.568 19.5753 36.2693 19.2808C35.9706 18.9863 35.6164 18.7541 35.2272 18.5977C34.838 18.4413 34.4216 18.3639 34.0022 18.3698Z" fill="#C06E0D"></path></g></g><defs><clipPath id="clip0_14632_180315"><rect width="48" height="48" rx="24"


 *); */
TEXT ainc(SB), $0	/* long ainc(long *); */
spinainc:
	LDREX(0,3)	/*	LDREX	0(R0),R3	*/
	ADD	$1,R3
	STREX(3,0,4)	/*	STREX	0(R0),R3,R4	*/
	CMP.S	$0, R4
	BNE	spinainc
	MOVW	$0, R0
	DMB
	MOVW	R3, R0
	RET

TEXT _xdec(SB), $0	/* long _xdec(long *); */
TEXT adec(SB), $0	/* long adec(long *); */
spinadec:
	LDREX(0,3)	/*	LDREX	0(R0),R3	*/
	SUB	$1,R3
	STREX(3,0,4)	/*	STREX	0(R0),R3,R4	*/
	CMP.S	$0, R4
	BNE	spinadec
	MOVW	$0, R0
	DMB
	MOVW	R3, R0
	RET

TEXT loadlinked(SB), $0	/* long loadlinked(long *); */
	LDREX(0,0)	/*	LDREX	0(R0),R0	*/
	RET

TEXT storecond(SB), $0	/* int storecond(long *, long); */
	MOVW	ov+4(FP), R3
	STREX(3,0,4)	/*	STREX	0(R0),R3,R4	*/
	MOVW	$0, R0
	DMB
	RSB	$1, R4, R0
	RET


set;

  @override
  Map<String, dynamic> get queryParameters => {
        'address': address,
        'owner_address': ownerAddress,
        'jetton_address': jettonAddress,
        'limit': limit,
        'offset': offset
      };

  TonCenterV3GetJettonWallets(
      {this.address,
      this.ownerAddress,
      this.jettonAddress,
      this.limit = maximumLimit,
      this.offset});
  @override
  String get method => TonCenterV3Methods.jettonWallets.uri;

  @override
  GetJettonWalletResponse onResonse(Map<String, dynamic> result) {
    return GetJettonWalletResponse.fromJson(result);
  }
}
import 'package:ton_dart/src/address/address.dart';
import 'package:ton_dart/src/boc/boc.dart';
import 'package:ton_dart/src/contracts/contracts.dart';
import 'package:ton_dart/src/dict/dictionary.dart';
import 'package:ton_dart/src/models/models/state_init.dart';

class OrderContractState extends ContractState {
  final TonAddress multisig;
  final BigInt orderSeqno;
  final int? threshold;
  final bool? executed;
  final List<TonAddress> signers;
  final BigInt? approvals;
  final int? approvalsNum;
  final BigInt? expirationDate;
  final Cell? order;

  factory OrderContractState.deserialize(Slice slice) {
    final multisig = slice.loadAddress();
    final BigInt orderSeqno = slice.loadUint256();
    final threshold = slice.loadUint8();
    final executed = slice.loadBoolean();
    final signers = Dictionary.loadDirect<int, TonAddress>(
            key: DictionaryKey.uintCodec(8),
            value: DictionaryValue.addressCodec(),
            slice: slice.loadRef().beginParse())
        .asMap
        .values
        .toList();
    final BigInt approvalsMask = slice.loadUint256();
    final int approvalsNum = slice.loadUint8();
    final BigInt expirationDate = slice.loadUintBig(48);
    final order = slice.loadRef();
    return OrderContractState(
        multisig: multisig,
        orderSeqno: orderSeqno,
        threshold: threshold,
        executed: executed,
        signers: signers,
        approvals: approvalsMask,
        approvalsNum: approvalsNum,
        expirationDate: expirationDate,
        order: order);
  }

  OrderContractState({
    required this.multisig,
    required this.orderSeqno,
    this.threshold,
    this.executed,
    List<TonAddress> signers = const [],
    this.approvals,
    this.approvalsNum,
    this.expirationDate,
    this.order,
  }) : signers = List<TonAddress>.unmodifiable(signers);

  @override
  StateInit initialState() {
    return StateInit(
        code: Cell.fromHex(MultiOwnerContractConst.orderHashCode),
        data: initialData());
  }

  @override
  Cell initialData() {
    return beginCell()
        .storeAddress(multisig)
        .storeUint256(orderSeqno)
        .endCell();
  }

  Map<String, dynamic> toJson() {
    return {
      'multisig': multisig.toFriendlyAddress(),
      'orderSeqno': orderSeqno.toString(),
      'threshold': threshold,
      'executed': executed,
      'signers': signers.map((e) => e.toFriendlyAddress()).toList(),
      'approvals': approvals,
      'approvalsNum': approvalsNum,
      'expirationDate': expirationDate,
      'order': order?.toBase64()
    };
  }
}
import 'package:ton_dart/src/contracts/core/core.dart';
import 'package:ton_dart/src/contracts/wal


 vUv;",

			"void main() {",

				"vUv = vec2( uv.x, 1.0 - uv.y );",
				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",

			"}"

		].join("\n"),

		fragmentShader: [

			"uniform vec2 center;",
			"uniform float angle;",
			"uniform float scale;",
			"uniform vec2 tSize;",

			"uniform sampler2D tDiffuse;",

			"varying vec2 vUv;",

			"float pattern() {",

				"float s = sin( angle ), c = cos( angle );",

				"vec2 tex = vUv * tSize - center;",
				"vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * scale;",

				"return ( sin( point.x ) * sin( point.y ) ) * 4.0;",

			"}",

			"void main() {",

				"vec4 color = texture2D( tDiffuse, vUv );",

				"float average = ( color.r + color.g + color.b ) / 3.0;",

				"gl_FragColor = vec4( vec3( average * 10.0 - 5.0 + pattern() ), color.a );",

			"}"

		].join("\n")

	},

	/* ------------------------------------------------------------------------------------------------
	//	Vignette shader
	//	- based on PaintEffect postprocess from ro.me
	//		http://code.google.com/p/3-dreams-of-black/source/browse/deploy/js/effects/PaintEffect.js
	 ------------------------------------------------------------------------------------------------ */

	'vignette': {

		uniforms: {

			tDiffuse: { type: "t", value: 0, texture: null },
			offset:   { type: "f", value: 1.0 },
			darkness: { type: "f", value: 1.0 }

		},

		vertexShader: [

			"varying vec2 vUv;",

			"void main() {",

				"vUv = vec2( uv.x, 1.0 - uv.y );",
				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",

			"}"

		].join("\n"),

		fragmentShader: [

			"uniform float offset;",
			"uniform float darkness;",

			"uniform sampler2D tDiffuse;",

			"varying vec2 vUv;",

			"void main() {",

				// Eskil's vignette

				"vec4 texel = texture2D( tDiffuse, vUv );",
				"vec2 uv = ( vUv - vec2( 0.5 ) ) * vec2( offset );",
				"gl_FragColor = vec4( mix( texel.rgb, vec3( 1.0 - darkness ), dot( uv, uv ) ), texel.a );",

				/*
				// alternative version from glfx.js
				// this one makes more "dusty" look (as opposed to "burned")

				"vec4 color = texture2D( tDiffuse, vUv );",
				"float dist = distance( vUv, vec2( 0.5 ) );",
				"color.rgb *= smoothstep( 0.8, offset * 0.799, dist *( darkness + offset ) );",
				"gl_FragColor = color;",
				*/

			"}"

		].join("\n")

	},

	/* -------------------------------------------------------------------------
	//	Bleach bypass shader [http://en.wikipedia.org/wiki/Bleach_bypass]
	//	- based on Nvidia example
	//		http://developer.download.nvidia.com/shaderlibrary/webpages/shader_library.html#post_bleach_bypass
	 ------------------------------------------------------------------------- */

	'bleachbypass': {

		uniforms: {

			tDiffuse: { type: "t", value: 0, texture: null },
			opacity:  { type: "f", value


.lang.ref.Reference;
import javax.annotation.Nullable;

public class Result_BlindedHopFeaturesDecodeErrorZ extends CommonBase {
	private Result_BlindedHopFeaturesDecodeErrorZ(Object _dummy, long ptr) { super(ptr); }
	protected void finalize() throws Throwable {
		if (ptr != 0) { bindings.CResult_BlindedHopFeaturesDecodeErrorZ_free(ptr); } super.finalize();
	}

	protected void force_free() {
		if (ptr != 0) { bindings.CResult_BlindedHopFeaturesDecodeErrorZ_free(ptr); ptr = 0; }
	}

	static Result_BlindedHopFeaturesDecodeErrorZ constr_from_ptr(long ptr) {
		if (bindings.CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(ptr)) {
			return new Result_BlindedHopFeaturesDecodeErrorZ_OK(null, ptr);
		} else {
			return new Result_BlindedHopFeaturesDecodeErrorZ_Err(null, ptr);
		}
	}
	public static final class Result_BlindedHopFeaturesDecodeErrorZ_OK extends Result_BlindedHopFeaturesDecodeErrorZ {
		public final BlindedHopFeatures res;
		private Result_BlindedHopFeaturesDecodeErrorZ_OK(Object _dummy, long ptr) {
			super(_dummy, ptr);
			long res = bindings.CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(ptr);
			org.ldk.structs.BlindedHopFeatures res_hu_conv = null; if (res < 0 || res > 4096) { res_hu_conv = new org.ldk.structs.BlindedHopFeatures(null, res); }
			if (res_hu_conv != null) { res_hu_conv.ptrs_to.add(this); };
			this.res = res_hu_conv;
		}
	}

	public static final class Result_BlindedHopFeaturesDecodeErrorZ_Err extends Result_BlindedHopFeaturesDecodeErrorZ {
		public final DecodeError err;
		private Result_BlindedHopFeaturesDecodeErrorZ_Err(Object _dummy, long ptr) {
			super(_dummy, ptr);
			long err = bindings.CResult_BlindedHopFeaturesDecodeErrorZ_get_err(ptr);
			org.ldk.structs.DecodeError err_hu_conv = org.ldk.structs.DecodeError.constr_from_ptr(err);
			if (err_hu_conv != null) { err_hu_conv.ptrs_to.add(this); };
			this.err = err_hu_conv;
		}
	}

	/**
	 * Creates a new CResult_BlindedHopFeaturesDecodeErrorZ in the success state.
	 */
	public static Result_BlindedHopFeaturesDecodeErrorZ ok(org.ldk.structs.BlindedHopFeatures o) {
		long ret = bindings.CResult_BlindedHopFeaturesDecodeErrorZ_ok(o.ptr);
		Reference.reachabilityFence(o);
		if (ret >= 0 && ret <= 4096) { return null; }
		Result_BlindedHopFeaturesDecodeErrorZ ret_hu_conv = Result_BlindedHopFeaturesDecodeErrorZ.constr_from_ptr(ret);
		return ret_hu_conv;
	}

	/**
	 * Creates a new CResult_BlindedHopFeaturesDecodeErrorZ in the error state.
	 */
	public static Result_BlindedHopFeaturesDecodeErrorZ err(org.ldk.structs.DecodeError e) {
		long ret = bindings.CResult_BlindedHopFeaturesDecodeErrorZ_err(e.ptr);
		Reference.reachabilityFence(e);
		if (ret >= 0 && ret <= 4096) { return null; }
		Result_BlindedHopFeaturesDecodeErrorZ ret_hu_conv = Result_BlindedHopFeaturesDecodeErrorZ.constr_from_ptr(ret);
		return ret_hu_conv;
	}

	/**
	 * Checks if the given object is currently in the success state
	 */
	publ


ptcProfile?.Values;
            if (iptcValues != null)
            {
                foreach (var entry in iptcValues)
                {
                    if (entry.Tag > IptcTag.Unknown)
                    {
                        yield return new ImageMetadataEntry(entry.Tag.ToString(), entry.Value, ImageMetadataProfile.Iptc);
                    }
                }
            }

            var exifValues = metadata.ExifProfile?.Values;
            if (exifValues != null && exifValues.Count > 0)
            {
                foreach (var entry in exifValues)
                {
                    if (entry.DataType > ExifDataType.Unknown)
                    {
                        var value = entry.GetValue();

                        if (value != null)
                        {
                            var valueString = value.GetType().IsArray
                                ? string.Join(", ", (value as IEnumerable).Cast<object>().ToArray())
                                : value.ToString();

                            yield return new ImageMetadataEntry(entry.Tag.ToString(), valueString, ImageMetadataProfile.Exif);
                        }
                    }
                }
            }
        }
    }
}


ecified by:
getId in interface Sincronizavel

getIdExterna

public java.lang.String getIdExterna()

Specified by:
getIdExterna in interface Sincronizavel

setIdExterna

public void setIdExterna(java.lang.String idExterna)

Specified by:
setIdExterna in interface Sincronizavel

getIdInicial

public java.lang.Long getIdInicial()

Specified by:
getIdInicial in interface Sincronizavel

setIdInicial

public void setIdInicial(java.lang.Long idInicial)

Specified by:
setIdInicial in interface Sincroniz


rtion_sort(data: &mut [i32]) {
    for sorted in 0..data.len() {
        let min = (sorted..data.len()).min_by_key(|&i| &data[i]).unwrap();
        data.swap(sorted, min);
    }
}

pub fn insertion_sort_fast(data: &mut [i32]) {
    unsafe {
        for sorted in 0..data.len() {
            let min = (sorted..data.len())
                .min_by_key(|&i| data.get_unchecked(i))
                .unwrap();
            std::ptr::swap(data.get_unchecked_mut(sorted), data.get_unchecked_mut(min));
        }
    }
}
```

性能有3倍左右的差距

```
insertions sort          time:   [551.79 us 553.24 us 555.71 us]
insertions sort (fast)   time:   [187.75 us 188.15 us 188.84 us]
```

很奇怪。于是很多人给他建议。

换种写法，跟unsafe差不多快。

```
pub fn insertion_sort(data: &mut [i32]) {
    for sorted in 0..data.len() {
        let min = data
            .iter()
            .enumerate().skip(sorted)
            .min_by_key(|(i, e)| *e)
            .unwrap()
            .0;
        data.swap(sorted, min);
    }
}
```

打开 `-C opt-level=z` 编译标志，按下面方式写：

```
pub fn insertion_sort_fast(data: &mut [i32]) {
    let mut data = data;
    while data.len() > 1 {
        let (head, tail) = data.split_first_mut().unwrap();
        let tailmin = tail.iter_mut().min().unwrap();
        if head > tailmin {
            std::mem::swap(head, tailmin);
        }
        data = tail;
    }
}
```

还有一种写法：

```
pub fn insertion_sort_iter(data: &mut [i32]) {
    for sorted in 0..data.len() {
        let min = data[sorted..].iter().enumerate().min_by_key(|&(_, e)| e).unwrap().0;
        data.swap(sorted, min + sorted);
    }
}

insertions sort (fast) time:  [187.05 us 187.37 us 187.84 us]
insertions sort (iter) time:  [186.87 us 187.30 us 188.00 us]

```

跟 unsafe 差不多。

[Read More](https://www.reddit.com/r/rust/comments/bsvup3/300_performance_


 authors. All rights reserved.
// Use of this source code is governed by a MIT-style license that can be
// found in the LICENSE file.

package ie

// NewRequestedAccessAvailabilityInformation creates a new RequestedAccessAvailabilityInformation IE.
func NewRequestedAccessAvailabilityInformation(rrca uint8) *IE {
	return newUint8ValIE(RequestedAccessAvailabilityInformation, rrca&0x01)
}

// RequestedAccessAvailabilityInformation returns RequestedAccessAvailabilityInformation in uint8 if the type of IE matches.
func (i *IE) RequestedAccessAvailabilityInformation() (uint8, error) {
	switch i.Type {
	case RequestedAccessAvailabilityInformation:
		return i.ValueAsUint8()
	case AccessAvailabilityControlInformation:
		ies, err := i.AccessAvailabilityControlInformation()
		if err != nil {
			return 0, err
		}

		for _, x := range ies {
			if x.Type == RequestedAccessAvailabilityInformation {
				return x.RequestedAccessAvailabilityInformation()
			}
		}
		return 0, ErrIENotFound
	default:
		return 0, &InvalidTypeError{Type: i.Type}
	}
}

// HasRRCA reports whether an IE has RRCA bit.
func (i *IE) HasRRCA() bool {
	v, err := i.RequestedAccessAvailabilityInformation()
	if err != nil {
		return false
	}

	return has1stBit(v)
}
// Copyright 2019-2024 go-pfcp authors. All rights reserved.
// Use of this source code is governed by a MIT-style license that can be
// found in the LICENSE file.

package ie

import (
	"io"
	"time"
)

// NewDownlinkDataNotificationDelay creates a new DownlinkDataNotificationDelay IE.
func NewDownlinkDataNotificationDelay(delay time.Duration) *IE {
	// TS29.244 8.2.28 Downlink Data Notification Delay
	// Delay Value in integer multiples of 50 millisecs, or zero
	return newUint8ValIE(DownlinkDataNotificationDelay, uint8(delay/50000000))
}

// DownlinkDataNotificationDelay returns DownlinkDataNotificationDelay in time.Duration if the type of IE matches.
func (i *IE) DownlinkDataNotificationDelay() (time.Duration, error) {
	if len(i.Payload) < 1 {
		return 0, io.ErrUnexpectedEOF
	}

	switch i.Type {
	case DownlinkDataNotificationDelay:
		return time.Duration(int64(i.Payload[0]) * 50000000), nil
	case CreateBAR:
		ies, err := i.CreateBAR()
		if err != nil {
			return 0, err
		}
		for _, x := range ies {
			if x.Type == DownlinkDataNotificationDelay {
				return x.DownlinkDataNotificationDelay()
			}
		}
		return 0, ErrIENotFound
	case UpdateBARWithinSessionReportResponse,
		UpdateBARWithinSessionModificationRequest:
		ies, err := i.UpdateBAR()
		if err != nil {
			return 0, err
		}
		for _, x := range ies {
			if x.Type == DownlinkDataNotificationDelay {
				return x.DownlinkDataNotificationDelay()
			}
		}
		return 0, ErrIENotFound
	default:
		return 0, &InvalidTypeError{Type: i.Type}
	}
}
// Copyright 2019-2024 go-pfcp authors. All rights reserved.
// Use of this source code is governed by a MIT-style license that can be
// found in the LICENSE file.

package ie

// NewMeasurementInformation creates a new MeasurementInformation IE.
func NewMeasurementInformation(flags uint8) *IE {
	return newUint8ValIE(MeasurementInformation, flags)
}

// MeasurementInformation ret


 return args.Length; } }

    static void Main()
    {
        System.Console.WriteLine(new Test()[1, 2]);
    }
}
";
            var verifier = CompileAndVerify(text, expectedOutput: @"2");

            verifier.VerifyIL("Test.Main", @"
{
  // Code size       40 (0x28)
  .maxstack  5
  IL_0000:  newobj     ""Test..ctor()""
  IL_0005:  ldc.i4.2
  IL_0006:  newarr     ""object""
  IL_000b:  dup
  IL_000c:  ldc.i4.0
  IL_000d:  ldc.i4.1
  IL_000e:  box        ""int""
  IL_0013:  stelem.ref
  IL_0014:  dup
  IL_0015:  ldc.i4.1
  IL_0016:  ldc.i4.2
  IL_0017:  box        ""int""
  IL_001c:  stelem.ref
  IL_001d:  call       ""int Test.this[params object[]].get""
  IL_0022:  call       ""void System.Console.WriteLine(int)""
  IL_0027:  ret
}
");
        }

        [Fact]
        public void IndexerOverrideNotAllAccessors_DefaultParameterValues()
        {
            var text = @"
using System;

class Base
{
    public virtual int this[int x, int y = 1]
    {
        get
        {
            Console.WriteLine(""Base.get y: "" + y);
            return y;
        }
        set { Console.WriteLine(""Base.set y: "" + y); }
    }
}

class Override : Base
{
    public override int this[int x, int y = 2]
    {
        set { Console.WriteLine(""Override.set y: "" + y); }
    }
}

class Program
{
    static void Main()
    {
        Base b = new Base();
        _ = b[0];
        b[0] = 0;

        Override o = new Override();
        _ = o[0];
        o[0] = 0;
        o[0] += 0;
    }
}
";
            CompileAndVerify(text, expectedOutput:
@"Base.get y: 1
Base.set y: 1
Base.get y: 1
Override.set y: 2
Base.get y: 1
Override.set y: 1
");
        }

        #endregion Lowering

        [Fact]
        [WorkItem("https://github.com/dotnet/roslyn/issues/75032")]
        public void MissingDefaultMemberAttribute_01()
        {
            var text1 = @"
public interface I1
{
    public I1 this[I1 args] { get; }
}
";
            var comp1 = CreateCompilation(text1);
            comp1.MakeMemberMissing(WellKnownMember.System_Reflection_DefaultMemberAttribute__ctor);

            comp1.VerifyDiagnostics(
                // (4,15): error CS0656: Missing compiler required member 'System.Reflection.DefaultMemberAttribute..ctor'
                //     public I1 this[I1 args] { get; }
                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "this").WithArguments("System.Reflection.DefaultMemberAttribute", ".ctor").WithLocation(4, 15)
                );

            comp1 = CreateCompilation(text1);
            comp1.MakeTypeMissing(WellKnown


from nba_api.stats.endpoints._base import Endpoint
from nba_api.stats.library.http import NBAStatsHTTP
from nba_api.stats.library.parameters import LeagueID, SeasonYear, SeasonType

class GLAlumBoxScoreSimilarityScore(Endpoint):
    endpoint = "glalumboxscoresimilarityscore"
    expected_data = {
        "GLeagueAlumBoxScoreSimilarityScores": [
            "PERSON_2_ID",
            "PERSON_2",
            "TEAM_ID",
            "SIMILARITY_SCORE",
        ]
    }

    nba_response = None
    data_sets = None
    player_stats = None
    team_stats = None
    headers = None

    def __init__(
        self,
        person2_id,
        person1_id,
        person1_league_id=LeagueID.default,
        person1_season_year=SeasonYear.default,
        person1_season_type=SeasonType.default,
        person2_league_id=LeagueID.default,
        person2_season_year=SeasonYear.default,
        person2_season_type=SeasonType.default,
        proxy=None,
        headers=None,
        timeout=30,
        get_request=True,
    ):
        self.proxy = proxy
        if headers is not None:
            self.headers = headers
        self.timeout = timeout
        self.parameters = {
            "Person2Id": person2_id,
            "Person1Id": person1_id,
            "Person1LeagueId": person1_league_id,
            "Person1Season": person1_season_year,
            "Person1SeasonType": person1_season_type,
            "Person2LeagueId": person2_league_id,
            "Person2Season": person2_season_year,
            "Person2SeasonType": person2_season_type,
        }
        if get_request:
            self.get_request()

    def get_request(self):
        self.nba_response = NBAStatsHTTP().send_api_request(
            endpoint=self.endpoint,
            parameters=self.parameters,
            proxy=self.proxy,
            headers=self.headers,
            timeout=self.timeout,
        )
        self.load_response()

    def load_response(self):
        data_sets = self.nba_response.get_data_sets()
        self.data_sets = [
            Endpoint.DataSet(data=data_set)
            for data_set_name, data_set in data_sets.items()
        ]
        self.g_league_alum_box_score_similarity_scores = Endpoint.DataSet(
            data=data_sets["GLeagueAlumBoxScoreSimilarityScores"]
        )


gh = true),
                SearchAppBean(2,"${AppNavRoute.Scan.label} 扫码 指尖工大 CAS统一认证登录", { Scan(navController) }, AppNavRoute.Scan.route,isHigh = true),
                SearchAppBean(3,"寝室电费 缴费 慧新易校" , { Electric(vm, false, vmUI,hazeState) },isHigh = true),
                SearchAppBean(4,"校园网 慧新易校 缴费" , { LoginWeb(vmUI, false, vm,hazeState) },isHigh = true),
                SearchAppBean(5,"教育邮箱 校园邮箱" , { Mail(vm,hazeState) }),
                SearchAppBean(6,"${AppNavRoute.Exam.label}" , { Exam(ifSaved,navController) },AppNavRoute.Exam.route),
                SearchAppBean(7,"${AppNavRoute.Grade.label}", { Grade(ifSaved,navController) }, AppNavRoute.Grade.receiveRoute()),
                SearchAppBean(8,"${AppNavRoute.FailRate.label}", { FailRate(navController) },AppNavRoute.FailRate.route),
                SearchAppBean(9,"${AppNavRoute.TotalCourse.label} 教材 课本", { CourseTotal(ifSaved,navController) },AppNavRoute.TotalCourse.receiveRoute()),
                SearchAppBean(10,"${AppNavRoute.Person.label}", { PersonUI(navController) },AppNavRoute.Person.route),
                SearchAppBean(11,"${AppNavRoute.WebNavigation.label} 实验室 收纳", { WebUI(navController) }, AppNavRoute.WebNavigation.route),
                SearchAppBean(12,"洗浴 洗澡 呱呱物联 慧新易校 缴费", { Shower(vm,hazeState) }),
                SearchAppBean(13,"${AppNavRoute.SelectCourse.label}", { SelectCourse(ifSaved, navController) },AppNavRoute.SelectCourse.route),
                SearchAppBean(14,"${AppNavRoute.DormitoryScore.label} 寝室卫生评分 寝室卫生分数", { DormitoryScoreXuanCheng(navController) }, AppNavRoute.DormitoryScore.route),
                SearchAppBean(15,"${AppNavRoute.Notifications.label} 通知中心 收纳", { NotificationsCenter(navController) },AppNavRoute.Notifications.route),
                SearchAppBean(16,"${AppNavRoute.Survey.label} 教师评教 教师教评", { Survey(ifSaved,navController) },AppNavRoute.Survey.route),
                SearchAppBean(17,"${AppNavRoute.News.label} 新闻 教务处", { News(navController) },AppNavRoute.News.route),
                SearchAppBean(18,"${AppNavRoute.Program.label}完成情况", { Program(ifSaved,navController) },AppNavRoute.Program.receiveRoute()),
                SearchAppBean(19,"${AppNavRoute.Library.label} 座位预约 借阅", { LibraryItem(navController ) },AppNavRoute.Library.route),
                SearchAppBean(20,"${AppNavRoute.Bus.label}", { SchoolBus(navController ) }, AppNavRoute.Bus.route),
                SearchAppBean(21,"报修 维修 后勤", { Repair(hazeState) }),
                SearchAppBean(22,"${AppNavRoute.NextCourse.label}", { NextCourse(ifSaved,navController ) },AppNavRoute.NextCourse.receiveRoute()),
                SearchAppBean(23,"饮水机 热水机 趣智校园", { HotWater() }),
                SearchAppBean(24,"${AppNavRoute.Classroom.label} 空教室", { Classroom(


'repeat': 'n',
        'type': 'rangenumber'
    }]
}, {
    'n': 'SIN',
    't': 0,
    'd': '给定角度（以弧度表示），返回其正弦值。',
    'a': '给定角度（以弧度表示）',
    'm': [1, 1],
    'p': [{
        'name': '角度',
        'detail': '要返回其正弦值的角度，以弧度表示。',
        'example': 'PI()',
        'require': 'm',
        'repeat': 'n',
        'type': 'rangenumber'
    }]
}, {
    'n': 'SINH',
    't': 0,
    'd': '返回给定实数的双曲正弦值。',
    'a': '返回给定实数的双曲正弦值。',
    'm': [1, 1],
    'p': [{
        'name': '值',
        'detail': '要计算其双曲正弦值的实数值。',
        'example': 'A2',
        'require': 'm',
        'repeat': 'n',
        'type': 'rangenumber'
    }]
}, {
    'n': 'SQRT',
    't': 0,
    'd': '返回一个正数的正平方根。',
    'a': '返回一个正数的正平方根。',
    'm': [1, 1],
    'p': [{
        'name': '值',
        'detail': '要计算其正平方根的数值。\n\n值必须为正数；如果为负，SQRT 将返回 #NUM! 错误。',
        'example': '9',
        'require': 'm',
        'repeat': 'n',
        'type': 'rangenumber'
    }]
}, {
    'n': 'SQRTPI',
    't': 0,
    'd': '返回 PI 与给定正数乘积的正平方根。',
    'a': '返回 PI 与给定正数乘积的正平方根。',
    'm': [1, 1],
    'p': [{
        'name': '值',
        'detail': '要将其与 PI 相乘并返回该乘积的平方根的数值\n\n值必须为正数；如果为负数，SQRTPI 将返回 #NUM! 错误。',
        'example': '9',
        'require': 'm',
        'repeat': 'n',
        'type': 'rangenumber'
    }]
}, {
    'n': 'GAMMALN',
    't': 1,
    'd': '返回指定伽玛函数的以 e（欧拉数）为底的对数。',
    'a': '返回指定伽玛函数的以 e（欧拉数）为底的对数。',
    'm': [1, 1],
    'p': [{
        'name': '值',
        'detail': '伽玛函数的输入值。返回的将是伽玛 (值) 的自然对数。\n\n值必须为正数。',
        'example': '4',
        'require': 'm',
        'repeat': 'n',
        'type': 'rangenumber'
    }]
}, {
    'n': 'COS',
    't': 0,
    'd': '返回给定角度的余弦值（角度以弧度表示）。',
    'a': '返回给定角度的余弦值（角度以弧度表示）。',
    'm': [1, 1],
    'p': [{
        'name': '角度',
        'detail': '要取其余弦值的角度，以弧度表示。',


();

    // Check for uniqueness.
    let mut tmp = axes.clone();
    tmp.slice_mut().sort_unstable();
    for i in 0..(tmp.ndim() - 1) {
        assert_ne!(tmp[i], tmp[i + 1], "Axes must be unique.");
    }

    Axes(axes)
}

impl<D, X, E> IntoAxesFor<D> for Axes<X>
where
    D: Dimension + SubDim<X, Out = E>,
    X: Dimension,
    E: Dimension,
{
    type Axes = X;
    type IntoOthers = AxesExcept<X>;

    /// The axes that result from calling `.into_axes_for()` on the return
    /// value are guaranteed to be in order.
    fn into_others(self) -> AxesExcept<X> {
        AxesExcept(self.0)
    }

    fn into_axes_for(self, for_ndim: usize) -> AxesFor<D, X> {
        AxesFor::from_axes(self, for_ndim)
    }

    /// The "other" axes are guaranteed to be in order.
    fn into_these_and_other_axes_for(self, for_ndim: usize) -> (AxesFor<D, X>, AxesFor<D, E>) {
        AxesFor::these_and_others_from_axes(self, for_ndim)
    }

    fn into_axes_mask(self, for_ndim: usize) -> AxesMask<D, X> {
        let mut mask = D::zeros(for_ndim);
        self.0.visitv(|ax| mask[ax] = 1);
        AxesMask {
            mask,
            num_true: PhantomData,
        }
    }
}

/// A list of unique axes that should be excluded.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct AxesExcept<E: Dimension>(E);

/// Creates a new list of unique axes that should be excluded.
///
/// **Panics** if the axes are not unique.
pub fn axes_except<T>(axes: T) -> AxesExcept<T::Dim>
where
    T: IntoDimension,
{
    let axes = axes.into_dimension();

    // Check for uniqueness.
    let mut tmp = axes.clone();
    tmp.slice_mut().sort_unstable();
    for i in 0..(tmp.ndim() - 1) {
        assert_ne!(tmp[i], tmp[i + 1], "Axes must be unique.");
    }

    AxesExcept(axes)
}

impl<D, X, E> IntoAxesFor<D> for AxesExcept<E>
where
    D: Dimension + SubDim<E, Out = X>,
    X: Dimension,
    E: Dimension,
{
    type Axes = X;
    type IntoOthers = Axes<E>;

    fn into_others(self) -> Axes<E> {
        Axes(self.0)
    }

    /// The resulting axes are guaranteed to be in order.
    fn into_axes_for(self, for_ndim: usize) -> AxesFor<D, X> {
        AxesFor::others_from_axes(&Axes(self.0), for_ndim)
    }

    /// The "these" axes are guaranteed to be in order.
    fn into_these_and_other_axes_for(self, for_ndim: usize) -> (AxesFor<D, X>, AxesFor<D, E>) {
        let (others, these) = AxesFor::these_and_others_from_axes(Axes(self.0), for_ndim);
        (these, others)
    }

    fn into_axes_mask(self, for_ndim: usize) -> AxesMask<D, X> {
        let mut mask = D::zeros(for_ndim);
        mask.map_inplace(|m| *m = 1);
        self.0.visitv(|ax|


(this);

		for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {

			std::shared_ptr<TriggerBox> tb = std::dynamic_pointer_cast<TriggerBox> (*i);
			if (tb) {
				_triggerbox = tb;
			}

			if (*i == _meter) {
				continue;
			}
			ProcessorList::iterator check = find (to_skip.begin(), to_skip.end(), *i);
			if (check != to_skip.end()) {
				continue;
			}

			std::shared_ptr<PluginInsert> pi;

			if ((pi = std::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
				PluginManager::instance().stats_use_plugin (pi->plugin()->get_info());
				pi->set_strict_io (_strict_io);
			}

			if (*i == _amp) {
				/* Ensure that only one amp is in the list at any time */
				ProcessorList::iterator check = find (_processors.begin(), _processors.end(), *i);
				if (check != _processors.end()) {
					if (before == _amp) {
						/* Already in position; all is well */
						continue;
					} else {
						_processors.erase (check);
					}
				}
			}

			assert (find (_processors.begin(), _processors.end(), *i) == _processors.end ());

			_processors.insert (loc, *i);
			(*i)->set_owner (this);

			{
				if (configure_processors_unlocked (err, &lm)) {
					pstate.restore ();
					configure_processors_unlocked (0, &lm); // it worked before we tried to add it ...
					return -1;
				}
			}

			if (pi && pi->has_sidechain ()) {
				pi->update_sidechain_name ();
				pi->sidechain_input ()->changed.connect_same_thread (*pi, std::bind (&Route::sidechain_change_handler, this, _1, _2));
			}

			if ((*i)->active()) {
				// emit ActiveChanged() and latency_changed() if needed
				(*i)->activate ();
			}

			(*i)->ActiveChanged.connect_same_thread (*this, std::bind (&Session::queue_latency_recompute, &_session));

			std::shared_ptr<Send> send;
			if ((send = std::dynamic_pointer_cast<Send> (*i))) {
				send->SelfDestruct.connect_same_thread (**i,
						std::bind (&Route::processor_selfdestruct, this, std::weak_ptr<Processor> (*i)));
				if (send->output()) {
					send->output()->changed.connect_same_thread (**i, std::bind (&Route::output_change_handler, this, _1, _2));
				}
			}

			if (std::dynamic_pointer_cast<InternalSend>(*i)) {
				routing_processor_added = true;
			}
		}

		for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
			std::shared_ptr<PluginInsert> pi;

			if ((pi = std::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
				if (pi->has_no_inputs ()) {
					_have_internal_generator = true;
					break;
				}
			}
		}
	}

	reset_instrument_info ();
	processors_changed (RouteProcessorChange (routing_processor_added ? RouteProcessorChange::SendReturnChange : RouteProcessorChange::GeneralChange, false)); /* EMIT SIGNAL */
	set_processor_positions ();

	if (fanout && fanout->configured ()
			&& fanout->output_streams().n_audio() > 2
			&& std::dynamic_pointer_cast<PluginInsert> (the_instrument ()) == fanout) {
		/* This adds new tracks or busses, and changes connections.
		 * This cannot be done here,


method"""
        original_type = x.dtype
        output = self.norm(self.cast(x, self.compute_type), self.weight)[0]
        output = self.cast(output, original_type)
        return output

    def shard(self, strategy):
        """shard method"""
        if not strategy:
            raise TypeError('The strategy length must bigger than 0! Strategy {} not supported'.format(strategy))

        if strategy[-1] != 1 and ms.get_context('mode') == ms.GRAPH_MODE:
            raise TypeError(
                'The last dim in FusedlayerNorm can not equal to 1! Strategy {} not supported!'.format(strategy))

        self.norm.shard((strategy, (strategy[-1],)))

def get_norm(config):
    r"""
    Get normalization layer.

    Args:
        config: The config of the model.

    Returns:
        callable, the normalization layer.
    """
    if config.normalization == "LayerNorm":
        return LayerNorm(
            config.hidden_size,
            eps=config.layernorm_epsilon,
            param_init_type=config.layernorm_compute_type)
    if config.normalization == "FusedLayerNorm":
        return FusedLayerNorm(
            config.hidden_size,
            eps=config.layernorm_epsilon,
            param_init_type=config.layernorm_compute_type)
    if config.normalization == "RMSNorm":
        return RMSNorm(
            dim=config.hidden_size,
            eps=config.layernorm_epsilon,
            param_init_type=config.layernorm_compute_type)
    if config.normalization == "FusedRMSNorm":
        return FusedRMSNorm(
            dim=config.hidden_size,
            eps=config.layernorm_epsilon,
            param_init_type=config.layernorm_compute_type)

    raise Exception(f"unsupported norm type '{config.normalization}'.")


.a).toBe(2)
    expect(tupleRef.value[3]()).toBe(0)
    tupleRef.value[4].value++
    expect(tupleRef.value[4].value).toBe(1)
  })

  it('should keep symbols', () => {
    const customSymbol = Symbol()
    const obj = {
      [Symbol.asyncIterator]: ref(1),
      [Symbol.hasInstance]: { a: ref('a') },
      [Symbol.isConcatSpreadable]: { b: ref(true) },
      [Symbol.iterator]: [ref(1)],
      [Symbol.match]: new Set<Ref<number>>(),
      [Symbol.matchAll]: new Map<number, Ref<string>>(),
      [Symbol.replace]: { arr: [ref('a')] },
      [Symbol.search]: { set: new Set<Ref<number>>() },
      [Symbol.species]: { map: new Map<number, Ref<string>>() },
      [Symbol.split]: new WeakSet<Ref<boolean>>(),
      [Symbol.toPrimitive]: new WeakMap<Ref<boolean>, string>(),
      [Symbol.toStringTag]: { weakSet: new WeakSet<Ref<boolean>>() },
      [Symbol.unscopables]: { weakMap: new WeakMap<Ref<boolean>, string>() },
      [customSymbol]: { arr: [ref(1)] },
    }

    const objRef = ref(obj)

    const keys: (keyof typeof obj)[] = [
      Symbol.asyncIterator,
      Symbol.hasInstance,
      Symbol.isConcatSpreadable,
      Symbol.iterator,
      Symbol.match,
      Symbol.matchAll,
      Symbol.replace,
      Symbol.search,
      Symbol.species,
      Symbol.split,
      Symbol.toPrimitive,
      Symbol.toStringTag,
      Symbol.unscopables,
      customSymbol,
    ]

    keys.forEach((key) => {
      expect(objRef.value[key]).toStrictEqual(obj[key])
    })
  })

  test('unref', () => {
    expect(unref(1)).toBe(1)
    expect(unref(ref(1))).toBe(1)
  })

  test('shallowRef', () => {
    const sref = shallowRef({ a: 1 })
    expect(isReactive(sref.value)).toBe(false)

    let dummy
    watchEffect(
      () => {
        dummy = sref.value.a
      },
      { flush: 'sync' }
    )
    expect(dummy).toBe(1)

    sref.value = { a: 2 }
    expect(isReactive(sref.value)).toBe(false)
    expect(dummy).toBe(2)

    sref.value.a = 3
    expect(dummy).toBe(2)
  })

  test('shallowRef force trigger', () => {
    const sref = shallowRef({ a: 1 })
    let dummy
    watchEffect(
      () => {
        dummy = sref.value.a
      },
      { flush: 'sync' }
    )
    expect(dummy).toBe(1)

    sref.value.a = 2
    expect(dummy).toBe(1) // should not trigger yet

    // force trigger
    triggerRef(sref)
    expect(dummy).toBe(2)
  })

  test('shallowRef noop when assignment is the same', () => {
    const sref = shallowRef(1)
    let calls = 0
    watchEffect(
      () => {
        sref.value
        calls++
      },
      { flush: 'sync' }
    )
    expect(calls).toBe(1)

    sref.value = 2
    expect(calls).toBe(2)

    sref.value = 2
    expect(calls).toBe(2)
  })

  test('isRef', () => {
    expect(isRef(ref(1))).toBe(true)
    expect(isRef(computed(() => 1))).toBe(true)

    expect(isRef(0)).toBe(false)
    expect(isRef(1)).toBe


FlagsData = null;
    volatile int rangeIndex = 1;
    boolean stopLoop = false;

    private F2CanvasView mCanvasView = null;

    private void startLoop() {
        if (stopLoop) return;
        rangeIndex ++;
        if (mCanvasView != null) {
            mCanvasView.postCanvasDraw();
        }
        mHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                startLoop();
            }
        }, 1000);
    }

    @Override
    public void onCanvasDraw(F2CanvasView canvasView) {
        mCanvasView = canvasView;
        if (mChart == null) {
            mChart = F2Chart.create(canvasView.getContext(), "MKTrendChart", canvasView.getWidth(), canvasView.getHeight());

            mHandler.postDelayed(new Runnable() {
                @Override
                public void run() {
                    startLoop();
                }
            }, 1000);
        }

        mChart.clear();
        mChart.setCanvas(canvasView);
        mChart.padding(0, 0, 0, 0);

        if (mJsonData == null) {
            mJsonData = JSON.parseObject(Utils.loadAssetFile(canvasView.getContext(), "mockData_trendChart.json"));
        }
        JSONArray sourceData = mJsonData.getJSONArray("items");
        List subData = sourceData.subList(0, rangeIndex % sourceData.size());
        mChart.source(JSON.toJSONString(subData));

        try {
            JSONArray timeRange = mJsonData.getJSONArray("timeRange");
            org.json.JSONArray timeRangeCopy = new org.json.JSONArray(timeRange.toJSONString());
            mChart.setScale("date", new F2Chart.ScaleConfigBuilder().type("timeSharing").setOption("timeRange", timeRangeCopy));
        } catch (Exception e) {
            e.printStackTrace();
        }

        F2Chart.ScaleConfigBuilder priceScaleCfg = new F2Chart.ScaleConfigBuilder();
        priceScaleCfg.tickCount(2);
        priceScaleCfg.min(mJsonData.getDouble("min") - 2).max(mJsonData.getDouble("max") + 2);
        mChart.setScale("price", priceScaleCfg);

        mChart.setAxis("date", new F2Chart.AxisConfigBuilder()
                .label(new F2Chart.AxisLabelConfigBuilder().labelMargin(20).labelOffset(4).textColor("#999999").item(mChart, new F2Function() {
                    @Override
                    public F2Config execute(String param) {
                        JSONObject json = JSON.parseObject(param);
                        int index = json.getIntValue("index");
                        if (index == 0) {
                            return new F2Config.Builder().setOption("content", "09:30").build();
                        } else if (index == 1) {
                            return new F2Config.Builder().setOption("content", "11:30/13:00").build();
                        } else if (index == 2){
                            return new F2Config.Builder().setOption("content", "15:00").build();
                        } else {
                            return new F2Config.Builder().setOption("content", "").build();
                        }
                    }
                }))
                .line(new F2Chart.AxisLineConfigBuilder().color("#DDDDDD"))
        );
        mChart.setAxis("price", new F2Chart.AxisConfigBuilder().hidden());

        mChart.line().position("date*price").fixedColor("#528EFF");
        mChart.area().position("date*price").fixedColor("#108EE9");

        JSON


er.
//  Server cannot be running when command is issued.
//-----------------------------------------------------------------------------
CON_COMMAND( maxplayers, "Change the maximum number of players allowed on this server." )
{
	if ( args.ArgC () != 2 )
	{
		ConMsg ("\"maxplayers\" is \"%u\"\n", sv.GetMaxClients() );
		return;
	}

	if ( sv.IsActive() )
	{
		ConMsg( "Cannot change maxplayers while the server is running\n");
		return;
	}

	SetupMaxPlayers( Q_atoi( args[ 1 ] ) );
}

int SV_BuildSendTablesArray( ServerClass *pClasses, SendTable **pTables, int nMaxTables )
{
        int nTables = 0;

        for( ServerClass *pCur=pClasses; pCur; pCur=pCur->m_pNext )
        {
                ErrorIfNot( nTables < nMaxTables, ("SV_BuildSendTablesArray: too many SendTables!") );
                pTables[nTables] = pCur->m_pTable;
                ++nTables;
        }

        return nTables;
}

// Builds an alternate copy of the datatable for any classes that have datatables with props excluded.
void SV_InitSendTables( ServerClass *pClasses )
{
	SendTable *pTables[MAX_DATATABLES];
	int nTables = SV_BuildSendTablesArray( pClasses, pTables, ARRAYSIZE( pTables ) );

	SendTable_Init( pTables, nTables );
}

void SV_TermSendTables( ServerClass *pClasses )
{
	SendTable_Term();
}

//-----------------------------------------------------------------------------
// Purpose: returns which games/mods we're allowed to play
//-----------------------------------------------------------------------------
struct ModDirPermissions_t
{
	int m_iAppID;
	const char *m_pchGameDir;
};

static ModDirPermissions_t g_ModDirPermissions[] =
{
	{ GetAppSteamAppId( k_App_CSS ),        GetAppModName( k_App_CSS ) },
	{ GetAppSteamAppId( k_App_DODS ),       GetAppModName( k_App_DODS ) },
	{ GetAppSteamAppId( k_App_HL2MP ),      GetAppModName( k_App_HL2MP ) },
	{ GetAppSteamAppId( k_App_LOST_COAST ), GetAppModName( k_App_LOST_COAST ) },
	{ GetAppSteamAppId( k_App_HL1DM ),      GetAppModName( k_App_HL1DM ) },
	{ GetAppSteamAppId( k_App_PORTAL ),     GetAppModName( k_App_PORTAL ) },
	{ GetAppSteamAppId( k_App_HL2 ),        GetAppModName( k_App_HL2 ) },
	{ GetAppSteamAppId( k_App_HL2_EP1 ),    GetAppModName( k_App_HL2_EP1 ) },
	{ GetAppSteamAppId( k_App_HL2_EP2 ),    GetAppModName( k_App_HL2_EP2 ) },
	{ GetAppSteamAppId( k_App_TF2 ),        GetAppModName( k_App_TF2 ) },
};

bool ServerDLL_Load( bool bIsServerOnly )
{
	// Load in the game .dll
	LoadEntityDLLs( GetBaseDirectory(), bIsServerOnly );
	return true;
}

void ServerDLL_Unload()
{
	UnloadEntityDLLs();
}

#if !defined(DEDICATED)
#if !defined(_X360)
// Put this function declaration at global scope to avoid the ambiguity of the most vexing parse.
bool CL_IsHL2Demo();
#endif
#endif

//-----------------------------------------------------------------------------
// Purpose: Loads the game .dll
//-----------------------------------------------------------------------------
void SV_Init


    ''' Example '''
    start = time()
    mr = MapReducer(range(N), mapper=mapper_1)
    print '* map '
    print '  List:', list(mr.run())
    ''' approximate running time '''
    timer(mr.started)
    mr = MapReducer(range(N), mapper=mapper_2, reducer=reducer_2, initializer=0)
    print '* map & reduce '
    print '  MR Result  :', mr.run()
    timer(mr.started)
    print '  Validation :', sum([ n**2 for n in range(N) ])
    mr = MapReducer(range(N), mapper=mapper_2, reducer=reducer_2, prefiltering=filter_1, initializer=0)
    print '* pre-filtering, map, reduce '
    print '  MR Result  :', mr.run()
    timer(mr.started)
    print '  Validation :', sum([ n**2 for n in range(N) if n % 2 == 0 ])
    mr = MapReducer(
        xrange(N),
        mapper=mapper_2,
        reducer=reducer_2,
        initializer=0,
        prefiltering=filter_1,
        worker_assign=lambda workers, current_worker_id, item: item % workers == current_worker_id
    )
    print '* pre-filtering, map, reduce with generator input '
    print '  MR Result  :', mr.run()
    timer(mr.started)
    print '  Validation :', sum([ n**2 for n in xrange(N) if n % 2 == 0 ])


 { get; set; }

    /// <summary>
    /// boolean properties decorated with this attribute will have their values set to true if the current principal has the specified permission.
    /// </summary>
    /// <param name="permission">the permission to check for</param>
    /// <param name="isRequired">set to false if a validation error shouldn't be thrown when the current principal doesn't have the specified permission.</param>
    /// <param name="removeFromSchema">set to true if your header is not required but shouldn't be added to body model.</param>
    public HasPermissionAttribute(string permission, bool isRequired = true, bool removeFromSchema = false)
    {
        Permission = permission;
        IsRequired = isRequired;
        RemoveFromSchema = removeFromSchema;
    }
}


ColumnsFile, "#define %s_START\t%d\n", szTable, nColumnCount);
			fprintf(pTablesFile, "#define %s\t%d\n", szTable, nTableCount++);
			strcpy(szLastTable, szTable);
			}
		fprintf(pColumnsFile, "#define %s\t%d\n", szColumn, nColumnCount++);
	}

	/* close out the files */
	fprintf(pStreamsFile, "{-1, -1, -1, -1, -1, -1, -1}\n};\n");
	fprintf(pStreamsFile, "#endif\n");
	fprintf(pColumnsFile, "#define %s_END\t%d\n", szLastTable, nColumnCount - 1);
	fprintf(pColumnsFile, "#define MAX_COLUMN\t%d\n", nColumnCount - 1);
	fprintf(pColumnsFile, "#endif\n");
	fprintf(pTablesFile, "#define PSEUDO_TABLE_START\t%d\n", nTableCount);
	fprintf(pTablesFile, "/* PSEUDO TABLES from here on; used in hierarchies */\n");
	fprintf(pTablesFile, "#define ITEM_BRAND\t%d\n", nTableCount++);
	fprintf(pTablesFile, "#define ITEM_CLASS\t%d\n", nTableCount++);
	fprintf(pTablesFile, "#define ITEM_CATEGORY\t%d\n", nTableCount++);
	fprintf(pTablesFile, "#define DIVISIONS\t%d\n", nTableCount++);
	fprintf(pTablesFile, "#define COMPANY\t%d\n", nTableCount++);
	fprintf(pTablesFile, "#define CONCURRENT_WEB_SITES\t%d\n", nTableCount++);
	fprintf(pTablesFile, "#define ACTIVE_CITIES\t%d\n", nTableCount++);
	fprintf(pTablesFile, "#define ACTIVE_COUNTIES\t%d\n", nTableCount++);
	fprintf(pTablesFile, "#define ACTIVE_STATES\t%d\n", nTableCount);
	fprintf(pTablesFile, "#define MAX_TABLE\t%d\n", nTableCount);
	fprintf(pTablesFile, "#endif\n");

	/* close the files */
	fclose(pStreamsFile);
	fclose(pColumnsFile);
	fclose(pInputFile);
	fclose(pTablesFile);

	exit(0);
}


sound( ecx, edx, filter, index, sprite_channel, sound_entry, sound_entry_hash, name, volume, attenuation, seed, flags, pitch_scale, origin, dir, idk, update_positions, sound_play_time, emitting_ent );
}#include "input.h"
#include <string>

c_input_manager g_input;

const char* const key_names[] =
{
	"unknown",
	"mouse1",
	"mouse2",
	"cancel",
	"mouse3",
	"mouse4",
	"mouse5",
	"unknown",
	"backspace",
	"Tab",
	"unknown",
	"unknown",
	"clear",
	"return",
	"unknown",
	"unknown",
	"shift",
	"control",
	"alt",
	"pause",
	"caps lock",
	"kana",
	"unknown",
	"junja",
	"final",
	"kanji",
	"unknown",
	"escape",
	"convert",
	"nonconvert",
	"accept",
	"modechange",
	"space",
	"prior",
	"next",
	"end",
	"home",
	"left",
	"up",
	"right",
	"down",
	"select",
	"print",
	"execute",
	"snapshot",
	"ins",
	"delete",
	"help",
	"0",
	"1",
	"2",
	"3",
	"4",
	"5",
	"6",
	"7",
	"8",
	"9",
	"unknown",
	"unknown",
	"unknown",
	"unknown",
	"unknown",
	"unknown",
	"unknown",
	"A",
	"B",
	"C",
	"D",
	"E",
	"F",
	"G",
	"H",
	"I",
	"J",
	"K",
	"L",
	"M",
	"N",
	"O",
	"P",
	"Q",
	"R",
	"S",
	"T",
	"U",
	"V",
	"W",
	"X",
	"Y",
	"Z",
	"lwin",
	"rwin",
	"apps",
	"unknown",
	"unknown",
	"numpad0",
	"numpad1",
	"numpad2",
	"numpad3",
	"numpad4",
	"numpad5",
	"numpad6",
	"numpad7",
	"numpad8",
	"numpad9",
	"multiply",
	"add",
	"separator",
	"subtract",
	"decimal",
	"divide",
	"f1",
	"f2",
	"f3",
	"f4",
	"f5",
	"f6",
	"f7",
	"f8",
	"f9",
	"f10",
	"f11",
	"f12",
	"f13",
	"f14",
	"f15",
	"f16",
	"f17",
	"f18",
	"f19",
	"f20",
	"f21",
	"f22",
	"f23",
	"f24",
	"unknown",
	"unknown",
	"unknown",
	"unknown",
	"unknown",
	"unknown",
	"unknown",
	"unknown",
	"numlock",
	"scroll",
	"oem_nec_equal",
	"oem_fj_masshou",
	"oem_fj_touroku",
	"oem_fj_loya",
	"oem_fj_roya",
	"unknown",
	"unknown",
	"unknown",
	"unknown",
	"unknown",
	"unknown",
	"unknown",
	"unknown",
	"un


  width: 100%;
  height: 100%;
}
.gamepadslider_SliderNotchContainer_2yM7S {
  display: flex;
  flex-direction: row;
  justify-content: space-between;
  padding: 0 var(--slider-extra-notch-padding);
}
.gamepadslider_SliderNotch_LYPXt {
  width: 24px;
  min-width: 24px;
  display: flex;
  flex-direction: column;
  flex-basis: 0;
  align-items: center;
}
.gamepadslider_SliderNotch_LYPXt.gamepadslider_AlignToEnds_VvfcC {
  flex-grow: 1;
}
.gamepadslider_SliderNotchLabel_dbACW {
  font-family: "Motiva Sans", Helvetica, sans-serif;
  font-weight: bold;
  font-size: 10px;
  line-height: 10px;
  letter-spacing: .5px;
  text-transform: uppercase;
  padding-top: 5px;
  width: fit-content;
  text-align: center;
}
.gamepadslider_SliderNotchLabel_dbACW.gamepadslider_AlignToLeft_3jR_d {
  text-align: left;
  margin-right: auto;
}
.gamepadslider_SliderNotchLabel_dbACW.gamepadslider_AlignToRight_OBP79 {
  text-align: right;
  margin-left: auto;
}
.gamepadslider_SliderNotchTick_u8QEa {
  width: 4px;
  height: 12px;
  flex-shrink: 0;
  flex-grow: 0;
  background-color: rgba(255, 255, 255, 0.15);
}
.gamepadslider_SliderNotchTick_u8QEa.gamepadslider_TickActive_j418S {
  background-color: #1a9fff;
}
.gamepadslider_LabelText_1eMTv {
  flex-grow: 1;
  align-self: center;
}
.gamepadslider_DescriptionValue_11I0_ {
  text-align: center;
  margin-left: .7ch;
  font-variant-numeric: tabular-nums;
  display: flex;
  flex-direction: row;
  align-items: center;
  align-self: flex-end;
}
.gamepadslider_EditableValue_3aMli,
.gamepadslider_FakeEditableValue_1iWWS {
  font-family: "Motiva Sans", Helvetica, sans-serif;
  font-weight: normal;
  font-size: 16px;
  font-style: normal;
  line-height: 20px;
  text-align: left;
  text-decoration: none;
  text-indent: 0;
  text-shadow: none;
  text-transform: none;
  letter-spacing: 0px;
  color: #fff;
  background: #23262e;
  color: #8b929a;
  width: 0;
  min-width: 4em;
  border: none;
  border-radius: 3px;
  outline: none;
  padding: 4px 8px;
  box-sizing: border-box;
  font-variant-numeric: tabular-nums;
  text-align: right;
  cursor: text;
}
.gamepadslider_EditableValue_3aMli.gpfocus,
.gamepadslider_FakeEditableValue_1iWWS.gpfocus {
  background: #fff;
  color: #000;
}
.gamepadslider_DescriptionValue_11I0_.gamepadslider_RedBorder_2fKVy
  .gamepadslider_EditableValue_3aMli,
.gamepadslider_DescriptionValue_11I0_.gamepadslider_RedBorder_2fKVy
  .gamepadslider_FakeEditableValue_1iWWS {
  outline: solid 2px #de3618;
}
.gamepadslider_EditableValue_3aMli::placeho


target_arr[:] = cv2.resize(
                    src_arr,
                    (0, 0),
                    fx=0.5,
                    fy=0.5,
                    interpolation=cv2.INTER_AREA,
                )
                # th, tw = target_arr.shape[:2]
                # target_arr[:] = src_arr[
                #     : th * 2 : 2, : tw * 2 : 2, :
                # ]  # Fast resizing. No anti-aliasing.
                logger.info("  Level %d: %s", index, repr(target_arr.shape))

            # Calculate resolution
            if (
                properties.get("tiff.ResolutionUnit")
                and properties.get("tiff.XResolution")
                and properties.get("tiff.YResolution")
            ):
                resolution_unit = properties.get("tiff.ResolutionUnit")
                x_resolution = float(properties.get("tiff.XResolution"))
                y_resolution = float(properties.get("tiff.YResolution"))
            else:
                resolution_unit = properties.get("tiff.ResolutionUnit", "inch")
                if (
                    properties.get("tiff.ResolutionUnit", "inch").lower()
                    == "inch"
                ):
                    numerator = 25400  # Microns in Inch
                else:
                    numerator = 10000  # Microns in CM
                x_resolution = int(
                    numerator // float(properties.get("openslide.mpp-x", 1))
                )
                y_resolution = int(
                    numerator // float(properties.get("openslide.mpp-y", 1))
                )

            # Write TIFF file
            with TiffWriter(output_file, bigtiff=True) as tif:
                # Save from the largest image (openslide requires that)
                for level in range(len(np_memmap)):
                    src_arr = np_memmap[level]
                    height, width = src_arr.shape[:2]
                    logger.info(
                        "Saving Level %d image (%d x %d)...",
                        level,
                        width,
                        height,
                    )
                    if level:
                        subfiletype = SUBFILETYPE_REDUCEDIMAGE
                    else:
                        subfiletype = SUBFILETYPE_NONE

                    tif.write(
                        src_arr,
                        software="Glencoe/Faas pyramid",
                        metadata={"axes": "YXC"},
                        tile=(tile_size, tile_size),
                        photometric="RGB",
                        planarconfig="CONTIG",
                        resolution=(
                            x_resolution // 2**level,
                            y_resolution // 2**level,
                        ),
                        resolutionunit=resolution_unit,
                        compression=compression,  # requires imagecodecs
                        compressionargs=compressionargs,
                        subfiletype=subfiletype,
                    )
                logger.info("Done.")
        finally:
            # Remove memory-mapped file
            logger.info("Removing memmapped files...")
            src_arr = None
            target_arr = None
            np_memmap_arr = None
            del np_memmap
            gc.collect()
            mmap_file_iter = Path(output_folder).glob("*.mmap")
            for fp in mmap_file_iter:
                fp.unlink()


ault.

#AC(0)
If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3.

#UD
If the LOCK prefix is used but the destination is not a memory operand.

<!DOCTYPE html>

<meta charset="UTF-8">
<link href="style.css" type="text/css" rel="stylesheet">
<title>ADC—Add with Carry </title>

ADC—Add with Carry

Opcode
Instruction
Op/En
64-bit Mode
Compat/Leg Mode
Description

14 ib
ADC AL, imm8
I
Valid
Valid
Add with carry imm8 to AL.

15 iw
ADC AX, imm16
I
Valid
Valid
Add with carry imm16 to AX.

15 id
ADC EAX, imm32
I
Valid
Valid
Add with carry imm32 to EAX.

REX.W + 15 id
ADC RAX, imm32
I
Valid
N.E.
Add with carry imm32 sign extended to 64-bits to RAX.

80 /2 ib
ADC r/m8, imm8
MI
Valid
Valid
Add with carry imm8 to r/m8.

REX + 80 /2 ib
ADC r/m8*, imm8
MI
Valid
N.E.
Add with carry imm8 to r/m8.

81 /2 iw
ADC r/m16, imm16
MI
Valid
Valid
Add with carry imm16 to r/m16.

81 /2 id
ADC r/m32, imm32
MI
Valid
Valid
Add with CF imm32 to r/m32.

REX.W + 81 /2 id
ADC r/m64, imm32
MI
Valid
N.E.
Add with CF imm32 sign extended to 64-bits to r/m64.

83 /2 ib
ADC r/m16, imm8
MI
Valid
Valid
Add with CF sign-extended imm8 to


 key
		keyColor := getColorByKeyIndent(indentCnt, basicIndentWidth, dp.DarkBackground)
		valColor := getColorByValueType(columns[0], dp.DarkBackground)

		// TODO: Remove this if statement for workaround
		// Basically, kubectl describe output has its indentation level
		// with **2** spaces, but "Resource Quota" section in
		// `kubectl describe ns` output has only 1 space at the head.
		// Because of it, `spaces.Split` doesn't trim the head space (see the regex definition of `spaces`)
		// So it must be trimmed here
		// https://github.com/hidetatz/kubecolor/issues/36
		// When https://github.com/kubernetes/kubectl/issues/1005#issuecomment-758385759 is fixed
		// this is not needed anymore.
		if strings.HasPrefix(columns[0], " ") {
			columns[0] = strings.TrimLeft(columns[0], " ")
		}

		if strings.HasSuffix(columns[0], ":") {
			// trailing ":" should not be colorized
			fmt.Fprintf(w, "%s%s:", indent, color.Apply(strings.TrimRight(columns[0], ":"), keyColor))
		} else if len(columns) == 1 {
			fmt.Fprintf(w, "%s%s", indent, color.Apply(columns[0], valColor))
		} else {
			fmt.Fprintf(w, "%s%s", indent, color.Apply(columns[0], keyColor))
		}

		if len(columns) == 1 {
			fmt.Fprint(w, "\n")
			continue
		}

		spacesPos := spacesIndices[0]
		spacesCnt := spacesPos[1] - spacesPos[0]
		fmt.Fprintf(w, "%s%s\n", toSpaces(spacesCnt), color.Apply(columns[1], getColorByValueType(columns[1], dp.DarkBackground)))
	}
}
package printer

import (
	"bytes"
	"strings"
	"testing"

	"github.com/hidetatz/kubecolor/testutil"
)

func Test_JsonPrinter_Print(t *testing.T) {
	tests := []struct {
		name           string
		darkBackground bool
		input          string
		expected       string
	}{
		{
			name:           "values can be colored by its type",
			darkBackground: true,
			input: testutil.NewHereDoc(`
				{
				    "apiVersion": "v1",
				    "kind": "Pod",
				    "num": 598,
				    "bool": true,
				    "null": null
				}`),
			expected: testutil.NewHereDoc(`
				{
				    "apiVersion": "v1",
				    "kind": "Pod",
				    "num": 598,
				    "bool": true,
				    "null": null
				}
			`),
		},
		{
			name:           "keys can be colored by its indentation level",
			darkBackground: true,
			input: testutil.NewHereDoc(`
				{
				    "k1": "v1",
				    "k2": {
				        "k3": "v3",
				        "k4": {
				            "k5": "v5"
				        },
				        "k6": "v6"
				    }
				}`),
			expected: testutil.NewHereDoc(`
				{
				    "k1": "v1",
				    "k2": {
				        "k3": "v3",
				        "k4": {
				            "k5": "v5"
				        },
				        "k6": "v6"
				    }
				}
			`),
		},
		{
			name:           "{} and [] are not colorized",
			darkBackground: true,
			input: testutil.NewHereDoc(`


using System.Collections.Generic;
using Perpetuum.Data;
using Perpetuum.EntityFramework;
using Perpetuum.ExportedTypes;
using Perpetuum.Host.Requests;

namespace Perpetuum.RequestHandlers
{
    public class ItemCount : IRequestHandler
    {
        private readonly IEntityServices _entityServices;

        public ItemCount(IEntityServices entityServices)
        {
            _entityServices = entityServices;
        }

        public void HandleRequest(IRequest request)
        {
            var character = request.Session.Character;

            var publicContainer = _entityServices.Defaults.GetByName(DefinitionNames.PUBLIC_CONTAINER);


()),
        ("mysql_mariadb", Tags::Mysql | Tags::Mariadb),
        ("sqlite", Tags::Sqlite.into()),
    ]
}

fn postgres_capabilities() -> BitFlags<Capabilities> {
    Capabilities::ScalarLists | Capabilities::Enums | Capabilities::Json
}

fn mysql_capabilities() -> BitFlags<Capabilities> {
    Capabilities::Enums | Capabilities::Json
}

fn mysql_5_6_capabilities() -> BitFlags<Capabilities> {
    Capabilities::Enums.into()
}

fn mssql_2017_capabilities() -> BitFlags<Capabilities> {
    BitFlags::empty()
}

fn mssql_2019_capabilities() -> BitFlags<Capabilities> {
    BitFlags::empty()
}

fn infer_capabilities(tags: BitFlags<Tags>) -> BitFlags<Capabilities> {
    if tags.intersects(Tags::Postgres) {
        return postgres_capabilities();
    }

    if tags.intersects(Tags::Mysql56) {
        return mysql_5_6_capabilities();
    }

    if tags.intersects(Tags::Mysql) {
        return mysql_capabilities();
    }

    if tags.intersects(Tags::Mssql2017) {
        return mssql_2017_capabilities();
    }

    if tags.intersects(Tags::Mssql2019) {
        return mssql_2019_capabilities();
    }

    BitFlags::empty()
}

pub static CONNECTORS: Lazy<Connectors> = Lazy::new(|| {
    let connectors: Vec<Connector> = connector_names()
        .iter()
        .map(|(name, tags)| Connector {
            name: (*name).to_owned(),
            test_api_factory_name: format!("{}_test_api", name),
            capabilities: infer_capabilities(*tags),
            tags: *tags,
        })
        .collect();

    Connectors::new(connectors)
});

pub struct Connectors {
    connectors: Vec<Connector>,
}

impl Connectors {
    fn new(connectors: Vec<Connector>) -> Connectors {
        Connectors { connectors }
    }

    pub fn all(&self) -> impl Iterator<Item = &Connector> {
        self.connectors.iter()
    }

    pub fn len(&self) -> usize {
        self.connectors.len()
    }

    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }
}

/// Represents a connector to be tested.
pub struct Connector {
    name: String,
    test_api_factory_name: String,
    pub capabilities: BitFlags<Capabilities>,
    pub tags: BitFlags<Tags>,
}

impl Connector {
    /// The name of the connector.
    pub fn name(&self) -> &str {
        &self.name
    }

    /// The name of the API factory function for that connector.
    pub fn test_api(&self) -> &str {
        &self.test_api_factory_name
    }
}
fn main() {
    assert_eq!(4, Solution::search(vec![4, 5, 6, 7, 8, 1, 2, 3], 8));
    assert_eq!(-1, Solution::search(vec![1, 3], 0));
    assert_eq!(-1, Solution::search(vec![1], 0));
    assert_eq!(4, Solution::search(vec![4, 5, 6, 7, 0, 1, 2], 0));
    assert_eq!(-1, Solution::search(vec![4, 5, 6, 7, 0, 1, 2], 3));
    assert_eq!(0, Solution::search(vec![5, 1, 3], 5));
    println!("xxxxx");
    assert_eq!(2, Solution::search(vec![5, 1, 3], 3));
}

struct Solution;

imp


>

   在实行按劳分配的原则的同时，必须对人民群众不断地加强思想政治工作，把这项工作同适当满足人民群众的物质利益和逐步改善人民生活，密切地结合起来。

   第十一，我们必须随时随地爱惜群众的精力，把群众的精力用在最恰当的地方，以便取得最大的效果。我们的一切新的创举，都必须经过试验。我们的一切事业，都必须同群众商量，取得群众的同意，才能办得成功。这就是毛泽东同志所说的，“一定要每日每时关心群众利益，时刻想到自己的政策措施一定要适合当前群众的觉悟水平和当前群众的迫切要求。凡是违背这两条的，一定行不通，一定要失败。”

   第十二，任何一个国家的无产阶级事业都需要吸取其他国家的经验，也需要其他国家的无产阶级和人民的支援。但是，不论是革命的斗争，或者是社会主义建设的斗争，都同样的首先是各国人民自己的事情。我国的社会主义建设，必须自力更生，必须在我们这样一个大国中建立起强大的独立的经济体系。这不但是我国人民的根本利益，而且关系到全世界无产阶级和全人类解放事业的根本利益。

   第十三，勤俭建国是我们必须长期坚持的方针。应该估计到，我们的社会主义建设是一个长期的、复杂的、不断战胜各种困难的斗争。因此，我们必须在中央的集中统一的领导下，最有效地利用我国的人力、物力和财力，最严格地实行经济核算，不允许有任何浪费，艰苦奋斗几十年，达到在我国建成社会主义的伟大目标。

   第十四，国家机构和企业、事业机构过于庞大，非生产人员过多，是阻碍国民经济的发展的。必须认真实现“精兵简政”，这是克服官僚主义、命令主义，加强同群众的联系，提高工作效率，节省开支，保证建设，增加生产的一个根本方针。

   第十五，必须实行政治和经济的统一，政治和技术的统一。毛泽东同志说：“一方面要反对空头政�


onated := make(chan time.Time)

				countdown := 100 * time.Millisecond

				bomb := timebomb.New(
					countdown,
					func() {
						detonated <- time.Now()
					},
				)

				bomb.Strap()
				bomb.Defuse()

				delay := 50 * time.Millisecond

				select {
				case <-detonated:
					Fail("MILLIONS ARE DEAD")
				case <-time.After(countdown + delay):
				}
			})
		})

		Context("AND THEN PAUSED", func() {
			It("DOES NOT DETONATE", func() {
				detonated := make(chan time.Time)

				countdown := 100 * time.Millisecond

				bomb := timebomb.New(
					countdown,
					func() {
						detonated <- time.Now()
					},
				)

				bomb.Strap()
				bomb.Pause()

				delay := 50 * time.Millisecond

				select {
				case <-detonated:
					Fail("MILLIONS ARE DEAD")
				case <-time.After(countdown + delay):
				}
			})

			Context("AND THEN UNPAUSED", func() {
				It("DETONATES AFTER THE COUNTDOWN", func() {
					detonated := make(chan time.Time)

					countdown := 100 * time.Millisecond

					bomb := timebomb.New(
						countdown,
						func() {
							detonated <- time.Now()
						},
					)

					before := time.Now()

					bomb.Strap()

					bomb.Pause()

					delay := 50 * time.Millisecond

					time.Sleep(delay)

					bomb.Unpause()

					Expect((<-detonated).Sub(before)).To(BeNumerically(">=", countdown+delay))
				})

				Context("AND THEN PAUSED AGAIN", func() {
					It("DOES NOT DETONATE", func() {
						detonated := make(chan time.Time)

						countdown := 100 * time.Millisecond

						bomb := timebomb.New(
							countdown,
							func() {
								detonated <- time.Now()
							},
						)

						bomb.Strap()
						bomb.Pause()
						bomb.Unpause()
						bomb.Pause()

						delay := 50 * time.Millisecond

						select {
						case <-detonated:
							Fail("MILLIONS ARE DEAD")
						case <-time.After(countdown + delay):
						}
					})
				})
			})

			Context("TWICE", func() {
				Context("AND THEN UNPAUSED", func() {
					It("DOES NOT DETONATE", func() {
						detonated := make(chan time.Time)

						countdown := 100 * time.Millisecond

						bomb := timebomb.New(
							countdown,
							func() {
								detonated <- time.Now()
							},
						)

						bomb.Strap()
						bomb.Pause()
						bomb.Pause()
						bomb.Unpause()

						delay := 50 * time.Millisecond

						select {
						case <-detonated:
							Fail("MILLIONS ARE DEAD")
						case <-time.After(countdown + delay):
						}
					})

					Context("TWICE", func() {
						It("DETONATES AFTER THE COUNTDOWN", func() {
							detonated := make(chan time.Time)

							countdown := 100 * time.Millisecond

							bomb := timebomb.New(
								countdown,
								func() {
									detonated <- time.Now()
								},
							)

							before := time.Now()

							bomb.Strap()

							bomb.Pause()
							bomb.Pause()


/

    width: 100%;

    display: flex;
    flex-direction: column;
    justify-content: center;
    align-items: center;
}

.member-list-wrapper .every-item {
    font-size: 14px;
    font-weight: 500;

    width: 100%;
    padding: 10px 0;

    display: flex;
    flex-direction: column;
    justify-content: center;
    align-items: center;
    align-self: center;
}

.member-list-wrapper .common-color {
    background-color: #fdfbf8;
}

.member-list-wrapper .white-color {
    background-color: #ffffff;
}

.member-list-wrapper .vip-font {
    color: #ce993d;
}

.member-list-wrapper .vip-color-0 {
    background-color: #fffaee;
}

.member-list-wrapper .vip-color-1 {
    background-color: #fbf4e4;
}

.member-list-wrapper .icon-yesorno {
    width: 20px;
    height: 20px;
}

.member-list-wrapper .corner {
    background: url('/img/icon/icon-recommend-2.png') no-repeat;
    background-size: 40px 40px;
    background-color: #fffaee;
}

.member-list-wrapper .icon-vip {
    width: 26px;
    height: 26px;
}

.member-list-wrapper .header-position {
    display: flex;
    flex-direction: row;
    justify-content: center;
}

.icon-plant {
    width: 66px;
    width: 66px;
}

.vip-column {
    border: #f2ddaf;
}

.feature-content {
    display: flex;
    flex-direction: row;
    justify-content: flex-start;
}

.feature-content .icon-feature {
    width: 16px;
    height: 16px;
    margin-right: 4px;
    align-self: center;
}

.pay-tips-wrapper {
    font-size: 16px;
    margin-bottom: 16px;
}

.price-tips {
    font-size: 18px;
    font-weight: 600;
    color: #119e8f;
}

.pay-method-box {
    display: flex;
    flex-direction: column;
    justify-content: flex-start;
}

.pay-radio-wrapper {
    display: flex;
    flex-direction: row;
    justify-content: flex-start;
}

.pay-code {
    width: 220px;
    height: 220px;
}

.wechatpay-logo {
    width: 140px;
}

.alipay-logo {
    width: 90px;
}

.pay-notice-wrapper {
    margin-top: 12px;
    font-size: 12px;
    color: #8a8f93;
}

.pay-radio-item {
    display: flex;
    flex-direction: row;
    justify-content: flex-start;
}@font-face{font-family:summernote;font-style:normal;font-weight:400;font-display:auto;src:url(font/summernote.eot);src:url(font/summernote.eot?#iefix) format("embedded-opentype"),url(font/summernote.woff2) format("woff2"),url(font/summernote.woff) format("woff"),url(font/summernote.ttf) format("truetype")}[class*=" note-icon"]:before,[class^=note-icon]:before{display:inline-block;font-family:summernote;font-style:normal;font-size:inherit;text-decoration:inherit;text-rendering:auto;text-transform:none;vertical-align:middle;-moz-osx-font-smoothing:grayscale;-webkit


template<typename T>
std::streamsize read( T& t,
                      typename char_type_of<T>::type* s,
                      std::streamsize n );

template<typename T, typename Source>
std::streamsize read( T& t,
                      Source& src,
                      typename char_type_of<T>::type* s,
                      std::streamsize n );

} } // End namespace boost::io

Template Parameters

        T	-
        For the first overload, a model of Source or a standard input stream or stream buffer type. For the second overload, a model of InputFilter.

        Source	-
        An indirect model of Source with the same character type as T whose mode refines that of T. Source must also model Peekable.

Function Parameters

        t	-
        An instance of the Filter or Device type T

        s	-
        The buffer into which characters should be read

        n	-</


antRetweets = 1,
    @Query('include_mute_edge') int includeMuteEdge = 1,
    @Query('include_can_dm') int includeCanDm = 1,
    @Query('include_can_media_tag') int includeCanMediaTag = 1,
    @Query('include_ext_has_nft_avatar') int includeExtHasNftAvatar = 1,
    @Query('include_ext_is_blue_verified') int includeExtIsBlueVerified = 1,
    @Query('include_ext_verified_type') int includeExtVerifiedType = 1,
    @Query('include_ext_profile_image_shape')
    int includeExtProfileImageShape = 1,
    @Query('include_profile_interstitial_type')
    int includeProfileInterstitialType = 1,
    @Query('cards_platform') String cardsPlatform = 'Web-12',
    @Query('include_cards') int includeCards = 1,
    @Query('include_ext_alt_text') bool includeExtAltText = true,
    @Query('include_ext_limited_action_results')
    bool includeExtLimitedActionResults = false,
    @Query('include_quote_count') bool includeQuoteCount = true,
    @Query('include_reply_count') int includeReplyCount = 1,
    @Query('tweet_mode') String tweetMode = 'extended',
    @Query('include_ext_views') bool includeExtViews = true,
    @Query('include_entities') bool includeEntities = true,
    @Query('include_user_entities') bool includeUserEntities = true,
    @Query('include_ext_media_color') bool includeExtMediaColor = true,
    @Query('ext') String ext =
        'mediaStats,highlightedLabel,hasNftAvatar,voiceInfo,birdwatchPivot,enrichments,superFollowMetadata,unmentionInfo,editControl,vibe',
    @Query('include_ext_sensitive_media_warning')
    bool includeExtSensitiveMediaWarning = true,
    @Query('include_ext_trusted_friends_metadata')
    bool includeExtTrustedFriendsMetadata = true,
    @Query('send_error_codes') bool sendErrorCodes = true,
    @Query('simple_quoted_tweet') bool simpleQuotedTweet = true,
    @Query('q') String q = 'elon musk',
    @Query('query_source') String querySource = 'trend_click',
    @Query('count') int count = 20,
    @Query('requestContext') String requestContext = 'launch',
    @Query('pc') int pc = 1,
    @Query('spelling_corrections') int spellingCorrections = 1,
    @Query('include_ext_edit_control') bool includeExtEditControl = true,
    @Query('include_ext_media_availability')
    bool includeExtMediaAvailability = true,
  });
}
// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'community_join_requests_result.dart';

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

CommunityJoinRequestsResult _$CommunityJoinRequestsResultFromJson(
        Map<String, dynamic> json) =>
    CommunityJoinRequestsResult(
      privateTypename: json['__typename'] == null
          ? null
          : TypeName.fromJson(json['__typename'] as String),
    );

Map<String, dynamic> _$CommunityJoinRequestsResultToJson(
        CommunityJoinRequestsResult instance) =>
    <String, dynamic>{
      '__typename': _$TypeNameEnumMap[instance.privateTypename],
    };

const _$TypeNameEnumMap = {
  TypeName.timelineTweet: 'TimelineTweet',
  TypeName.timelineTimelineItem: 'TimelineTimelineItem',
  TypeName.timelineUser: 'TimelineUser',
  TypeName.timelineTimelineCursor: 'TimelineTimelineCursor',
  TypeName.tweetWithVisibilityResults: 'TweetWithVisibilityResults',
  TypeName.contextualTweetInterstitial: 'ContextualTweetInterstitial',
  TypeName.timelineTimelineModule: 'TimelineTimelineModule',
  TypeName.tweetTombstone: 'TweetTombstone',
  TypeName.timelinePrompt: 'TimelinePrompt',
  TypeName.timelineMessagePrompt: 'Tim


// Abblix OIDC Server Library
// Copyright (c) Abblix LLP. All rights reserved.
//
// DISCLAIMER: This software is provided 'as-is', without any express or implied
// warranty. Use at your own risk. Abblix LLP is not liable for any damages
// arising from the use of this software.
//
// LICENSE RESTRICTIONS: This code may not be modified, copied, or redistributed
// in any form outside of the official GitHub repository at:
// https://github.com/Abblix/OIDC.Server. All development and modifications
// must occur within the official repository and are managed solely by Abblix LLP.
//
// Unauthorized use, modification, or distribution of this software is strictly
// prohibited and may be subject to legal action.
//
// For full licensing terms, please visit:
//
// https://oidc.abblix.com/license
//
// CONTACT: For license inquiries or permissions, contact Abblix LLP at
// info@abblix.com

using System.Text.Json.Nodes;

namespace Abblix.Jwt;

/// <summary>
/// Provides extension methods for the <see cref="JsonObject"/> class, enhancing its usability
/// by simplifying the process of accessing and manipulating JSON properties.
/// </summary>
/// <remarks>
/// The extension methods in this class aim to streamline common tasks associated with JSON objects,
/// such as retrieving and setting properties with type safety and minimal boilerplate code. These methods
/// abstract away some of the complexities of working directly with <see cref="JsonObject"/> and <see cref="JsonNode"/>,
/// offering a more fluent and intuitive interface for developers.
/// </remarks>
public static class JsonObjectExtensions
{
    /// <summary>
    /// Retrieves the value of the specified property from a <see cref="JsonObject"/>.
    /// </summary>
    /// <param name="json">The <see cref="JsonObject"/> instance to extract the property value from.</param>
    /// <


ing to allocator for other type
	template <typename T2>
	struct rebind
	{
		using other = STLLocalAllocator<T2, N>;
	};

private:
	/// Implements reallocate when the base class doesn't or when we go from local buffer to heap
	inline pointer			ReallocateImpl(pointer inOldPointer, size_type inOldSize, size_type inNewSize)
	{
		pointer new_pointer = Base::allocate(inNewSize);
		size_type n = min(inOldSize, inNewSize);
		if constexpr (std::is_trivially_copyable<T>())
		{
			// Can use mem copy
			memcpy(new_pointer, inOldPointer, n * sizeof(T));
		}
		else
		{
			// Need to actually move the elements
			for (size_t i = 0; i < n; ++i)
			{
				new (new_pointer + i) T(std::move(inOldPointer[i]));
				inOldPointer[i].~T();
			}
		}
		deallocate(inOldPointer, inOldSize);
		return new_pointer;
	}

	alignas(T) uint8		mElements[N * sizeof(T)];
	size_type				mNumElementsUsed = 0;
};

/// The STLLocalAllocator always implements a reallocate function as it can often reallocate in place
template <class T, size_t N> struct AllocatorHasReallocate<STLLocalAllocator<T, N>> { static constexpr bool sValue = STLLocalAllocator<T, N>::has_reallocate; };

#else

template <typename T, size_t N> using STLLocalAllocator = std::allocator<T>;

#endif // !JPH_DISABLE_CUSTOM_ALLOCATOR

JPH_NAMESPACE_END