rray     :",
        "  {",
        "    PROVIDE_HIDDEN (__init_array_start = .);",
        "    KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))",
        "    KEEP (*(.init_array .ctors))",
        "    PROVIDE_HIDDEN (__init_array_end = .);",
        "  }",
        "  .fini_array     :",
        "  {",
        "    PROVIDE_HIDDEN (__fini_array_start = .);",
        "    KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))",
        "    KEEP (*(.fini_array .dtors))",
        "    PROVIDE_HIDDEN (__fini_array_end = .);",
        "  }",
        "  .data.rel.ro : { *(.data.rel.ro.local* ) *(.data.rel.ro .data.rel.ro.* ) }",
        "  .dynamic        : { *(.dynamic) }",
        "  .got            : { *(.got) }",
        "  . = DATA_SEGMENT_RELRO_END (SIZEOF (.got.plt) >= 24 ? 24 : 0, .);",
        "  .got.plt        : { *(.got.plt)  *(.igot.plt) }",
        "  .data           :",
        "  {",
        "    *(.data .data.* )",
        "    SORT(CONSTRUCTORS)",
        "  }",
        "  _edata = .; PROVIDE (edata = .);",
        "  __bss_start = .;",
        "  .bss            :",
        "  {",
        "   *(.dynbss)",
        "   *(.bss .bss.* )",
        "   *(COMMON)",
        "   /* Align here to ensure that the .bss section occupies space up to",
        "      _end.  Align after .bss to ensure correct alignment even if the",
        "      .bss section disappears because there are no input sections.",
        "      FIXME: Why do we need it? When there is no .bss section, we don't",
        "      pad the .data section.  */",
        "   . = ALIGN(. != 0 ? 8 : 1);",
        "  }",
        "  . = ALIGN(8);",
        "  _end = .; PROVIDE (end = .);",
        "  . = DATA_SEGMENT_END (.);",
        "  /* Stabs debugging sections.  */",
        "  .stab          0 : { *(.stab) }",
        "  .stabstr       0 : { *(.stabstr) }",
        "  .stab.excl     0 : { *(.stab.excl) }",
        "  .stab.exclstr  0 : { *(.stab.exclstr) }",
        "  .stab.index    0 : { *(.stab.index) }",
        "  .stab.indexstr 0 : { *(.stab.indexstr) }",
        "  .comment       0 : { *(.comment) }",
        "  /* DWARF debug sections.",
        "     Symbols in the DWARF debugging sections are relative to the beginning",
        "     of the section so we begin them at 0.  */",
        "  /* DWARF 1 */",
        "  .debug          0 : { *(.debug) }",
        "  .line           0 : { *(.line) }",
        "  /* GNU DWARF 1 extensions */",
        "  .debug_srcinfo  0 : { *(.debug_srcinfo) }",
        "  .debug_sfnames  0 : { *(.debug_sfnames


작성하지 않고도 모든 웹 사이트에 몇 분 내로 대기실을 설치할 수 있습니다.

엔지니어링 아키텍트이거나 비즈니스 운영 분석가이거나 대기실 설치는 단순합니다. Cloudflare와 함께 하면, 응용 프로그램을 안정적으로 유지하며 예상치 못한 트래픽 급증으로부터 보호하는 일을 빠르고 쉽게 할 수 있습니다. 또한, Cloudflare는 자동 활성화와 동적인 유출이 중요하다고 생각합니다. 즉, 임계값이 초과되면 대기실이 자동으로 작동되어야 하며 사용자가 응용 프로그램에서 작업을 완료하면 사용자의 다양한 크기 버킷을 제거하고 대기 중인 사용자를 받아들여야 합니다. 자동으로 작동해야 하는 것입니다. 마지막으로, 사용자와 기업 모두 COVID-19의 영향을 똑같이 받고 있습니다. 특히 보건 및 정부 부문이 심각하지만, 이에 국한된 것은 아닙니다. Cloudflare는 이러한 응용 프로그램이 계속 사용 가능하고 기능을 유지함으로써 모든 사용자가 자신의 브라우저 내에서 오류가 아니라 필요한 대우를 받을 수 있게 하고 싶었습니다.

Cloudflare 대기실의 작동 방식Cloudflare 대기실은 에지 네트워크와 Worker 제품 위에 구축되었습니다. Cloudflare는 Workers 및 지속 가능 개체 서비스를 활용함으로써 고객 코딩의 필요�


return setmetatable(v, prj_proxy)
end

local function rebasekeys(t, keys, old, new)
	for _,key in ipairs(keys) do
		t[key] = path.rebase(t[key], old, new)
	end
	return t
end

local function rebasearray(t, old, new)
	local res = { }
	for _,f in ipairs(t) do
		table.insert(res, path.rebase(f, old, new))
	end
	return res
end

function new_cfg_proxy(cfg)
	local keys = { "directory", "fullpath", "bundlepath" }

	local old = cfg.location
	local new = path.join(cfg.location, cfg.shortname)
	local v = {
		__inner     = cfg,
		location    = new,
		objectsdir  = path.rebase(cfg.objectsdir, old, new),
		buildtarget = rebasekeys(table.deepcopy(cfg.buildtarget), keys, old, new),
		linktarget  = rebasekeys(table.deepcopy(cfg.linktarget), keys, old, new),
	}

	v.files             = rebasearray(cfg.files, old, new)
	v.includedirs       = rebasearray(cfg.includedirs, old, new)
	v.libdirs       	= rebasearray(cfg.libdirs, old, new)
	v.userincludedirs   = rebasearray(cfg.userincludedirs, old, new)
	v.systemincludedirs = rebasearray(cfg.systemincludedirs, old, new)
	v.swiftmodulemaps   = rebasearray(cfg.swiftmodulemaps, old, new)

	return setmetatable(v, cfg_proxy)
end

function cfg_proxy:getprojectfilename(fullpath)
	local name = self.project.name .. ".ninja"

	if fullpath ~= nil then
		return path.join(self.location, name)
	end

	return name
end

function cfg_proxy:getoutputfilename()
	return path.join(self.buildtarget.directory, self.buildtarget.name)
end

local proxy_cache = {
	prj = { new = new_prj_proxy },
	cfg = { new = new_cfg_proxy },
}

function get_proxy(cache, obj)
	if not cache[obj] then
		cache[obj] = cache.new(obj)
	end
	return cache[obj]
end

function ninja.get_proxy(typ, obj)
	if not proxy_cache[typ] then
		error("invalid proxy type")
	end

	return get_proxy(proxy_cache[typ], obj)
end


                        f.write_str("<locked>")
                    }
                }

                f.debug_struct("RecursiveMutex")
                    .field("data", &LockedPlaceholder)
                    .finish()
            }
            Err(TryLockError::Abandoned(_)) => {
                struct AbandonedPlaceholder;
                impl fmt::Debug for AbandonedPlaceholder {
                    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                        f.write_str("<abandoned>")
                    }
                }

                f.debug_struct("RecursiveMutex")
                    .field("data", &AbandonedPlaceholder)
                    .finish()
            }
            Err(TryLockError::BadParam) => {
                struct BadParamPlaceholder;
                impl fmt::Debug for BadParamPlaceholder {
                    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                        f.write_str("<current priority too high>")
                    }
                }

                f.debug_struct("RecursiveMutex")
                    .field("data", &BadParamPlaceholder)
                    .finish()
            }
        }
    }
}

impl<System: Kernel, T: fmt::Debug + 'static> fmt::Debug for MutexGuard<'_, System, T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&**self, f)
    }
}

impl<System: Kernel, T: fmt::Display + 'static> fmt::Display for MutexGuard<'_, System, T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Display::fmt(&**self, f)
    }
}

/// The destructor of `MutexGuard` that releases the lock. It will panic if
/// CPU Lock is active.
impl<System: Kernel, T: 'static> Drop for MutexGuard<'_, System, T> {
    #[inline]
    fn drop(&mut self) {
        let level = &self.mutex.hunk.level;
        if level.get() == 0 || level.get() == LEVEL_ABANDONED {
            self.mutex.mutex.unlock().unwrap();
        } else {
            level.update(|x| x - (1 << LEVEL_COUNT_SHIFT));
        }
    }
}

impl<System: Kernel, T: 'static> core::ops::Deref for MutexGuard<'_, System, T> {
    type Target = T;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.mutex.hunk.data
    }
}
<reponame>DanielT/a2lfile<gh_stars>0
use std::collections::HashMap;

use crate::specification::*;

#[derive(Debug, PartialEq)]
pub enum NameMapObject<'a> {
    Measurement(&'a Measurement),
    Characteristic(&'a Characteristic),
    AxisPts(&'a AxisPts),
    Blob(&'a Blob),
    Instance(&'a Instance),
}

#[derive(Debug, PartialEq)]
pub enum NameMapCompuTab<'a> {
    CompuTab(&'a CompuTab),
    CompuVtab(&'a CompuVtab),
    CompuVtabRange(&'a CompuVtabRange),
}

#[derive(Debug, PartialEq)]
pub enum NameMapTypedef<'a> {
    TypedefBlob(&'a TypedefBlob),
    TypedefAxis(&'a TypedefAxis),
    TypedefMeasurement(&'a TypedefMeasurement),
    TypedefCharacteristic(&'a TypedefCharacteristic),
    TypedefStructure(&'a TypedefStructure),
}

macro_rules! check_and_insert {
    ( $hash:expr, $key:expr, $item:expr, $log_msgs:expr, $blockname:expr ) => {
        if let Some(existing_val) = $hash.get(&$key) {
            $log_msgs.push(format!("Name collision: The {} blocks on line {} and {} both use the name {}",
                $blockname, existing_val.get_line(), $item.get_line(), $key));
        } else {
            $hash.insert($key, $item);
        }
    }
}

macro_rules! check_and_insert_multi {


#include <u.h>
#include <libc.h>
#include <bio.h>
#include <auth.h>
#include "imap4d.h"

static NamedInt	flagMap[] =
{
	{"\\Seen",	MSeen},
	{"\\Answered",	MAnswered},
	{"\\Flagged",	MFlagged},
	{"\\Deleted",	MDeleted},
	{"\\Draft",	MDraft},
	{"\\Recent",	MRecent},
	{nil,		0}
};

int
storeMsg(Box *box, Msg *m, int uids, void *vst)
{
	Store *st;
	int f, flags;

	USED(uids);

	if(m->expunged)
		return uids;

	st = vst;
	flags = st->flags;

	f = m->flags;
	if(st->sign == '+')
		f |= flags;
	else if(st->sign == '-')
		f &= ~flags;
	else
		f = flags;

	/*
	 * not allowed to change the recent flag
	 */
	f = (f & ~MRecent) | (m->flags & MRecent);
	setFlags(box, m, f);

	if(st->op != STFlagsSilent){
		m->sendFlags = 1;
		box->sendFlags = 1;
	}

	return 1;
}

/*
 * update flags & global flag counts in box
 */
void
setFlags(Box *box, Msg *m, int f)
{
	if(f == m->flags)
		return;

	box->dirtyImp = 1;
	if((f & MRecent) != (m->flags & MRecent)){
		if(f & MRecent)
			box->recent++;
		else
			box->recent--;
	}
	m->flags = f;
}

void
sendFlags(Box *box, int uids)
{
	Msg *m;

	if(!box->sendFlags)
		return;

	box->sendFlags = 0;
	for(m = box->msgs; m != nil; m = m->next){
		if(!m->expunged && m->sendFlags){
			Bprint(&bout, "* %lud FETCH (", m->seq);
			if(uids)
				Bprint(&bout, "uid %lud ", m->uid);
			Bprint(&bout, "FLAGS (");
			writeFlags(&bout, m, 1);
			Bprint(&bout, "))\r\n");
			m->sendFlags = 0;
		}
	}
}

void
writeFlags(Biobuf *b, Msg *m, int recentOk)
{
	char *sep;
	int f;

	sep = "";
	for(f = 0; flagMap[f].name != nil; f++){
		if((m->flags & flagMap[f].v)
		&& (flagMap[f].v != MRecent || recentOk)){
			Bprint(b, "%s%s", sep, flagMap[f].name);
			sep = " ";
		}
	}
}

int
msgSeen(Box *box, Msg *m)
{
	if(m->flags & MSeen)
		return 0;
	m->flags |= MSeen;
	box->sendFlags = 1;
	m->sendFlags = 1;
	box->dirtyImp = 1;
	return 1;
}

ulong
mapFlag(char *name)
{
	return mapInt(flagMap, name);
}


         if matrix_point.speed < last_point.speed {
                log::error!(
                    "Curve fan speeds should be monotonically increasing, found {} then {}",
                    last_point.speed,
                    matrix_point.speed
                );

                return Err(ConfigError::UnsortedFanSpeed {
                    current: matrix_point.speed,
                    last: last_point.speed,
                    index,
                }
                .into());
            }
            if matrix_point.temp < last_point.temp {
                log::error!(
                    "Curve fan temps should be monotonically increasing, found {} then {}",
                    last_point.temp,
                    matrix_point.temp
                );

                return Err(ConfigError::UnsortedFanTemp {
                    current: matrix_point.temp,
                    last: last_point.temp,
                    index,
                }
                .into());
            }
        }

        last_point = Some(matrix_point)
    }

    Ok(config)
}

#[cfg(test)]
mod parse_config {
    use crate::config::TempInput;
    use amdgpu::{AmdGpuError, Card};
    use serde::Deserialize;

    #[derive(Deserialize, PartialEq, Debug)]
    pub struct Foo {
        card: Card,
    }

    #[test]
    fn parse_card0() {
        assert_eq!("card0".parse::<Card>(), Ok(Card(0)))
    }

    #[test]
    fn parse_card1() {
        assert_eq!("card1".parse::<Card>(), Ok(Card(1)))
    }

    #[test]
    fn toml_card0() {
        assert_eq!(toml::from_str("card = 'card0'"), Ok(Foo { card: Card(0) }))
    }

    #[test]
    fn parse_invalid_temp_input() {
        assert_eq!(
            "".parse::<TempInput>(),
            Err(AmdGpuError::InvalidTempInput("".to_string()))
        );
        assert_eq!(
            "12".parse::<TempInput>(),
            Err(AmdGpuError::InvalidTempInput("12".to_string()))
        );
        assert_eq!(
            "temp12".parse::<TempInput>(),
            Err(AmdGpuError::InvalidTempInput("temp12".to_string()))
        );
        assert_eq!(
            "12_input".parse::<TempInput>(),
            Err(AmdGpuError::InvalidTempInput("12_input".to_string()))
        );
        assert_eq!(
            "temp_12_input".parse::<TempInput>(),
            Err(AmdGpuError::InvalidTempInput("temp_12_input".to_string()))
        );
    }

    #[test]
    fn parse_valid_temp_input() {
        assert_eq!("temp12_input".parse::<TempInput>(), Ok(TempInput(12)));
    }
}

#[cfg(test)]
mod speed_for_temp {
    use super::*;

    #[test]
    fn below_minimal() {
        let config = Config::default();
        assert_eq!(config.speed_for_temp(1f64), 4f64);
    }

    #[test]
    fn minimal() {
        let config = Config::default();
        assert_eq!(config.speed_for_temp(4f64), 4f64);
    }

    #[test]
    fn between_3_and_4_temp_46() {
        let config = Config::default();
        // 45 -> 50
        // 60 -> 66
        assert_eq!(config.speed_for_temp(46f64).round(), 51f64);
    }

    #[test]
    fn between_3_and_4_temp_58() {
        let config = Config::default();
        // 45 -> 50
        // 60 -> 66
        assert_eq!(config.speed_for_temp(58f64).round(), 64f64);
    }

    #[test]
    fn between_3_and_4_temp_59() {
        let config = Config::default();
        // 45 -> 50
        // 60 -> 66
        assert_eq!(config.speed_for_temp(59f64).round


21d1184 :thumb
	ldr     r0, [pc, #0xf4] @ 0x21d127c, (=0x221a400)
	ldr     r1, [r0, #0x0]
	ldr     r0, [pc, #0xf4] @ 0x21d1280, (=0x1070)
	ldr     r0, [r1, r0]
	cmp     r0, #0x4
	beq     branch_21d1196
	add     sp, #0x10
	mov     r0, #0x0
	pop     {r3-r7,pc}
@ 0x21d1196

.thumb
branch_21d1196: @ 21d1196 :thumb
	bl      Function_21d27cc
	ldr     r2, [pc, #0xe8] @ 0x21d1284, (=Unknown_2215868)
	add     r1, sp, #0x8
	ldmia   r2!, {r0,r2}
	str     r0, [sp, #0x8]
	mov     r0, #0xfa
	lsl     r0, r0, #2
	str     r2, [sp, #0xc]
	mul     r0, r7
	str     r0, [sp, #0xc]
	mov     r0, #0x0
	mov     r2, #0x8
	blx     Function_21dc9ac
	cmp     r0, #0x0
	beq     branch_21d11bc
	bl      ErrorHandling
branch_21d11bc: @ 21d11bc :thumb
	ldr     r1, [pc, #0xc8] @ 0x21d1288, (=0x2215e94)
	mov     r0, #0x0
	mov     r2, r5
	blx     Function_21dc87c
	cmp     r0, #0x0
	bne     branch_21d11ce
	bl      ErrorHandling
branch_21d11ce: @ 21d11ce :thumb
	ldr     r0, [pc, #0xac] @ 0x21d127c, (=0x221a400)
	mov     r2, #0x80
	ldr     r1, [r0, #0x0]
	ldr     r0, [pc, #0xb4] @ 0x21d128c, (=0xfc4)
	add     r0, r1, r0
	mov     r1, #0x0
	blx     MI_CpuFill8
	ldr     r0, [pc, #0x9c] @ 0x21d127c, (=0x221a400)
	ldr     r2, [pc, #0xa4] @ 0x21d1288, (=0x2215e94)
	ldr     r1, [r0, #0x0]
	ldr     r0, [pc, #0xa4] @ 0x21d128c, (=0xfc4)
	mov     r3, r5
	add     r0, r1, r0
	ldr     r1, [pc, #0xa4] @ 0x21d1290, (=0x2215870)
	blx     Function_20d7510
	ldr     r0, [pc, #0x88] @ 0x21d127c, (=0x221a400)
	ldr     r1, [r0, #0x0]
	ldr     r0, [pc, #0x94] @ 0x21d128c, (=0xfc4)
	add     r0, r1, r0
	blx     Function_20d8b60
	cmp     r0, #0x80
	bcc     branch_21d1204
	bl      ErrorHandling
.thumb
branch_21d1204: @ 21d1204 :thumb
	cmp     r6, #


// Magica Cloth.
// Copyright (c) MagicaSoft, 2020-2022.
// https://magicasoft.jp
using System.Collections.Generic;
using UnityEngine;

namespace MagicaCloth
{
    public class ModelController : MonoBehaviour
    {
        [SerializeField]
        private List<GameObject> characterList = new List<GameObject>();

        [SerializeField]
        private float slowTime = 0.1f;

        private bool slow;

        void Start()
        {
        }

        void Update()
        {
        }

        private void AnimatorAction(System.Action<Animator> act)
        {
            foreach (var chara in characterList)
            {
                if (chara && chara.activeInHierarchy)
                {
                    var animator = chara.GetComponent<Animator>();
                    if (animator)
                    {
                        act(animator);
                    }
                }
            }
        }

        private void ClothAction(System.Action<BaseCloth> act)
        {
            foreach (var chara in characterList)
            {


LOC_PPC_GLOB_DAT<var></var>

— : BFD_RELOC_PPC_JMP_SLOT<var></var>

— : BFD_RELOC_PPC_RELATIVE<var></var>

— : BFD_RELOC_PPC_LOCAL24PC<var></var>

— : BFD_RELOC_PPC_EMB_NADDR32<var></var>

— : BFD_RELOC_PPC_EMB_NADDR16<var></var>

— : BFD_RELOC_PPC_EMB_NADDR16_LO<var></var>

— : BFD_RELOC_PPC_EMB_NADDR16_HI<var></var>

— : BFD_RELOC_PPC_EMB_NADDR16_HA<var></var>

— : BFD_RELOC_PPC_EMB_SDAI16<var></var>

— : BFD_RELOC_PPC_EMB_SDA2I16<var></var>

— : BFD_RELOC_PPC_EMB_SDA2REL<var></var>

— : BFD_RELOC_PPC_EMB_SDA21<var></var>

— : BFD_RELOC_PPC_EMB_MRKREF<var></var>

— : BFD_RELOC_PPC_EMB_RELSEC16<var></var>

— : BFD_RELOC_PPC_EMB_RELST_LO<var><a name="


 next: *mut c_void,
    pub pipeline_executable_info: u32,
}

impl VkWrappedType<RawVkPhysicalDevicePipelineExecutablePropertiesFeatures> for VkPhysicalDevicePipelineExecutablePropertiesFeatures {
    fn vk_to_raw(src: &VkPhysicalDevicePipelineExecutablePropertiesFeatures, dst: &mut RawVkPhysicalDevicePipelineExecutablePropertiesFeatures) {
        dst.s_type = vk_to_raw_value(&VkStructureType::PhysicalDevicePipelineExecutablePropertiesFeaturesKhr);
        dst.next = ptr::null_mut();
        dst.pipeline_executable_info = vk_to_raw_value(&src.pipeline_executable_info);
    }
}

impl VkRawType<VkPhysicalDevicePipelineExecutablePropertiesFeatures> for RawVkPhysicalDevicePipelineExecutablePropertiesFeatures {
    fn vk_to_wrapped(src: &RawVkPhysicalDevicePipelineExecutablePropertiesFeatures) -> VkPhysicalDevicePipelineExecutablePropertiesFeatures {
        VkPhysicalDevicePipelineExecutablePropertiesFeatures {
            pipeline_executable_info: u32::vk_to_wrapped(&src.pipeline_executable_info),
        }
    }
}

impl Default for VkPhysicalDevicePipelineExecutablePropertiesFeatures {
    fn default() -> VkPhysicalDevicePipelineExecutablePropertiesFeatures {
        VkPhysicalDevicePipelineExecutablePropertiesFeatures {
            pipeline_executable_info: false,
        }
    }
}

impl VkSetup for VkPhysicalDevicePipelineExecutablePropertiesFeatures {
    fn vk_setup(&mut self, fn_table: *mut VkFunctionTable) {

    }
}

impl VkFree for RawVkPhysicalDevicePipelineExecutablePropertiesFeatures {
    fn vk_free(&self) {

    }
}<reponame>nbigaouette/gitlab-api-rs
//! List a group's projects
//!
//! https://docs.gitlab.com/ce/api/groups.html#list-a-group-s-projects
//!
//! # List a group's projects
//!
//! Get a list of projects in this group.
//!
//! ```text
//! GET /groups/ID/projects
//! ```
//!
//! Parameters:
//!
//! - `archived` (optional) - if passed, limit by archived status
//! - `visibility` (optional) - if passed, limit by visibility `public`, `internal`, `private`
//! - `order_by` (optional) - Return requests ordered by `id`, `name`, `path`, `created_at`,
//!     `updated_at` or `last_activity_at` fields. Default is `created_at`
//! - `sort` (optional) - Return requests sorted in `asc` or `desc` order. Default is `desc`
//! - `search` (optional) - Return list of authorized projects according to a search criteria
//! - `ci_enabled_first` - Return projects ordered by `ci_enabled` flag. Projects with enabled
//!     CI go first
//!
//!

use serde_urlencoded;

use BuildQuery;

use groups::ProjectsListerInternal;

use ::errors::*;

#[derive(Debug, Clone)]
pub struct ProjectsLister<'a> {
    gl: &'a ::GitLab,
    id: i64,
    internal: ProjectsListerInternal,
}

impl<'a> ProjectsLister<'a> {
    pub fn new(gl: &'a ::GitLab, id: i64) -> ProjectsLister {
        ProjectsLister {
            gl: gl,
            id: id,
            internal: ProjectsListerInternal {
                archived: None,
                visibility: None,
                order_


    [返回索引页面]

   区济文在广西整党工作会议上的讲话

   日期：1986-8-22 作者：区济文

   区济文

   当前整党情况和今后工作意见（节录）

   ——区济文同志在全区整党工作会议上的讲话

   第二个问题  坚定不移善始善终做好我区清理“三种人”工作

   我区清理“三种人”工作，在党中央的直接部署、关怀和帮助下，在区党委和各级党委的直接领导下，开始是作为处遗的重要组成部分，进行整党后，又作为整党的一项重要内容。三年多来，经过全体处遗、核查工作人员的共同努力，做了很多工作，取得了很大的成绩。下面我讲一讲三年多来的工作情况和今后工作的一些意见：

   一、主要成绩

   我区处遗、清理“三种人”工作，截至今年六月统计，共立案审查××× ××人，其中，国家干部×××××人（厅局级以上干部×××人，处级干部×××人，县级干部××××人，一般干部×××××人），工人、农民、居民共×××××人。已定案处理×××××人，占被审查人数的百分之九十九点三八。在已定案处理的人员中，国家干部×××××人（定为“三种人”×××人；严重违法乱纪分子××××人；犯严重错误××××人；犯有错误××××人；一般错误××××人；查无问题××××人），工人、农民、居民共×××××人（定为严重违法乱纪分子×××××人，定为犯严重错误×××××人，犯有错误××××人，一般错误××××人，查无问题×××人）。待定案处理的×××人（其中国家干部×××人，工人、农民、居民共×××人）

   在已定案处理的人员中，依法逮捕××××人（国家干部×××


;
            expect(result.length).to.equal(0);
        });

        it('Finds properties by special basic information group', () => {

            let propertyFilter = new Filters.PropertyFilter("Basic Information", []);
            const result = propertyFilter.filter(data);
            expect(result.length).to.equal(frames * entities);
        });

        it('Finds the same data after exporting and importing', () => {

            let propertyFilter = new Filters.PropertyFilter("Basic Information", []);
            const result = propertyFilter.filter(data);

            const exportedFilter = propertyFilter.export();
            let importedFilter = new Filters.PropertyFilter("", []);
            importedFilter.import(exportedFilter);
            const resultImported = importedFilter.filter(data);

            expect(areResultArraysEqual(result, resultImported)).to.be.true;
        });
    });
});import getAccountsFromLocalStorage from './getAccountsFromLocalStorage';
import getActiveLoginIDFromLocalStorage from './getActiveLoginIDFromLocalStorage';

/**
 * Gets the current user's auth `token` for the active `loginid` from the `localStorage`.
 */
const getActiveAuthTokenIDFromLocalStorage = () => {
    const accounts = getAccountsFromLocalStorage();
    const active_loginid = getActiveLoginIDFromLocalStorage();

    // If there is no active loginid or no accounts list, return undefined.
    if (!active_loginid || !accounts) return;

    return accounts[active_loginid]?.token;
};

export default getActiveAuthTokenIDFromLocalStorage;
/**
 * Последний элемент
 * @param xs: Array<T>
 * @returns {T}
 */
export const last = (xs: any[]): any => xs[xs.length - 1];

/**
 * Фильтрация списка
 * @param p: (A) => boolean
 * @param xs: Array
 * @returns {B}
 */
export const filter = (p: (any) => boolean) => (xs: any[]) => xs.filter(p);

/**
 * В обратном порядке
 * @param xs: Array
 * @returns {Array}
 */
export const reverse = (xs: any[]) => xs.reverse();

/**
 * Сортировка
 * @param f: (Array) => number | string
 * @param xs: Array
 * @returns {Array<any>}
 */
export const orderBy = (f) => (xs) => xs.sort((x0, x1) => f(x0) >= f(x1) ? 1 : -1);

/**
 * Группировка
 * @param f: (A) => string
 * @param xs: Array
 * @returns { [string]: Array }
 */
export const groupBy = (f) => (xs) => xs.reduce((acc, x) => {
	const key = f(x);
	if (acc[key]) {
		acc[key].push(x);
	} else {
		acc[key] = [x];
	}
	return acc;
}, {});

/**
 * Содержит ли
 * @param xs: Array
 * @param x: A
 * @returns {boolean}
 */
export const includes = (xs: any[], x: any): boolean => xs.indexOf(x) !== -1;

/**
 * Пересечение множеств
 * @param xs: Array
 * @param ys: Array
 * @returns {Array}
 */
export const intersection = (xs: any[], ys: any[]): any[] => xs.filter((x) => includes(ys, x));

/**
 * Разность множеств
 * @param xs: Array
 * @param ys: Array
 * @returns {Array}
 */
export const difference = (xs: any[], ys: any[]): any[] => xs.filter((x) => !includes(ys, x));

/**
 * Равны ли все элементы массива по данному отношению равенства
 * @param xs: Array
 * @param isEqual: (A, A) => boolean
 * @returns {boolean}
 */
export const allEqual = (xs: any[], isEqual: (x: any, y: any) => boolean): boolean => {
    return !xs.length || xs.every((x) => isEqual(x, xs[0]));
};

/**
 * Сумма
 * @param xs: Array<number>
 * @returns {number}
 */
export const sum = (xs: any[]): number => xs.reduce((s, x


        end
    end)

    it("should generate uuid with dash", function()
        for i = 1, 1000 do
            local uuid = random.uuid(true)
            assert.Equals(uuid:len(), 36)
            assert.Equals(uuid:sub(9, 9), "-")
            assert.Equals(uuid:sub(14, 14), "-")
            assert.Equals(uuid:sub(19, 19), "-")
            assert.Equals(uuid:sub(24, 24), "-")
            assert.Equals(uuid:sub(15, 15), "4")
            assert.is_true(is_magic_char(uuid:sub(20, 20)))
        end
    end)
end)


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

//
//  GTLPredictionOutput.h
//

// ----------------------------------------------------------------------------
// NOTE: This file is generated from Google APIs Discovery Service.
// Service:
//   Prediction API (prediction/v1.6)
// Description:
//   Lets you access a cloud hosted machine learning service that makes it easy
//   to build smart apps
// Documentation:
//   https://developers.google.com/prediction/docs/developer-guide
// Classes:
//   GTLPredictionOutput (0 custom class methods, 6 custom properties)
//   GTLPredictionOutputOutputMultiItem (0 custom class methods, 2 custom properties)

#if GTL_BUILT_AS_FRAMEWORK
  #import "GTL/GTLObject.h"
#else
  #import "GTLObject.h"
#endif

@class GTLPredictionOutputOutputMultiItem;

// ----------------------------------------------------------------------------
//
//   GTLPredictionOutput
//

@interface GTLPredictionOutput : GTLObject

// The unique name for the predictive model.
// identifier property maps to 'id' in JSON (to avoid Objective C's 'id').
@property (nonatomic, copy) NSString *identifier;

// What kind of resource this is.
@property (nonatomic, copy) NSString *kind;

// The most likely class label (Categorical models only).
@property (nonatomic, copy) NSString *outputLabel;

// A list of class labels with their estimated probabilities (Categorical models
// only).
@property (nonatomic, retain) NSArray *outputMulti;  // of GTLPredictionOutputOutputMultiItem

// The estimated regression value (Regression models only).
@property (nonatomic, copy) NSString *outputValue;

// A URL to re-request this resource.
@property (nonatomic, copy) NSString *selfLink;

@end

// ----------------------------------------------------------------------------
//
//   GTLPredictionOutputOutputMultiItem
//

@interface GTLPredictionOutputOutputMultiItem : GTLObject

// The class label.
@property (nonatomic, copy) NSString *label;

// The probability of the class label.
@property (nonatomic, copy) NSString *score;

@end


d restored(WalletModel* wallet_model);

private:
    void finish();
};

class MigrateWalletActivity : public WalletControllerActivity
{
    Q_OBJECT

public:
    MigrateWalletActivity(WalletController* wallet_controller, QWidget* parent) : WalletControllerActivity(wallet_controller, parent) {}

    void migrate(const std::string& path);

Q_SIGNALS:
    void migrated(WalletModel* wallet_model);

private:
    QString m_success_message;

    void finish();
};

#endif // BITCOIN_QT_WALLETCONTROLLER_H


AddCSLuaFile()
DEFINE_BASECLASS( "base_wire_entity" )
ENT.PrintName       = "Wire Laser Pointer Receiver"
ENT.WireDebugName 	= "Laser Receiver"

if CLIENT then return end

function ENT:Initialize()
	self:PhysicsInit( SOLID_VPHYSICS )
	self:SetMoveType( MOVETYPE_VPHYSICS )
	self:SetSolid( SOLID_VPHYSICS )
	self:SetUseType( SIMPLE_USE )
	self.Outputs = WireLib.CreateSpecialOutputs(self, {"X", "Y", "Z", "Active", "Pos", "RangerData"}, {"NORMAL", "NORMAL", "NORMAL", "NORMAL", "VECTOR", "RANGER"})
	self.VPos = Vector(0,0,0)

	self:SetOverlayText( "Laser Pointer Receiver" )
end

function ENT:GetBeaconPos(sensor)
	return self.VPos
end
function ENT:GetBeaconVelocity(sensor) return Vector() end

function ENT:Use( User, caller )
	if not hook.Run("PlayerGiveSWEP", User, "laserpointer", weapons.Get( "laserpointer" )) then return end
	User:PrintMessage(HUD_PRINTTALK, "Hold down your use key for 2 seconds to get and link a Laser Pointer.")
	timer.Create("las_receiver_use_"..User:EntIndex(), 2, 1, functi


f (dirty & /*altSItems*/ 4 && t0_value !== (t0_value = /*metricToString*/ ctx[3](/*item*/ ctx[25].metric) + "")) set_data(t0, t0_value);
			if (/*i*/ ctx[27] !== 0) if_block0.p(ctx, dirty);

			if (/*i*/ ctx[27] !== /*altSItems*/ ctx[2].length - 1) {
				if (if_block1) {
					if_block1.p(ctx, dirty);
				} else {
					if_block1 = create_if_block(ctx);
					if_block1.c();
					if_block1.m(span1, t3);
				}
			} else if (if_block1) {
				if_block1.d(1);
				if_block1 = null;
			}

			if (dirty & /*altSItems, MetricCounter*/ 4 && select0_value_value !== (select0_value_value = /*item*/ ctx[25].metric.counter)) {
				select_option(select0, /*item*/ ctx[25].metric.counter);
			}

			if (dirty & /*altSItems, MetricCounter*/ 4 && select1_value_value !== (select1_value_value = /*item*/ ctx[25].metric.type)) {
				select_option(select1, /*item*/ ctx[25].metric.type);
			}

			if (dirty & /*altSItems, MetricCounter*/ 4 && input0_value_value !== (input0_value_value = /*item*/ ctx[25].prefix) && input0.value !== input0_value_value) {
				input0.value = input0_value_value;
			}

			if (dirty & /*altSItems, MetricCounter*/ 4 && input1_value_value !== (input1_value_value = /*item*/ ctx[25].suffix) && input1.value !== input1_value_value) {
				input1.value = input1_value_value;
			}
		},
		d(detaching) {
			if (detaching) detach(details);
			if (if_block0) if_block0.d();
			if (if_block1) if_block1.d();
			mounted = false;
			run_all(dispose);
		}
	};
}

function create_fragment$1(ctx) {
	let div6;
	let h40;
	let t1;
	let p0;
	let t3;
	let div2;
	let button0;
	let t5;
	let button1;
	let t7;
	let t8;
	let h41;
	let t10;
	let p1;
	let t12;
	let div5;
	let button2;
	let t14;
	let button3;
	let t16;
	let mounted;
	let dispose;
	let each_value_1 = /*statusItems*/ ctx[1];
	let each_blocks_1 = [];

	for (let i = 0; i < each_value_1.length; i += 1) {
		each_blocks_1[i] = create_each_block_1(get_each_context_1(ctx, each_value_1, i));
	}

	let each_value = /*altSItems*/ ctx[2];
	let each_blocks = [];

	for (let i = 0; i < each_value.length; i += 1) {
		each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i));
	}

	return {
		c() {
			div6 = element("div");
			h40 = element("h4");
			h40.textContent = "Markdown Status Bar";
			t1 = space();
			p0 = element("p");
			p0.textContent = "Here you can customize what statistics are displayed on the status bar when editing a markdown note.";
			t3 = space();
			div2 = element("div");
			button0 = element("button");
			button0.innerHTML = `<div class="icon">Add Item</div>`;
			t5 = space();
			button1 = element("button");
			button1.


/*
 * Copyright (c) 2017, 2018, Oracle and/or its affiliates.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are
 * permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this list of
 * conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list of
 * conditions and the following disclaimer in the documentation and/or other materials provided
 * with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors may be used to
 * endorse or promote products derived from this software without specific prior written
 * permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include <stdio.h>
#include <string.h>

struct test {
  char a;
  char b[3];
  char c;
  char d[2];
  char e;
};

int main() {
  struct test t;
  memset(&t, 'a', sizeof t);
  printf("%c %c %c %c %c %c %c %c\n", t.a, t.b[0], t.b[1], t.b[2], t.c, t.d[0], t.d[1], t.e);
}


}
// ---------------------------------------------------------------------------------------
// NeoGeo CD Game Info Module (by CaptainCPS-X)
// ---------------------------------------------------------------------------------------
#include "burner.h"
#include "neocdlist.h"

#define DEBUG_CD    0

const int nSectorLength = 2352;

NGCDGAME* game;

struct NGCDGAME games[] =
{
// ---------------------------------------------------------------------------------------------------------------------------------------------//
//	* Name				* Title														* Year			* Company					* Game ID		//
// ---------------------------------------------------------------------------------------------------------------------------------------------//
	{ _T("placeholder")	, _T("Empty Placeholder")									, _T("")		, _T("")					, 0x0000 },		//
	{ _T("nam1975")		, _T("NAM-1975")											, _T("1990")	, _T("SNK")					, 0x0001 },		//
	{ _T("bstars")		, _T("Baseball Stars Professional")							, _T("1991")	, _T("SNK")					, 0x0002 },		//
	{ _T("tpgolf")		, _T("Top Player's Golf")									, _T("1990")	, _T("SNK")					, 0x0003 },		//
	{ _T("mahretsu")	, _T("Mahjong Kyo Retsuden - Nishi Nihon Hen")				, _T("1990")	, _T("SNK")					, 0x0004 },		//
	{ _T("maglord")		, _T("Magician Lord")										, _T("1990")	, _T("ADK")					, 0x0005 },		//
	{ _T("ridhero")		, _T("Riding Hero")											, _T("1991")	, _T("SNK")					, 0x0006 },		//
	{ _T("alpham2")		, _T("Alpha Mission II / ASO II - Last Guardian")			, _T("1994")	, _T("SNK")					, 0x0007 },		//
	{ _T("ncombat")		, _T("Ninja Combat")										, _T("1990")	, _T("SNK/ADK")				, 0x0009 },		//
	{ _T("cyberlip")	, _T("Cyber-Lip")											, _T("1991")	, _T("SNK")					, 0x0010 },		//
	{ _T("superspy")	, _T("The Super Spy")										, _T("1990")	, _T("SNK")					, 0x0011 },		//
	{ _T("mutnat")		, _T("Mutation Nation")										, _T("1995")	, _T("SNK")					, 0x0014 },		//
	{ _T("sengoku")		, _T("Sengoku / Sengoku Denshou")							, _T("1994")	, _T("SNK")					, 0x0017 },		//
	{ _T("burningf")	, _T("Burning Fight")										, _T("1994")	, _T("SNK")					, 0x0018 },		//
	{ _T("lbowling")	, _T("League Bowling")										, _T("1994")	, _T("SNK")					, 0x0019 },		//
	{ _T("gpilots")		, _T("Ghost Pilots")										, _T("199


RRect(ui.RRect rrect) {
  final Float32List skRRect = Float32List(12);
  skRRect[0] = rrect.left;
  skRRect[1] = rrect.top;
  skRRect[2] = rrect.right;
  skRRect[3] = rrect.bottom;
  skRRect[4] = rrect.tlRadiusX;
  skRRect[5] = rrect.tlRadiusY;
  skRRect[6] = rrect.trRadiusX;
  skRRect[7] = rrect.trRadiusY;
  skRRect[8] = rrect.brRadiusX;
  skRRect[9] = rrect.brRadiusY;
  skRRect[10] = rrect.blRadiusX;
  skRRect[11] = rrect.blRadiusY;
  return skRRect;
}

// TODO(hterkelsen): Use a shared malloc'ed array for performance.
Float32List toOuterSkRect(ui.RRect rrect) {
  final Float32List skRect = Float32List(4);
  skRect[0] = rrect.left;
  skRect[1] = rrect.top;
  skRect[2] = rrect.right;
  skRect[3] = rrect.bottom;
  return skRect;
}

/// Encodes a list of offsets to CanvasKit-compatible point array.
///
/// Uses `CanvasKit.Malloc` to allocate storage for the points in the WASM
/// memory to avoid unnecessary copying. Unless CanvasKit takes ownership of
/// the list the returned list must be explicitly freed using
/// [free].
SkFloat32List toMallocedSkPoints(List<ui.Offset> points) {
  final int len = points.length;
  final SkFloat32List skPoints = mallocFloat32List(len * 2);
  final Float32List list = skPoints.toTypedArray();
  for (int i = 0; i < len; i++) {
    list[2 * i] = points[i].dx;
    list[2 * i + 1] = points[i].dy;
  }
  return skPoints;
}

/// Converts a list of [ui.Offset] into a flat list of points.
Float32List toFlatSkPoints(List<ui.Offset> points) {
  final int len = points.length;
  final Float32List result = Float32List(len * 2);
  for (int i = 0; i < len; i++) {
    result[2 * i] = points[i].dx;
    result[2 * i + 1] = points[i].dy;
  }
  return result;
}

/// Converts a list of [ui.Color] into a flat list of ints.
Uint32List toFlatColors(List<ui.Color> colors) {
  final int len = colors.length;
  final Uint32List result = Uint32List(len);
  for (int i = 0; i < len; i++) {
    result[i] = colors[i].value;
  }
  return result;
}

Uint16List toUint16List(List<int> ints) {
  final int len = ints.length;
  final Uint16List result = Uint16List(len);
  for (int i = 0; i < len; i++) {
    result[i] = ints[i];
  }
  return result;
}

@JS('window.flutterCanvasKit.PictureRecorder')
@staticInterop
class SkPictureRecorder {
  external factory SkPictureRecorder();
}

extension SkPictureRecorderExtension on SkPictureRecorder {
  @JS('beginRecording')
  external SkCanvas _beginRecording(
      JSFloat32Array bounds, JSBoolean computeBounds);
  SkCanvas beginRecording(Float32List bounds) =>
      _beginRecording(bounds.toJS, true.toJS);

  external SkPicture finishRecordingAsPicture();
  external JSVoid delete();
}

/// We do not use the `delete` method (which may be removed in the future anyway).
///
/// By Skia coding convention raw pointers should always be tre


        keyFieldType: $pb.PbFieldType.OS,
        valueFieldType: $pb.PbFieldType.OS,
        packageName: const $pb.PackageName('google.datastore.admin.v1beta1'))
    ..aOM<EntityFilter>(3, _omitFieldNames ? '' : 'entityFilter',
        subBuilder: EntityFilter.create)
    ..aOS(4, _omitFieldNames ? '' : 'outputUrlPrefix')
    ..hasRequiredFields = false;

  @$core.Deprecated('Using this can add significant overhead to your binary. '
      'Use [GeneratedMessageGenericExtensions.deepCopy] instead. '
      'Will be removed in next major version')
  ExportEntitiesRequest clone() =>
      ExportEntitiesRequest()..mergeFromMessage(this);
  @$core.Deprecated('Using this can add significant overhead to your binary. '
      'Use [GeneratedMessageGenericExtensions.rebuild] instead. '
      'Will be removed in next major version')
  ExportEntitiesRequest copyWith(
          void Function(ExportEntitiesRequest) updates) =>
      super.copyWith((message) => updates(message as ExportEntitiesRequest))
          as ExportEntitiesRequest;

  $pb.BuilderInfo get info_ => _i;

  @$core.pragma('dart2js:noInline')
  static ExportEntitiesRequest create() => ExportEntitiesRequest._();
  ExportEntitiesRequest createEmptyInstance() => create();
  static $pb.PbList<ExportEntitiesRequest> createRepeated() =>
      $pb.PbList<ExportEntitiesRequest>();
  @$core.pragma('dart2js:noInline')
  static ExportEntitiesRequest getDefault() => _defaultInstance ??=
      $pb.GeneratedMessage.$_defaultFor<ExportEntitiesRequest>(create);
  static ExportEntitiesRequest? _defaultInstance;

  /// Project ID against which to make the request.
  @$pb.TagNumber(1)
  $core.String get projectId => $_getSZ(0);
  @$pb.TagNumber(1)
  set projectId($core.String v) {
    $_setString(0, v);
  }

  @$pb.TagNumber(1)
  $core.bool hasProjectId() => $_has(0);
  @$pb.TagNumber(1)
  void clearProjectId() => clearField(1);

  /// Client-assigned labels.
  @$pb.TagNumber(2)
  $core.Map<$core.String, $core.String> get labels => $_getMap(1);

  /// Description of what data from the project is included in the export.
  @$pb.TagNumber(3)
  EntityFilter get entityFilter => $_getN(2);
  @$pb.TagNumber(3)
  set entityFilter(EntityFilter v) {
    setField(3, v);
  }

  @$pb.TagNumber(3)
  $core.bool hasEntityFilter() => $_has(2);
  @$pb.TagNumber(3)
  void clearEntityFilter() => clearField(3);
  @$pb.TagNumber(3)
  EntityFilter ensureEntityFilter() => $_ensure(2);

  ///  Location for the export metadata and data files.
  ///
  ///  The full resource URL of the external storage location. Currently, only
  ///  Google Cloud Storage is supported. So output_url_prefix should be of the
  ///  form: `gs://BUCKET_NAME[/NAMESPACE_PATH]`, where `BUCKET_NAME` is the
  ///  name of the Cloud Storage bucket and `NAMESPACE_PATH` is an optional Cloud
  ///  Storage namespace path (this is not a Cloud Datastore namespace). For more
  ///  information about Cloud Storage namespace paths, see
  ///  [Object name
  ///  considerations](https://cloud.google.com/storage/docs/naming#object-considerations).
  ///
  ///  The resulting files will be nested deeper than the specified URL prefix.
  ///  The final output URL will be provided in the
  ///  [google.datastore.admin.v1beta1.ExportEntitiesResponse.output_url][google.datastore.a


       exercise: true,
      },
    })
  },

  create: (data: WorkoutSetPayload) => {
    const repo = DATASOURCE.getRepository(WorkoutSet)
    return repo.save(data)
  },

  update: ({uuid, data}: {uuid: string; data: WorkoutSetPayload}) => {
    const repo = DATASOURCE.getRepository(WorkoutSet)
    return repo.update(uuid, data)
  },

  remove: ({uuid}: {uuid: string}) => {
    const repo = DATASOURCE.getRepository(WorkoutSet)
    return repo.delete(uuid)
  },

  workoutDays: (): Promise<{date: string; count: number}[]> => {
    const repo = DATASOURCE.getRepository(WorkoutSet)

    return repo
      .createQueryBuilder('ws')
      .select('date(ws.executedAt)', 'date')
      .addSelect('COUNT(ws.uuid)', 'count')
      .groupBy('date(ws.executedAt)')
      .getRawMany()
  },

  workoutSetsForDay: ({date}: {date: string}) => {
    const repo = DATASOURCE.getRepository(WorkoutSet)
    return repo
      .createQueryBuilder('ws')
      .leftJoinAndSelect('ws.exercise', 'exercise')
      .where('date(ws.executedAt) = date(:date)', {date})
      .orderBy('ws.executedAt', 'ASC')
      .getMany()
  },
}
import { GetCarRepository } from '@/data/protocols/db/get-car-repository'
import { UpdateCarRepository } from '@/data/protocols/db/update-car-repository'
import { CarModel } from '@/domain/models/car'
import { UpdateCarModel } from '@/domain/usecases/car'
import { DbUpdateCar } from './db-update-car'

const makeFakeCarWithId = () => {
  const fakeCar = {
    id: 'valid_id',
    brand: 'any_brand',
    model: 'any_model',
    version: 'any_version',
    year: 2000,
    mileage: 10000,
    gearbox: 'valid_gear_box',
    price: 50000
  }

  return fakeCar
}

const makeFakeCar = () => {
  const fakeCar = {
    brand: 'any_brand',
    model: 'any_model',
    version: 'any_version',
    price: 50000
  }

  return fakeCar
}

const makeGetCarRepository = (): GetCarRepository => {
  class GetCarRepositoryStub implements GetCarRepository {
    async get(id: string): Promise<CarModel> {
      const fakeCar = makeFakeCarWithId()
      return new Promise(resolve => resolve(fakeCar))
    }
  }
  return new GetCarRepositoryStub()
}

const makeAddUpdateCarRepository = (): UpdateCarRepository => {
  class UpdateCarRepositoryStub implements UpdateCarRepository {
    async update(carId: string, carData: UpdateCarModel): Promise<void> {
      return new Promise(resolve => resolve())
    }
  }
  return new UpdateCarRepositoryStub()
}

type SutTypes = {
  sut: DbUpdateCar
  updateCarRepositoryStub: UpdateCarRepository
  getCarRepositoryStub: GetCarRepository
}

const makeSut = (): SutTypes => {
  const updateCarRepositoryStub = makeAddUpdateCarRepository()
  const getCarRepositoryStub = makeGetCarRepository()
  const sut = new DbUpdateCar(updateCarRepositoryStub, getCarRepositoryStub)

  return {


	float sigmas = GV3::get<float>("harris.sigmas", 2.0, 1);
	harris_like<HarrisScore,PosInserter>(i, c, N, blur, sigmas);
}

void ShiTomasiDetect::operator()(const CVD::Image<CVD::byte>& i, std::vector<CVD::ImageRef>& c, unsigned int N) const
{
	float blur = GV3::get<float>("shitomasi.blur", 2.5, 1);
	float sigmas = GV3::get<float>("shitomasi.sigmas", 2.0, 1);
	harris_like<ShiTomasiScore, PosInserter>(i, c, N, blur, sigmas);
}
#include "tests/test_helper.h"
#include <TooN/gauss_jordan.h>

template<int C, int D>
void test(Matrix<C, D> m)
{
	gauss_jordan(m);

	cout << setprecision(10) << m << endl;
}

int main()
{
	Matrix<10, 20> m;

	m.slice<0,10,10,10>() = Identity;
	m.slice<0,0,10,10>()= Data(
			0.34797399, 0.99949284, 0.79089508, 0.77106323, 0.42008832, 0.34115353, 0.82386306, 0.30355494, 0.43675765, 0.14701409,
			0.79196638, 0.89361322, 0.01607914, 0.80605940, 0.65770431, 0.78196315, 0.72096826, 0.72992854, 0.59231807, 0.29441620,
			0.87756469, 0.13676905, 0.24987969, 0.70330337, 0.14679752, 0.24212448, 0.54797729, 0.39780385, 0.28859592, 0.56037868,
			0.28673516, 0.50161131, 0.68057626, 0.49395349, 0.40353230, 0.87453874, 0.40320916, 0.81494509, 0.08367898, 0.30109605,
			0.63965121, 0.81584239, 0.41207698, 0.62649440, 0.17279511, 0.20152095, 0.68882719, 0.25012805, 0.59680722, 0.08332985,
			0.28651408, 0.79504551, 0.33326702, 0.26440896, 0.95748781, 0.22512739, 0.01047784, 0.85470217, 0.85677470, 0.65734012,
			0.59521552, 0.78840112, 0.96281698, 0.31079097, 0.31028381, 0.10117889, 0.87224212, 0.29233044, 0.63348397, 0.45734703,
			0.76090196, 0.19765961, 0.34467370, 0.13664008, 0.03025330, 0.04633244, 0.85239184, 0.51009616, 0.29205931, 0.01302757,
			0.74295611, 0.33527418, 0.62969038, 0.50725507, 0.64402412, 0.89390381, 0.59720718, 0.74400470, 0.98612919, 0.53410648,
			0.93191033, 0.22050625, 0.78088493, 0.06762009, 0.56923140, 0.24980766, 0.74376115, 0.14729345, 0.02183219, 0.42504135);

	test(m);

	Matrix<> md = m;
	test(md);

	int id_failures=0;
	double max_error=0;

	for(int i=0; i < 1000; i++)
	{
		int s = 1 + xor128u() % 99;
		Matrix<> m(s, s*2);

		for(int r=0; r < s; r++)


BG() {
        Assert.assertFalse(myActivity.multiAdRequestCompleted)
        myActivity.load(bgTask = true)
        //        Assert.assertTrue(myActivity.multiAdRequestCompleted);
        myActivity.adRequest = null
        onView(isRoot()).check(matches(anything()))
        val adUnitList = myActivity.anMultiAdRequest!!.getAdUnitList()
        for (adWeakReference in adUnitList) {
            val ad = adWeakReference.get()
            if (ad != null) {
                Assert.assertFalse(adWeakReference.get() === myActivity.adRequest)
            }
        }
        Assert.assertTrue(
            "MultiAdRequest is still in progress, Idling Resource isn't working properly",
            myActivity.multiAdRequestCompleted
        )
    }

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

package appnexus.com.appnexussdktestapp.placement.banner

import android.content.Intent
import android.content.res.Resources
import androidx.test.espresso.Espresso
import androidx.test.espresso.IdlingPolicies
import androidx.test.espresso.IdlingRegistry
import androidx.test.espresso.action.ViewActions
import androidx.test.espresso.assertion.ViewAssertions
import androidx.test.espresso.assertion.ViewAssertions.matches
import androidx.test.espresso.intent.Intents
import androidx.test.espresso.intent.matcher.IntentMatchers
import androidx.test.espresso.intent.rule.IntentsTestRule
import androidx.test.espresso.matcher.ViewMatchers
import androidx.test.runner.AndroidJUnit4
import appnexus.com.appnexussdktestapp.BannerActivity
import appnexus.com.appnexussdktestapp.R
import appnexus.com.appnexussdktestapp.util.SizeMatcher
import com.appnexus.opensdk.AdActivity
import com.appnexus.opensdk.XandrAd
import com.appnexus.opensdk.utils.ViewUtil
import com.microsoft.appcenter.espresso.Factory
import org.junit.*
import org.junit.runner.RunWith
import java.util.concurrent.TimeUnit

/**
 * Instrumented test, which will execute on an Android device.
 *
 * See [testing documentation](http://d.android.com/tools/testing).
 */
@RunWith(AndroidJUnit4::class)
class InAppBrowserUITest {
    val Int.dp: Int
        get() = (this / Resources.getSystem().displayMetrics.density).toInt()
    val Int.px: Int
        get() = (this * Resources.getSystem().displayMetrics.density).toInt()

    @get:Rule
    var reportHelper = Factory.getReportHelper()

    @Rule
    @JvmField
    var mActivityTestRule = IntentsTestRule(BannerActivity::class.java, false, false)

    lateinit var bannerActivity: BannerActivity

    @Before
    fun setup() {
        XandrAd.init(123, null, false, null)
        IdlingPolicies.setMasterPolicyTimeout(1, TimeUnit.MINUTES)
        IdlingPolicies.setIdlingResourceTimeout(1, TimeUnit.MINUTES)
        var intent = Intent()
        mActivityTestRule.launchActivity(in


 else if (content.length > 1) {
            // create TextChar for each character
            let textCharsToInsert: Array<TextChar> = []
            for (let i = 0; i < content.length; i++) {
                textCharsToInsert.push(new TextChar(content.charAt(i)))
            }
            // insert into textChars
            this.textChars.splice(index, 0, ...textCharsToInsert)
        }

        // update visibleTextChars
        this.visibleTextChars = this.textChars.filter(textChar => !textChar.isHidden())

    }

    /**
     * @return a string of text to display
     */
    getTextValue(): string {
        if (this.visibleTextChars.length === 0) return ''
        return this.visibleTextChars.map(textChar => textChar.content).reduce((str1, str2) => str1.concat(str2))
    }

}

const textCharManager = new TextCharManager();
textCharManager.createTextChar(0, 'initial data')

export default textCharManager;
let container: HTMLElement|null = null;
let refCount = 0;

/**
 * Temporarily appends node to DOM.
 */
export function append(node: HTMLElement): { dispose(): void; } {
    refCount++;
    if (!container) {
        container = document.createElement('div');
        container.style.position = 'absolute';
        container.style.left = '-99999px';
        container.style.top = '-99999px';
        document.body.appendChild(container);
    }

    container.appendChild(node);

    const savedContainer = container;
    let disposed = false;

    return {
        dispose() {
            if (disposed) {
                return;
            }

            disposed = true;
            savedContainer.removeChild(node);
            if (--refCount === 0) {
                savedContainer.parentElement!.removeChild(savedContainer);
                container = null;
            }
        }
    };
}
import { Controller, Get, Param } from '@nestjs/common';

type Username = {
    name: string,
    age: number
}

/*
 * Controller = handles incoming request
 */

@Controller('/api') //decorators
export class AppController {

    text: string
    num: number
    arr: Username[]

    @Get('/name/:nama')
    getByName(@Param('nama') nama: string): object{

        //
        this.text = 'hello world'
        this.num = 23
        this.arr = [{name:'stephen', age:20}]

        //
        const title: string = 'hi there'
        const data: string[] = this.arr.map(item => item.name + item.age)

        let response: object;

        (nama === 'imam') ? response = { data } : response = { title }

        return response

    }

    @Get('/filter')
    getByFilter(): string{

        const filter: string = 'Hi Filter'

        return filter
    }

    @Get('/number')
    async getByNumber(){

        let data: number[] = []

        for(let i = 1; i < 100000; i++){
            data.push(i)
        }

        return await data
    }

}declare class ColorSamplers {
    readonly [index: number]: ColorSampler
    /** @readonly The number of elements in the ColorSamplers collection. */
    readonly length: number
    /** @readonly The containing document. */
    readonly parent: Document
    /** @readonly The class name of the referenced ColorSamplers object. */
    readonly type: string

    /**
     * Creates a new color sampler object and adds it to this collection.


= toproto.AttributePaths(testCase.in)

			// Protocol Buffers generated types must have unexported fields
			// ignored or cmp.Diff() will raise an error. This is easier than
			// writing a custom Comparer for each type, which would have no
			// benefits.
			diffOpts := cmpopts.IgnoreUnexported(
				tfplugin5.AttributePath{},
				tfplugin5.AttributePath_Step{},
			)

			if diff := cmp.Diff(got, testCase.expected, diffOpts); diff != "" {
				t.Errorf("unexpected difference: %s", diff)
			}
		})
	}
}

func TestAttributePath_Step(t *testing.T) {
	t.Parallel()

	testCases := map[string]struct {
		in       tftypes.AttributePathStep
		expected *tfplugin5.AttributePath_Step
	}{
		"nil": {
			in:       nil,
			expected: nil,
		},
		"AttributeName": {
			in: tftypes.AttributeName("test"),
			expected: &tfplugin5.AttributePath_Step{
				Selector: &tfplugin5.AttributePath_Step_AttributeName{
					AttributeName: "test",
				},
			},
		},
		"ElementKeyInt": {
			in: tftypes.ElementKeyInt(123),
			expected: &tfplugin5.AttributePath_Step{
				Selector: &tfplugin5.AttributePath_Step_ElementKeyInt{
					ElementKeyInt: 123,
				},
			},
		},
		"ElementKeyString": {
			in: tftypes.ElementKeyString("test"),
			expected: &tfplugin5.AttributePath_Step{
				Selector: &tfplugin5.AttributePath_Step_ElementKeyString{
					ElementKeyString: "test",
				},
			},
		},
		"ElementKeyValue": {
			in:       tftypes.ElementKeyValue(tftypes.NewValue(tftypes.String, "test")),
			expected: nil,
		},
	}

	for name, testCase := range testCases {
		t.Run(name, func(t *testing.T) {
			t.Parallel()

			got := toproto.AttributePath_Step(testCase.in)

			// Protocol Buffers generated types must have unexported fields
			// ignored or cmp.Diff() will raise an error. This is easier than
			// writing a custom Comparer for each type, which would have no
			// benefits.
			diffOpts := cmpopts.IgnoreUnexported(
				tfplugin5.AttributePath_Step{},
			)

			if diff := cmp.Diff(got, testCase.expected, diffOpts); diff != "" {
				t.Errorf("unexpected difference: %s", diff)
			}
		})
	}
}

func TestAttributePath_Steps(t *testing.T) {
	t.Parallel()

	testCases := map[string]struct {
		in       []tftypes.AttributePathStep
		expected []*tfplugin5.AttributePath_Step
	}{
		"nil": {
			in:       nil,
			expected: []*tfplugin5.AttributePath_Step{},
		},
		"zero": {
			in:       []tftypes.AttributePathStep{},
			expected: []*tfplugin5.AttributePath_Step{},
		},
		"one": {
			in: []tftypes.AttributePathStep{
				tftypes.AttributeName("test"),
			},
			expected: []*tfplugin5.AttributePath_Step{
				{
					Selector: &tfplugin5.AttributePath_Step_AttributeName{
						AttributeName: "test",
					},
				},
			},
		},
		"two": {
			in: []tftypes.AttributePathStep{
				tftypes.AttributeName("test1"),
				tftypes.AttributeName("test2"),
			},
			expected: []*tfplugin5.AttributePath_Step{
				{
					Selector: &tfplugin5.AttributePath_Step_AttributeName{
						Attribute


	{ 15153, 32, 2, 16, "Nocturnal Cloak" },
	{ 15154, 33, 2, 6, "Nocturnal Sash" },
	{ 15155, 34, 2, 10, "Nocturnal Gloves" },
	{ 15156, 38, 2, 1, "Nocturnal Cap" },
	{ 15157, 36, 2, 7, "Nocturnal Leggings" },
	{ 15158, 35, 2, 3, "Nocturnal Shoulder Pads" },
	{ 15159, 37, 2, 5, "Nocturnal Tunic" },
	{ 15160, 34, 2, 9, "Nocturnal Wristbands" },
	{ 15161, 38, 2, 6, "Imposing Belt" },
	{ 15162, 40, 2, 8, "Imposing Boots" },
	{ 15163, 38, 2, 9, "Imposing Bracers" },
	{ 15164, 42, 2, 5, "Imposing Vest" },
	{ 15165, 37, 2, 16, "Imposing Cape" },
	{ 15166, 40, 2, 10, "Imposing Gloves" },
	{ 15167, 43, 2, 1, "Imposing Bandana" },
	{ 15168, 40, 2, 7, "Imposing Pants" },
	{ 15169, 39, 2, 3, "Imposing Shoulders" },
	{ 15170, 47, 2, 5, "Potent Armor" },
	{ 15171, 45, 2, 8, "Potent Boots" },
	{ 15172, 42, 2, 9, "Potent Bands" },
	{ 15173, 41, 2, 16, "Potent Cape" },
	{ 15174, 45, 2, 10, "Potent Gloves" },
	{ 15175, 46, 2, 1, "Potent Helmet" },
	{ 15176, 45, 2, 7, "Potent Pants" },
	{ 15177, 44, 2, 3, "Potent Shoulders" },
	{ 15178, 42, 2, 6, "Potent Belt" },
	{ 15179, 52, 2, 5, "Praetorian Padded Armor" },
	{ 15180, 48, 2, 6, "Praetorian Girdle" },
	{ 15181, 50, 2, 8, "Praetorian Boots" },
	{ 15182, 46, 2, 9, "Praetorian Wristbands" },
	{ 15183, 45, 2, 16, "Praetorian Cloak" },
	{ 15184, 49, 2, 10, "Praetorian Gloves" },
	{ 15185, 52, 2, 1, "Praetorian Coif" },
	{ 15186, 50, 2, 7, "Praetorian Leggings" },
	{ 15187, 49, 2, 3, "Praetorian Pauldrons" },
	{ 15188, 52, 2, 9, "Grand Armguards" },
	{ 15189, 55, 2, 8, "Grand Boots" },
	{ 15190, 50, 2, 16, "Grand Cloak" },
	{ 15191, 52, 2, 6, "Grand Belt" },
	{ 15192, 55, 2, 10, "Grand Gauntlets" },
	{ 15193, 57, 2, 1, "Grand Crown" },
	{ 15194, 56, 2, 7, "Grand Legguards" },
	{ 15195, 57, 2, 5, "Grand Breastplate" },
	{ 15196, 0, 1, 19, "Private's Tabard" },
	{ 15197, 0, 1, 19, "Scout's Tabard" },
	{ 15198, 0, 1, 19, "Knight's Colors" },
	{ 15199, 0, 1, 19, "Stone Guard's Herald" },
	{ 15200, 30, 3, 2, "Senior Sergeant's Insignia" },
	{ 15202, 0, 2, 7, "Wildkeeper Leggings" },
	{ 15203, 0, 2, 7, "Guststorm Legguards" },
	{ 15204


%l3
ld [%l3], %l7
st %l7, [%l3]
add %l3, %l6, %l3
ld [%l3], %l7
st %l7, [%l3]

P5129: !ST [2] (maybe <- 0x85000b) (Int)
stw   %l4, [%i0 + 12 ]
add   %l4, 1, %l4

P5130: !DWST [15] (maybe <- 0x489fff80) (FP)
! 0 th moved, current_fp_src=20
fmovs  %f16, %f20
fadds  %f16, %f17, %f16
std %f20, [%i3 + 192]

P5131: !ST [9] (maybe <- 0x85000c) (Int)
stw   %l4, [%i1 + 512 ]
add   %l4, 1, %l4

P5132: !DWST [13] (maybe <- 0x489fffa0) (FP)
! 0 th moved, current_fp_src=20
fmovs  %f16, %f20
fadds  %f16, %f17, %f16
std %f20, [%i3 + 64]

P5133: !PREFETCH [2] (Int)
prefetch [%i0 + 12], 1

P5134: !PREFETCH [14] (Int)
prefetch [%i3 + 128], 1

P5135: !DWST [6] (maybe <- 0x85000d) (Int)
mov %l4, %l6
sllx %l6, 32, %l6
add   %l4, 1, %l4
mov %l4, %l7
or %l6, %l7, %l6
stx %l6, [%i1 + 80 ]
add   %l4, 1, %l4

P5136: !PREFETCH [5] (Int)
prefetch [%i1 + 76], 1

P5137: !MEMBAR (Int)
membar #StoreLoad

P5138: !DWST [0] (maybe <- 0x85000f) (Int)
mov %l4, %l6
sllx %l6, 32, %l6
add   %l4, 1, %l4
mov %l4, %l7
or %l6, %l7, %l6
stx %l6, [%i0 + 0 ]
add   %l4, 1, %l4

P5139: !MEMBAR (Int)
membar #StoreLoad

P5140: !LD [11] (Int)
lduw [%i2 + 64], %l6
! move %l6(lower) -> %o1(lower)
or %l6, %o1, %o1

P5141: !CAS [5] (maybe <- 0x850011) (Int)
add %i1, 76, %l7
lduw [%l7], %o2
mov %o2, %l3
! move %l3(lower) -> %o2(upper)
sllx %l3, 32, %o2
mov %l4, %l6
cas [%l7], %l3, %l6
! move %l6(lower) -> %o2(lower)
sllx %l6, 32, %l7
srlx %l7, 32, %l7
or %l7, %o2, %o2
add   %l4, 1, %l4

P5142: !DWST [9] (maybe <- 0x850012) (Int)
mov %l4, %l6
sllx %l6, 32, %l6
stx %l6, [%i1 + 512 ]
add   %l4, 1, %l4

P5143: !LD [2] (FP)
ld [%i0 + 12], %f


 #1
   addq.w   #6,sp
   rts

out_title
   lea   title(pc),a0
   bra.s   out_mess

get_fname
   pea   filename(pc)
   move.w   #10,-(sp)
   trap   #1
   addq.w   #6,sp
   lea   filename(pc),a0
   moveq   #0,d0
   move.b   1(a0),d0
   clr.b   2(a0,d0)
   rts

create_file
   clr.w   -(sp)
   pea   filename+2(pc)
   move.w   #60,-(sp)
   trap   #1
   addq.w   #8,sp
   move.w   d0,handle
   rts

open_file
   clr.w   -(sp)
   pea   filename+2(pc)
   move.w   #61,-(sp)
   trap   #1
   addq.w   #8,sp
   move.w   d0,handle
   rts

read_file
   pea   emptyram(pc)
   pea   1000000
   move.w   handle,-(sp)
   move.w   #63,-(sp)
   trap   #1
   add.w   #12,sp
   btst.l   #0,d0
   beq.s   .ok
   addq.l   #1,d0
.ok   move.l   d0,old_size
   rts

write_file
   pea   (a6)
   move.l   new_size,-(sp)
   move.w   handle,-(sp)
   move.w   #64,-(sp)
   trap   #1
   add.w   #12,sp
   rts

close_file
   move.w   handle,-(sp)
   move.w   #62,-(sp)
   trap   #1
   addq.w   #4,sp
   rts

   SECTION   DATA

mask   dc.b   $e0
   even

title
   dc.b   'BORIS SAMPLE PACKER II',13,10
   dc.b   'Version 2.0',13,10
   dc.b   189,' 1990',13,10
   dc.b   'By Boris of "Persistence of Vision"',13,10
   dc.b   10,'Filename ? ',0
   even

pack_mess
   dc.b   13,10,10,'Packing...',0
   even

save_mess
   dc.b   13,10,'Save as ? ',0
   even

done_mess
   dc.b   13,10,'Done.',13,10,0
   even

filename
   dc.b   99,0
   ds.b   100

   SECTION   BSS

old_size   ds.l   1
new_size   ds.l   1

handle      ds.w   1

header      ds.b   10
emptyram   even


// 因为union会对字段进行隐式排序，而order by的字段一定是union的字段，所以不需要额外对union语句的order by等函数的字段进行检查
		if stmt.SelectList == nil {
			return nil
		}
		for _, s := range stmt.SelectList.Selects {
			if s.From == nil || s.From.TableRefs == nil {
				continue
			}
			t, ok := s.From.TableRefs.Left.(*ast.TableSource)
			if ok && t != nil && s.From.TableRefs.Right == nil {
				temp, ok := t.Source.(*ast.TableName)
				if ok {
					singleTable = temp

					// 收集select的普通目标列
					if s.Fields != nil {
						for _, field := range s.Fields.Fields {
							if c, ok := field.Expr.(*ast.ColumnNameExpr); ok && c.Name != nil {
								checkColumns = append(checkColumns, col{
									Table:   temp,
									ColName: c.Name.Name.L,
								})
							}
						}
					}
				}
			}
			gatherColFromSelectStmt(s, singleTable) // 收集group by、distinct里的列
			gatherColFromOrderByClause(s.OrderBy, singleTable)
		}
	case *ast.DeleteStmt:
		if stmt.TableRefs == nil || stmt.TableRefs.TableRefs == nil {
			return nil
		}
		t, ok := stmt.TableRefs.TableRefs.Left.(*ast.TableSource)
		if ok && t != nil && stmt.TableRefs.TableRefs.Right == nil {
			temp, ok := t.Source.(*ast.TableName)
			if ok {
				singleTable = temp
			}
		}
		gatherColFromOrderByClause(stmt.Order, singleTable)
	case *ast.UpdateStmt:
		if stmt.TableRefs == nil || stmt.TableRefs.TableRefs == nil {
			return nil
		}
		t, ok := stmt.TableRefs.TableRefs.Left.(*ast.TableSource)
		if ok && t != nil && stmt.TableRefs.TableRefs.Right == nil {
			temp, ok := t.Source.(*ast.TableName)
			if ok {
				singleTable = temp
			}
		}
		gatherColFromOrderByClause(stmt.Order, singleTable)
	default:
		return nil
	}

	for _, column := range checkColumns {
		if err := checkColLen(column); err != nil {
			return err
		}
	}

	if len(invalidCols) > 0 {
		addResult(input.Res, input.Rule, input.Rule.Name, strings.Join(invalidCols, ","))
	}

	return nil
}

func checkAffectedRows(input *RuleHandlerInput) error {

	switch input.Node.(type) {
	case *ast.UpdateStmt, *ast.DeleteStmt:
	default:
		return nil
	}

	affectCount, err := util.GetAffectedRowNum(
		context.TODO(), input.Node.Text(), input.Ctx.GetExecutor(), input.Ctx.GetExecutionPlan)
	if err != nil {
		log.NewEntry().Errorf("rule: %v; SQL: %v; get affected row number failed: %v", input.Rule.Name, input.Node.Text(), err)
		return nil
	}

	affectCountLimit := input.Rule.Params.GetParam(DefaultSingleParamKeyName).Int()
	if affectCount > int64(affectCountLimit) {
		addResult(input.Res, input.Rule, input.Rule.Name, affectCount, affectCountLimit)
	}

	return nil
}

// NOTE: ParamMarkerExpr is actually "?".
// ref: https://docs.pingcap.com/zh/tidb/dev/expression-syntax#%E8%A1%A8%E8%BE%BE%E5%BC%8F%E8%AF%AD%E6%B3%95-expression-syntax
// re


using UserService.Domain.Entities.Clients;
using UserService.Domain.Entities.Companies;
using UserService.Domain.Enums;

namespace UserService.Application.DTOs.Users;

public class UserUpdateDto
{
    public string FullName { get; set; }

    p


%v0
	vfaef	%v0, %v31, %v0
	vfaef	%v15, %v0, %v0
	vfaef	%v31, %v0, %v0
	vfaef	%v18, %v3, %v20, 4
	vfaef	%v18, %v3, %v20, 15
	vfaefs	%v18, %v3, %v20, 8
	vfaezf	%v18, %v3, %v20, 4
	vfaezfs	%v18, %v3, %v20, 8
	vfaezfs	%v18, %v3, %v20, 15

#CHECK: vfaeh   %v0, %v0, %v0, 0        # encoding: [0xe7,0x00,0x00,0x00,0x10,0x82]
#CHECK: vfaeh   %v0, %v0, %v0, 0        # encoding: [0xe7,0x00,0x00,0x00,0x10,0x82]
#CHECK: vfaeh   %v0, %v0, %v0, 12       # encoding: [0xe7,0x00,0x00,0xc0,0x10,0x82]
#CHECK: vfaeh   %v0, %v0, %v15, 0       # encoding: [0xe7,0x00,0xf0,0x00,0x10,0x82]
#CHECK: vfaeh   %v0, %v0, %v31, 0       # encoding: [0xe7,0x00,0xf0,0x00,0x12,0x82]
#CHECK: vfaeh   %v0, %v15, %v0, 0       # encoding: [0xe7,0x0f,0x00,0x00,0x10,0x82]
#CHECK: vfaeh   %v0, %v31, %v0, 0       # encoding: [0xe7,0x0f,0x00,0x00,0x14,0x82]
#CHECK: vfaeh   %v15, %v0, %v0, 0       # encoding: [0xe7,0xf0,0x00,0x00,0x10,0x82]
#CHECK: vfaeh   %v31, %v0, %v0, 0       # encoding: [0xe7,0xf0,0x00,0x00,0x18,0x82]
#CHECK: vfaeh   %v18, %v3, %v20, 4      # encoding: [0xe7,0x23,0x40,0x40,0x1a,0x82]
#CHECK: vfaeh   %v18, %v3, %v20, 15     # encoding: [0xe7,0x23,0x40,0xf0,0x1a,0x82]
#CHECK: vfaehs  %v18, %v3, %v20, 8      # encoding: [0xe7,0x23,0x40,0x90,0x1a,0x82]
#CHECK: vfaezh  %v18, %v3, %v20, 4      # encoding: [0xe7,0x23,0x40,0x60,0x1a,0x82]
#CHECK: vfaezhs %v18, %v3, %v20, 8      # encoding: [0xe7,0x23,0x40,0xb0,0x1a,0x82]
#CHECK: vfaezhs %v18, %v3, %v20, 15     # encoding: [0xe7,0x23,0x40,0xf0,0x1a,0x82]

	vfaeh	%v0, %v0, %v0
	vfaeh	%v0, %v0, %v0, 0
	vfa


identity(_i3.U64Codec.codec),
  );

  /// WETEE Root account id.
  /// 组织最高权限 id
  _i5.Future<_i2.AccountId32?> account(
    BigInt key1, {
    _i1.BlockHash? at,
  }) async {
    final hashedKey = _account.hashedKeyFor(key1);
    final bytes = await __api.getStorage(
      hashedKey,
      at: at,
    );
    if (bytes != null) {
      return _account.decodeValue(bytes);
    }
    return null; /* Nullable */
  }

  /// WETEE Root account id.
  /// 组织最高权限 id
  _i5.Future<bool?> closeDao(
    BigInt key1, {
    _i1.BlockHash? at,
  }) async {
    final hashedKey = _closeDao.hashedKeyFor(key1);
    final bytes = await __api.getStorage(
      hashedKey,
      at: at,
    );
    if (bytes != null) {
      return _closeDao.decodeValue(bytes);
    }
    return null; /* Nullable */
  }

  /// sudo模块调用历史
  _i5.Future<List<_i4.SudoTask>> sudoTasks(
    BigInt key1, {
    _i1.BlockHash? at,
  }) async {
    final hashedKey = _sudoTasks.hashedKeyFor(key1);
    final bytes = await __api.getStorage(
      hashedKey,
      at: at,
    );
    if (bytes != null) {
      return _sudoTasks.decodeValue(bytes);
    }
    return []; /* Default */
  }

  /// Returns the storage key for `account`.
  _i6.Uint8List accountKey(BigInt key1) {
    final hashedKey = _account.hashedKeyFor(key1);
    return hashedKey;
  }

  /// Returns the storage key for `closeDao`.
  _i6.Uint8List closeDaoKey(BigInt key1) {
    final hashedKey = _closeDao.hashedKeyFor(key1);
    return hashedKey;
  }

  /// Returns the storage key for `sudoTasks`.
  _i6.Uint8List sudoTasksKey(BigInt key1) {
    final hashedKey = _sudoTasks.hashedKeyFor(key1);
    return hashedKey;
  }

  /// Returns the storage map key prefix for `account`.
  _i6.Uint8List accountMapPrefix() {
    final hashedKey = _account.mapPrefix();
    return hashedKey;
  }

  /// Returns the storage map key prefix for `closeDao`.
  _i6.Uint8List closeDaoMapPrefix() {
    final hashedKey = _closeDao.mapPrefix();
    return hashedKey;
  }

  /// Returns the storage map key prefix for `sudoTasks`.
  _i6.Uint8List sudoTasksMapPrefix() {
    final hashedKey = _sudoTasks.mapPrefix();
    return hashedKey;
  }
}

class Txs {
  const Txs();

  /// Execute external transactions as root
  /// 以 root 账户执行函数
  _i7.RuntimeCall sudo({
    required BigInt daoId,
    required _i7.RuntimeCall call,
  }) {
    final _call = _i8.Call.values.sudo(
      daoId: daoId,
      call: call,
    );
    return _i7.RuntimeCall.values.weTEESudo(_call);
  }

  /// set sudo account
  /// 设置超级用户账户
  _i7.RuntimeCall setSudoAccount({
    required Bi


/*
 * Copyright (C) 2010 David Conrad
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "libavcodec/bytestream.h"
#include "avformat.h"
#include "internal.h"
#include "oggdec.h"

static int skeleton_header(AVFormatContext *s, int idx)
{
    struct ogg *ogg = s->priv_data;
    struct ogg_stream *os = ogg->streams + idx;
    AVStream *st = s->streams[idx];
    uint8_t *buf = os->buf + os->pstart;
    int version_major, version_minor;
    int64_t start_num, start_den;
    uint64_t start_granule;
    int target_idx, start_time;

    strcpy(st->codec->codec_name, "skeleton");
    st->codec->codec_type = AVMEDIA_TYPE_DATA;

    if ((os->flags & OGG_FLAG_EOS) && os->psize == 0)
        return 1;

    if (os->psize < 8)
        return -1;

    if (!strncmp(buf, "fishead", 8)) {
        if (os->psize < 64)
            return -1;

        version_major = AV_RL16(buf+8);
        version_minor = AV_RL16(buf+10);

        if (version_major != 3 && version_major != 4) {
            av_log(s, AV_LOG_WARNING, "Unknown skeleton version %d.%d\n",
                   version_major, version_minor);
            return -1;
        }

        // This is the overall start time. We use it for the start time of
        // of the skeleton stream since if left unset lavf assumes 0,
        // which we don't want since skeleton is timeless
        // FIXME: the real meaning of this field is "start playback at
        // this time which can be in the middle of a packet
        start_num = AV_RL64(buf+12);
        start_den = AV_RL64(buf+20);

        if (start_den > 0 && start_num > 0) {
            int base_den;
            av_reduce(&start_time, &base_den, start_num, start_den, INT_MAX);
            avpriv_set_pts_info(st, 64, 1, base_den);
            os->lastpts =
            st->start_time = start_time;
        }
    } else if (!strncmp(buf, "fisbone", 8)) {
        if (os->psize < 52)
            return -1;

        target_idx = ogg_find_stream(ogg, AV_RL32(buf+12));
        start_granule = AV_RL64(buf+36);
        if (target_idx < 0) {
            av_log(s, AV_LOG_WARNING, "Serial number in fisbone doesn't match any stream\n");
            return 1;
        }
        os = ogg->streams + target_idx;
        if (os->start_granule != OGG_NOGRANULE_VALUE) {
            av_log(s, AV_LOG_WARNING, "Multiple fisbone for the same stream\n");
            return 1;
        }
        if (start_granule != OGG_NOGRANULE_VALUE) {
            os->start_granule = start_granule;
        }
    }

    return 1;
}

const struct ogg_codec ff_skeleton_codec = {
    .magic = "fishead",
    .magicsize = 8,
    .header = skeleton_header,
    .nb_header = 0,
};


 enough capacity to support the DNS application pods and ensure that the application has the correct tolerations to schedule against the capacity. If running a cluster with Fargate, ensure that you have a [fargate profile](https://docs.aws.amazon.com/eks/latest/userguide/fargate-profile.html) that selects against your DNS application pods.

### Karpenter Role names exceeding 64-character limit

If you use a tool such as AWS CDK to generate your Kubernetes cluster name, when you add Karpenter to your cluster you could end up with a cluster name that is too long to incorporate into your KarpenterNodeRole name (which is limited to 64 characters).

Node role names for Karpenter are created in the form `KarpenterNodeRole-${Cluster_Name}` in the [Create the KarpenterNode IAM Role]({{<ref "./getting-started/getting-started-with-karpenter/#create-the-karpenternode-iam-role" >}}) section of the getting started guide.
If a long cluster name causes the Karpenter node role name to exceed 64 characters, creating that object will fail.

Keep in mind that `KarpenterNodeRole-` is just a recommendation from the getting started guide.
Instead of using the eksctl role, you can shorten the name to anything you like, as long as it has the right permissions.

### Unknown field in NodePool or EC2NodeClass spec

If you are upgrading from an older version of Karpenter, there may have been changes in the CRD between versions. Attempting to utilize newer functionality which is surfaced in newer versions of the CRD may result in the following error message:

```
Error from server (BadRequest): error when creating "STDIN": NodePool in version "v1" cannot be handled as a NodePool: strict decoding error: unknown field "spec.template.spec.nodeClassRef.foo"
```

If you see this error, you can solve the problem by following the [Custom Resource Definition Upgrade Guidance](../upgrade-guide/#custom-resource-definition-crd-upgrades).

Info on whether there has been a change to the CRD between versions of Karpenter can be found in the [Release Notes](../upgrade-guide/#released-upgrade-notes)

### Unable to schedule pod due to insufficient node group instances

`0.16.0` changed the default replicas from 1 to 2.

Karpenter won't launch capacity to run itself (log related to the `karpenter.sh/nodepool DoesNotExist requirement`)
so it can't provision for the second Karpenter pod.

To solve this you can either reduce the replicas back from 2 to 1, or ensure there is enough capacity that isn't being managed by Karpenter to run both pods.

To do so on AWS increase the `minimum` and `desired` parameters on the node group autoscaling group to launch at lease 2 instances.

### Helm Error When Pulling the Chart

If Helm is showing an error when trying to install Karpenter Helm charts:

- Ensure you are using a newer Helm version, Helm started supporting OCI images since `3.8.0`.
- Helm does not have an `helm repo add` concept in OCI, so to install Karpenter you no longer need this.
- If you get an error like `Error: public.ecr.aws/karpenter/karpenter:0.34.0: not found` make sure you're adding a `v` prefix for Karpenter versions between `0.17.0` & `0.34.x`.
- Verify that the image you are trying to pull actually exists in [gallery.ecr.aws/karpenter](https://gallery.ecr.aws/karpenter/karpenter)
- Sometimes Helm generates a generic error, you can add the --debug switch to any of the Helm commands in this doc for more verbose error messages
- If you are getting a 403 forbidden error, you can try `docker logout public.ecr.aws` as explained [here](https://docs.aws.amazon.com/AmazonECR/latest/public/public-troubleshooting.html).

### Helm Error when i


="-6" name="us-gaap:DefinedBenefitPlanSettlementsPlanAssets" format="ixt:num-dot-decimal" scale="6" id="f-1593">187</ix:nonFraction> million of plan assets and liabilities to an insurer and recognized a $<ix:nonFraction unitRef="usd" contextRef="c-369" decimals="-6" name="us-gaap:DefinedBenefitPlanRecognizedNetGainLossDueToSettlements1" format="ixt:num-dot-decimal" scale="6" id="f-1594">14</ix:nonFraction> million net settlement gain related to the acceleration of existing unrecognized gains.
</ix:nonNumeric>
All of the amounts in the table above, other than service cost, were recorded in the line item other income (loss) — net in our consolidated statements of income.

Impact on Accumulated Other Comprehensive Income
<ix:nonNumeric contextRef="c-1" name="us-gaap:ScheduleOfAmountsRecognizedInOtherComprehensiveIncomeLossTableTextBlock" id="f-1595" continuedAt="f-1595-1" escape="true">
The following table sets forth the pretax changes in AOCI for our pension and other postretirement benefit plans (in millions):

Pension Plans	Other Postretirement Benefit Plans

Year Ended Decemb


port-sidebar-disabled-color: rgba(159, 162, 165, 0.75);--quarto-scss-export-valuebox-bg-primary: #5397e9;--quarto-scss-export-valuebox-bg-secondary: #D96E34;--quarto-scss-export-valuebox-bg-success: #3aa716;--quarto-scss-export-valuebox-bg-info: rgba(153, 84, 187, 0.7019607843);--quarto-scss-export-valuebox-bg-warning: #fa6400;--quarto-scss-export-valuebox-bg-danger: rgba(255, 0, 57, 0.7019607843);--quarto-scss-export-valuebox-bg-light: #f8f9fa;--quarto-scss-export-valuebox-bg-dark: #343a40;--quarto-scss-export-mermaid-bg-color: #0E171E;--quarto-scss-export-mermaid-edge-color: #D96E34;--quarto-scss-export-mermaid-node-fg-color: #FAF0E3;--quarto-scss-export-mermaid-fg-color: #FAF0E3;--quarto-scss-export-mermaid-fg-color--lighter: white;--quarto-scss-export-mermaid-fg-color--lightest: white;--quarto-scss-export-mermaid-label-bg-color: #0E171E;--quarto-scss-export-mermaid-label-fg-color: #FFFBF2;--quarto-scss-export-mermaid-node-bg-color: rgba(255, 251, 242, 0.1);--quarto-scss-export-code-block-border-left-color: #FFFBF2;--quarto-scss-export-callout-color-note: #2780e3;--quarto-scss-export-callout-color-tip: #3fb618;--quarto-scss-export-callout-color-important: #ff0039;--quarto-scss-export-callout-color-caution: #f0ad4e;--quarto-scss-export-callout-color-warning: #ff7518}/* required styles */

.leaflet-pane,
.leaflet-tile,
.leaflet-marker-icon,
.leaflet-marker-shadow,
.leaflet-tile-container,
.leaflet-pane > svg,
.leaflet-pane > canvas,
.leaflet-zoom-box,
.leaflet-image-layer,
.leaflet-layer {
	position: absolute;
	left: 0;
	top: 0;
	}
.leaflet-container {
	overflow: hidden;
	}
.leaflet-tile,
.leaflet-marker-icon,
.leaflet-marker-shadow {
	-webkit-user-select: none;
	   -moz-user-select: none;
	        user-select: none;
	  -webkit-user-drag: none;
	}
/* Safari renders non-retina tile on retina better with this, but Chrome is worse */
.leaflet-safari .leaflet-tile {
	image-rendering: -webkit-optimize-contrast;
	}
/* hack that prevents hw layers "stretching" when loading new tiles */
.leaflet-safari .leaflet-tile-container {
	width: 1600px;
	height: 1600px;
	-webkit-transform-origin: 0 0;
	}
.leaflet-marker-icon,
.leaflet-marker-shadow {
	display: block;
	}
/* .leaflet-container svg: reset svg max-width decleration shipped in Joomla! (joomla.org) 3.x */
/* .leaflet-container img: map is broken in FF if you have max-width: 100% on tiles */
.leaflet-container .leaflet-overlay-pane svg


: 0.9 + index * 0.1 }}
            className="my-6"
          >
            {level === 1 && (

                {text}

            )}
            {level === 2 && (

                {text}

            )}
            {level === 3 && (

                {text}

            )}
          </motion.div>
        );
      }

      const formatText = (txt) => {
        txt = txt.replace(
          /`([^`]+)`/g,
          '$1'
        );
        txt = txt.replace(
          /\*\*([^*]+)\*\*/g,
          '$1'
        );
        txt = txt.replace(
          /\*([^*]+)\*/g,
          '$1'
        );
        return txt;
      };

      return (
        <motion.p
          key={index}
          className={`text-base sm:text-lg leading-relaxed text-slate-700 dark:text-slate-200 mb-4 ${index === 0
            ? "first-letter:text-5xl first-letter:font-bold first-letter:text-blue-600 dark:first-letter:text-blue-400 first-letter:mr-3 first-letter:float-left first-letter:leading-none first-letter:mt-1"
            : ""
            }`}
          initial={{ opacity: 0, x: -20 }}
          animate={{ opacity: 1, x: 0 }}
          transition={{ delay: 0.9 + index * 0.1 }}
          dangerouslySetInnerHTML={{ __html: formatText(paragraph) }}
        />
      );
    });
  };

  return (
    <AnimatePresence>
      {blog && (
        <motion.div
          className="fixed inset-0 z-50 flex items-center justify-center p-2 sm:p-4"
          initial={{ opacity: 0 }}
          animate={{ opacity: 1 }}
          exit={{ opacity: 0 }}
          transition={{ duration: 0.3 }}
        >
          <motion.div
            className="absolute inset-0 bg-black/70 backdrop-blur-md"
            onClick={onClose}
            initial={{ opacity: 0 }}
            animate={{ opacity: 1 }}
            exit={{ opacity: 0 }}
          />

          <motion.div
            initial={{ y: 100, opacity: 0, scale: 0.8 }}
            //animate={{ y: 0, opacity: 1, scale: 1 }}
            animate={{ y: 0, opacity: 1, scale: isMaximized ? 1.22 : 1 }}
            exit={{ y: 100, opacity: 0, scale: 0.8 }}
            transition={{ type: "spring", stiffness: 300, damping: 25, mass: 0.8 }}
            className="relative z-10 w-full max-w-6xl max-h-[95vh] sm:max-h-[90vh] bg-gradient-to-br from-white/98 via-blue-50/80 to-purple-50/80 dark:from-slate-900/98 dark:via-slate-800/90 dark:to-purple-900/30 rounded-3xl overflow-hidden border-2 border-white/30 dark:border-slate-700/50 shadow-2xl backdrop-blur-2xl"
          >
            <motion.div
              className="bg-gradient-to-r from-blue-600 via-purple-600 to-indigo-600 p-4 sm:p-5 text-white relative overflow-hidden"
              initial={{ y: -50, opacity: 0 }}
              animate={{ y: 0, opacity: 1 }}
              transition={{ delay: 0.2 }}
            >

                <motion


//-----------------------------------------------------------------------
// <copyright file="SharedKeyCanonicalizer.cs" company="Microsoft">
//    Copyright 2013 Microsoft Corporation
//
//    Licensed under the Apache License, Version 2.0 (the "License");
//    you may not use this file except in compliance with the License.
//    You may obtain a copy of the License at
//      http://www.apache.org/licenses/LICENSE-2.0
//
//    Unless required by applicable law or agreed to in writing, software
//    distributed under the License is distributed on an "AS IS" BASIS,
//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//    See the License for the specific language governing permissions and
//    limitations under the License.
// </copyright>
//-----------------------------------------------------------------------

namespace Microsoft.Azure.Storage.Core.Auth
{
    using Microsoft.Azure.Storage.Core.Util;
    using Microsoft.Azure.Storage.Shared.Protocol;
    using System;
    using System.Diagnostics.CodeAnalysis;
    using System.Net;
    using System.Net.Http;

    /// <summary>
    /// Represents a canonicalizer that converts HTTP request data into a standard form appropriate for signing via
    /// the Shared Key authentication scheme for the Blob or Queue service.
    /// </summary>
    /// <seealso href="http://msdn.microsoft.com/en-us/library/Azure/dd179428.aspx">Authentication for the Microsoft Azure Storage Services</seealso>
    [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Canonicalizer", Justification = "Reviewed: Canonicalizer can be used as an identifier name.")]
    public sealed class SharedKeyCanonicalizer : ICanonicalizer
    {
        private const string SharedKeyAuthorizationScheme = "SharedKey";

        private static SharedKeyCanonicalizer instance = new SharedKeyCanonicalizer();

        /// <summary>
        /// Gets a static instance of the <see cref="SharedKeyCanonicalizer"/> object.
        /// </summary>
        /// <value>The static instance of the class.</value>
        /// <seealso href="http://msdn.microsoft.com/en-us/library/Azure/dd179428.aspx">Authentication for the Microsoft Azure Storage Services</seealso>
        public static SharedKeyCanonicalizer Instance
        {
            get
            {
                return SharedKeyCanonicalizer.instance;
            }
        }

        private SharedKeyCanonicalizer()
        {
        }

        /// <summary>
        /// Gets the authorization scheme used for canonicalization.
        /// </summary>
        /// <value>The authorization scheme used for canonicalization.</value>
        /// <seealso href="http://msdn.microsoft.com/en-us/library/Azure/dd179428.aspx">Authentication for the Microsoft Azure Storage Services</seealso>
        public string AuthorizationScheme
        {
            get
            {
                return SharedKeyAuthorizationScheme;
            }
        }

        /// <summary>
        /// Converts the specified HTTP request data into a standard form appropriate for signing.
        /// </summary>
        /// <param name="request">The HTTP request that needs to be signed.</param>
        /// <param name="accountName">The name of the storage account that the HTTP request will access.</param>
        /// <returns>The canonicalized string containing the HTTP requ


85.5 }, rot = { x = 0.0, y = 0.0, z = 0.0 }, level = 1 }
}

-- 区域
regions = {
}

-- 触发器
triggers = {
}

-- 变量
variables = {
}

--================================================================
--
-- 初始化配置
--
--================================================================

-- 初始化时创建
init_config = {
	suite = 1,
	end_suite = 0,
	rand_suite = false
}

--================================================================
--
-- 小组配置
--
--================================================================

suites = {
	{
		-- suite_id = 1,
		-- description = ,
		monsters = { 16, 17 },
		gadgets = { 86, 87 },
		regions = { },
		triggers = { },
		rand_weight = 100
	}
}

--================================================================
--
-- 触发器
--
--================================================================


Utils = {}

function Utils.StringSplit(oriStr, p)
    if not oriStr or not p then
        return {}
    end
	local nFindStartIndex = 1
	local nSplitIndex = 1
	local nSplitArray = {}
	while true do
		local nFindLastIndex = string.find(oriStr, p, nFindStartIndex)
		if not nFindLastIndex then
			nSplitArray[nSplitIndex] = string.sub(oriStr, nFindStartIndex, string.len(oriStr))
			break
		end
		nSplitArray[nSplitIndex] = string.sub(oriStr, nFindStartIndex, nFindLastIndex - 1)
		nFindStartIndex = nFindLastIndex + string.len(p)
		nSplitIndex = nSplitIndex + 1
	end
	return nSplitArray
end

local logType = 0
local function TypeLog(msg)
    if logType == 1 then
        Debug.Log(msg)
    elseif logType == 2 then
        Debug.LogWarning(msg)
    elseif logType == 3 then
        Debug.LogError(msg)
    else
        print(msg)
    end
end

local function GetKeyValueStr(v, depth)
    if type(v) == 'string' then
        return string.format('%q', v)
    elseif type(v) == 'number' then
        return tostring(v)
    elseif type(v) == 'boolean' then
        return ((v and 'true') or 'false')
    elseif type(v) == 'table' then
        return 'table'
    elseif type(v) == 'userdata' then
        return 'userdata'
    elseif type(v) == 'function' then
        return 'function'
    else
        return 'invalid type ' .. type(v)
    end
end

local function GetTableStr(t, depth)
    if t == nil then
        TypeLog('printTable: nil table')
        return
    end

    local depth = depth or 1
    if depth > 9 then
        TypeLog('too many depth; ignore')
        return
    end

    TypeLog(string.format('%s{', string.rep('    ', depth - 1)))
    for k, v in pairs(t) do
        if type(v) == 'table' then
            TypeLog(string.format('%s[%s] = ', string.rep('    ', depth), GetKeyValueStr(k, de


       Continent::SouthAmerica => "South America",
            Continent::MiddleAmerica => "Central America",
        }
        .to_owned()
    }
}

impl<'de> Deserialize<'de> for Continent {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let string = String::deserialize(deserializer)?.to_lowercase();

        match &string[..] {
            "asia" => Ok(Continent::Asia),
            "europe" => Ok(Continent::Europe),
            "australia" => Ok(Continent::AustraliaAndOceania),
            "africa" => Ok(Continent::Africa),
            "north america" => Ok(Continent::NorthAmerica),
            "south america" => Ok(Continent::SouthAmerica),
            "central america" => Ok(Continent::MiddleAmerica),
            _ =>
                Err(serde::de::Error::invalid_value(
                    serde::de::Unexpected::Str(&string),
                    &"'Asia', 'Europe', 'Australia', 'Africa', 'North America', 'South America' or 'Central America'",
                )),
        }
    }
}

impl Serialize for Continent {
    fn serialize<S>(&self, serializer: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(match self {
            Continent::Asia => "asia",
            Continent::Europe => "europe",
            Continent::AustraliaAndOceania => "australia",
            Continent::Africa => "africa",
            Continent::NorthAmerica => "north america",
            Continent::SouthAmerica => "south america",
            Continent::MiddleAmerica => "central america",
        })
    }
}
<reponame>mre/wundergraph
use crate::diesel_ext::MaybeNull;
use crate::error::Result;
use crate::scalar::WundergraphScalarValue;
use diesel::backend::Backend;
use diesel::expression::NonAggregate;
use diesel::query_builder::QueryFragment;
use diesel::{BoxableExpression, Column, Expression, ExpressionMethods, SelectableExpression};
use juniper::LookAheadMethods;
use juniper::LookAheadSelection;

/// A helper trait to construct a select clause for a given table out of
/// a given graphql request
pub trait BuildSelect<T: ::diesel::Table, DB, ST> {
    /// Construct the select clause out of a given graphql request
    fn build_select(
        select: &LookAheadSelection<'_, WundergraphScalarValue>,
        get_field_name: impl Fn(usize) -> &'static str,
        is_primary_key_index: impl Fn(usize) -> bool,
        should_select_primary_key: bool,
    ) -> Result<Box<dyn BoxableExpression<T, DB, SqlType = ST>>>;
}

macro_rules! impl_select_builder {
    ($(
        $Tuple:tt {
            $(($idx:tt) -> $T:ident, $ST: ident, $TT: ident,) +
        }
    )+) => {
        $(
            impl<Table, DB, $($T,)+> BuildSelect<
                Table, DB, ($(<MaybeNull<$T> as Expression>::SqlType,)+ ),
                > for ($($T,)+)
            where Table: ::diesel::Table,
                DB: Backend,
            $($T: Column<Table = Table> + Default + ExpressionMethods +
              SelectableExpression<Table> + NonAggregate + QueryFragment<DB> + 'static ,)+
                $(MaybeNull<$T>: Expression,


>
     * {@link #STARRED}
     * read/write
     * An indicator for favorite contacts: '1' if favorite, '0' otherwise.
     * Changing this field immediately affects the corresponding aggregate contact:
     * if any raw contacts in that aggregate contact are starred, then the contact
     * itself is marked as starred.
     *

     *

     * String
     * {@link #CUSTOM_RINGTONE}
     * read/write
     * A custom ringtone associated with a raw contact. Typically this is the
     * URI returned by an activity launched with the
     * {@link android.media.RingtoneManager#ACTION_RINGTONE_PICKER} intent.
     * To have an effect on the corresponding value of the aggregate contact, this field
     * should be set at the time the raw contact is inserted. To set a custom
     * ringtone on a contact, use the field {@link ContactsContract.Contacts#CUSTOM_RINGTONE
     * Contacts.CUSTOM_RINGTONE}
     * instead.
     *

     *

     * int
     * {@link #SEND_TO_VOICEMAIL}
     * read/write
     * An indicator of whether calls from this raw contact should be forwarded
     * directly to voice mail ('1') or not ('0'). To have an effect
     * on the corresponding value of the aggregate contact, this field
     * should be set at the time the raw contact is inserted.
     *

     *

     * String
     * {@link #ACCOUNT_NAME}
     * read/write-once
     * The name of the account instance to which this row belongs, which when paired with
     * {@link #ACCOUNT_TYPE} identifies a specific account.
     * For example, this will be the Gmail address if it is a Google account.
     * It should be set at the time the raw contact is inserted and never
     * changed afterwards.
     *

     *

     * String
     * {@link #ACCOUNT_TYPE}
     * read/write-once
     *
     *

     * The type of account to which this row belongs, which when paired with
     * {@link #ACCOUNT_NAME} identifies a specific account.
     * It should be set at the time the raw contact is inserted and never
     * changed afterwards.
     *

     *

     * To ensure uniqueness, new account types should be chosen according to the
     * Java package naming convention.  Thus a Google account is of type "com.google".
     *

     *
     *

     *

     * String
     * {@link #DATA_SET}
     * read/write-once
     *
     *

     * The data set within the account that this row belongs to.  This allows
     * multiple sync adapters for the same account type to distinguish between
     * each others' data.  The combination of {@link #ACCOUNT_TYPE},
     * {@link #ACCOUNT_NAME}, and {@link #DATA_SET} identifies a set of data
     * that is associated with a single sync adapter.
     *

     *

     * This is empty by default, and is completely optional.  It only needs to
     * be populated if multiple sync adapters are entering distinct data for
     * the same account type and account name.
     *

     *

     * It should be set at the time the raw


o" target="_blank">
           GitHub

 -->

Selected Projects

      <video controls>
        <source src="videos/phenotype.mp4" type="video/mp4">
      </video>

Phenotyping and Precision Agriculture (2025)

        Leveraging ROS for robot control and TensorFlow for DL image processing to automate phenotyping in crop breeding applications.

      <video controls>
        <source src="videos/spot.mp4" type="video/mp4">
      </video>

Legged Robot (Boston Dynamics SPOT) for Industrial Site Inspection (2023)

        Developed control and navigation algorithms for the Boston Dynamics SPOT robot to enable autonomous industrial site inspections. ROS for control and navigation with PyTorch x FastRCNN for grate and puddle detection.

      <video controls>
        <source src="videos/hanamoflor.mp4" type="video/mp4">
      </video>

Nursing care robot (2023)

        In this project, I utilized the Sony Hanamoflor mobile humanoid robot to explore applications in elderly care assistance.

           Showcasing Our Robot

      <video controls>
        <source src="videos/multirobot_ntt.mp4" type="video/mp4">
      </video>

Multi-robot coordination and control (2022)

        Developed a multi-robot coordination system with collision avoidance by integrating dynamic obstacle detection via an Extended Kalman Filter (EKF) and Reciprocal Velocity Obstacles (RVO) for safe navigation among multiple robots without collisions.

      <video controls>
        <source src="videos/table_cleaning.mp4" type="video/mp4">
      </video>

Service Humanoid Robot (2023)

        Developed a service robot capable of autonomously cleaning tables in a restaurant setting, using ROS for navigation and MoveIt for manipulation and motion planning.

      <video controls>
        <source src="videos/manipulator_design.mp4" type="video/mp4">
      </video>

Affordable 6-DOF Manipulator Design (2025)

       A lightweight, 3D-printed 6-D


/**
     * @return Ignite releases dir.
     */
    public String igniteReleasesDir() {
        return igniteReleasesDir;
    }

    /**
     * @return User's libs.
     */
    public String userLibs() {
        return userLibs;
    }

    /**
     * @return Ignite configuration.
     */
    public String igniteCfg() {
        return igniteCfg;
    }

    /**
     * @return Licence path.
     */
    public String licencePath() {
        return licencePath;
    }

    /**
     * @return Ignite hdfs path.
     */
    public String ignitePath() {
        return ignitePath;
    }

    /**
     * @return Jvm opts.
     */
    public String jvmOpts() {
        return jvmOpts;
    }

    /**
     * @return Host name constraint.
     */
    public Pattern hostnameConstraint() {
        return hostnameConstraint;
    }

    /**
     * @return Yarn Queue
     */
    public String yarnQueue() { return yarnQueue; }

    /**
     * Instantiate a ClusterProperties from a set of properties.
     *
     * @param props If {@code null} will be used system properties.
     * @return Cluster properties.
     */
    private static ClusterProperties fromProperties(Properties props) {
        ClusterProperties prop = new ClusterProperties();

        prop.clusterName = getStringProperty(IGNITE_CLUSTER_NAME, props, DEFAULT_CLUSTER_NAME);

        prop.cpuPerNode = getDoubleProperty(IGNITE_RUN_CPU_PER_NODE, props, DEFAULT_CPU_PER_NODE);
        prop.memPerNode = getDoubleProperty(IGNITE_MEMORY_PER_NODE, props, DEFAULT_MEM_PER_NODE);
        // The minimum memory overhead: overhead is by default 0.1* MEMORY_PER_NODE,
        // with a minimum of DEFAULT_MINIMUM_MEM_OVERHEAD_PER_NODE
        prop.memOverHeadPerNode = getDoubleProperty(IGNITE_MEMORY_OVERHEAD_PER_NODE, props,
            Math.max( 0.1 * prop.memPerNode, DEFAULT_MINIMUM_MEM_OVERHEAD_PER_NODE));
        prop.nodeCnt = getDoubleProperty(IGNITE_NODE_COUNT, props, DEFAULT_IGNITE_NODE_COUNT);

        prop.igniteUrl = getStringProperty(IGNITE_URL, props, null);
        prop.ignitePath = getStringProperty(IGNITE_PATH, props, null);
        prop.licencePath = getStringProperty(LICENCE_PATH, props, null);
        prop.jvmOpts = getStringProperty(IGNITE_JVM_OPTS, props, null);
        prop.igniteWorkDir = getStringProperty(IGNITE_WORKING_DIR, props, DEFAULT_IGNITE_WORK_DIR);
        prop.igniteLocalWorkDir = getStringProperty(IGNITE_LOCAL_WORK_DIR, props, DEFAULT_IGNITE_LOCAL_WORK_DIR);
        prop.igniteReleasesDir = getStringProperty(IGNITE_RELEASES_DIR, props, DEFAULT_IGNITE_RELEASES_DIR);
        prop.igniteCfg = getStringProperty(IGNITE_CONFIG_XML, props, null);
        prop.userLibs = getStringProperty(IGNITE_USERS_LIBS, props, null);
        prop.yarnQueue = getStringProperty(IGNITE_YARN_QUEUE, props, DEFAULT_IGNITE_YARN_QUEUE);

        String pattern = getStringProperty(IGNITE_HOSTNAME_CONSTRAINT, props, null);

        if (pattern != null) {
            try {
                prop.hostnameConstraint = Pattern.compile(pattern);
            }
            catch (PatternSyntaxException e) {
                log.log(Level.WARNING, "IGNITE_HOSTNAME_CONSTRAINT has invalid pattern. It will be ignore.", e);
            }
        }

        return prop;
    }

    /**
     * @param config Path to config file.
     * @return Cluster configuration.
     */
    public static ClusterProperties from(String config) {