废物的收集、运送、贮存、处置以及监督管理等活动。

医疗卫生机构收治的传染病病人或者疑似传染病病人产生的生活垃圾，按照医疗废物进行管理和处置。

医疗卫生机构废弃的麻醉、精神、放射性、毒性等药品及其相关的废物的管理，依照有关法律、行政法规和国家有关规定、标准执行。

第四条 国家推行医疗废物集中无害化处置，鼓励有关医疗废物安全处置技术的研究与开发。

县级以上地方人民政府负责组织建设医疗废物集中处置设施。

国家对边远贫困地区建设医疗废物集中处置设施给予适当的支持。

第五条 县级以上各级人民政府卫生行政主管部门，对医疗废物收集、运送、贮存、处置活动中的疾病防治工作实施统一监督管理；环境保护行政主管部门，对医疗废物收集、运送、贮存、处置活动中的环境污染防治工作实施统一监督管理。

县级以上各级人民政府其他有关部门在各自的职责范围内负责与医疗废物处置有关的监督管理工作。

第六条 任何单位和个人有权对医疗卫生机构、医疗废物集中处置单位和监督管理部门及其工作人员的违法行为进行举报、投诉、检举和控告。

## 第二章 医疗废物管理的一般规定

第七条 医疗卫生机构和医疗废物集中处置单位，应当建立、健全医疗废物管理责任制，其法定代表人为第一责任人，切实履行职责，防止因医疗废物导致传染病传播和环境污染事故。

第八条 医疗卫生机构和医疗废物集中处置单位，应当制定与医疗废物安全处置有关的规章制度和在发生意外事故时的应急方案；设置监控部门或者专(兼)职人员，负责检查、督促、落实本单位医疗废物的管理工作，防止违反本条例的行为发生。

第九条 医疗卫生机构和医疗废物集中处置单位，应当对本单位从事医疗废物收集、运送、贮存、处置等工作的人员和管理人员，进行


    pub sa_handler: Option<extern "C" fn(usize)>,
    pub sa_mask: [u64; 2],
    pub sa_flags: SigActionFlags,
}

#[allow(dead_code)]
unsafe fn _assert_size_of_function_is_sane() {
    // Transmuting will complain *at compile time* if sizes differ.
    // Rust forbids a fn-pointer from being 0 so to allow SIG_DFL to
    // exist, we use Option<extern "C" fn(usize)> which will mean 0
    // becomes None
    let _ = mem::transmute::<Option<extern "C" fn(usize)>, usize>(None);
}

#[derive(Copy, Clone, Debug, Default, PartialEq)]
#[repr(C)]
pub struct Stat {
    pub st_dev: u64,
    pub st_ino: u64,
    pub st_mode: u16,
    pub st_nlink: u32,
    pub st_uid: u32,
    pub st_gid: u32,
    pub st_size: u64,
    pub st_blksize: u32,
    pub st_blocks: u64,
    pub st_mtime: u64,
    pub st_mtime_nsec: u32,
    pub st_atime: u64,
    pub st_atime_nsec: u32,
    pub st_ctime: u64,
    pub st_ctime_nsec: u32,
}

impl Deref for Stat {
    type Target = [u8];
    fn deref(&self) -> &[u8] {
        unsafe {
            slice::from_raw_parts(self as *const Stat as *const u8,
                                  mem::size_of::<Stat>())
        }
    }
}

impl DerefMut for Stat {
    fn deref_mut(&mut self) -> &mut [u8] {
        unsafe {
            slice::from_raw_parts_mut(self as *mut Stat as *mut u8,
                                      mem::size_of::<Stat>())
        }
    }
}

#[derive(Copy, Clone, Debug, Default, PartialEq)]
#[repr(C)]
pub struct StatVfs {
    pub f_bsize: u32,
    pub f_blocks: u64,
    pub f_bfree: u64,
    pub f_bavail: u64,
}

impl Deref for StatVfs {
    type Target = [u8];
    fn deref(&self) -> &[u8] {
        unsafe {
            slice::from_raw_parts(self as *const StatVfs as *const u8,
                                  mem::size_of::<StatVfs>())
        }
    }
}

impl DerefMut for StatVfs {
    fn deref_mut(&mut self) -> &mut [u8] {
        unsafe {
            slice::from_raw_parts_mut(self as *mut StatVfs as *mut u8,
                                      mem::size_of::<StatVfs>())
        }
    }
}

#[derive(Copy, Clone, Debug, Default, PartialEq)]
#[repr(C)]
pub struct TimeSpec {
    pub tv_sec: i64,
    pub tv_nsec: i32,
}

impl Deref for TimeSpec {
    type Target = [u8];
    fn deref(&self) -> &[u8] {
        unsafe {
            slice::from_raw_parts(self as *const TimeSpec as *const u8,
                                  mem::size_of::<TimeSpec>())
        }
    }
}

impl DerefMut for TimeSpec {
    fn deref_mut(&mut self) -> &mut [u8] {
        unsafe {
            slice::from_raw_parts_mut(self as *mut TimeSpec as *mut u8,


.anon_author{color:#222}@supports ((display: -webkit-box) or (display: -webkit-flex) or (display: -moz-box) or (display: -ms-flexbox) or (display: flex)){.r .wi_author{display:-webkit-box;display:-webkit-flex;display:-moz-box;display:-ms-flexbox;display:flex;-webkit-box-align:center;-webkit-align-items:center;-moz-box-align:center;-ms-flex-align:center;align-items:center;margin-bottom:0}.r .wi_author .explain{margin-left:5px;white-space:nowrap;overflow:hidden;-o-text-overflow:ellipsis;text-overflow:ellipsis;font-weight:400;-webkit-font-smoothing:subpixel-antialiased;-moz-osx-font-smoothing:auto}.r .wi_author .explain .divider{padding:0 4px}}.PostActions__toggler,.r .wi_actions_btn{margin:0;position:absolute;min-width:auto;top:2px;right:2px;padding:10px}.PostActions__togglerIcon,.r .wi_actions_btn .i_icon{display:block;margin:0;padding:0;width:24px;height:24px;background-image:url('/images/mobile/icons/post_buttons.png?3');background-repeat:no-repeat;-webkit-background-size:100% 100%!important;-moz-background-size:100%!important;background-size:100%!important;background-position:0 83.33333333%!important}.vk_2x .PostActions__togglerIcon,.vk_2x.r .wi_actions_btn .i_icon{background-image:url('/images/mobile/icons/post_buttons_2x.png?3')}.PostActions__dropdown,.r .upanel .wi_actions_wrap{width:100%;margin:0;padding:0;position:absolute;top:40px;right:0}.PostActions__dropdown_reverse,.r .upanel .wi_actions_top{top:9px}.PostActions__dropdownTriangle,.r .wi_actions_wrap .pointer{display:block}.PostActions__dropdownTriangleIcon,.r .wi_actions_wrap .i_pointer{height:8px;right:16px}.Audio__menu,.PostActions__dropdownContent,.r .ai_menu,.r .upanel .wi_actions{position:absolute;width:100%;background:#fff;border-top:1px solid #d6d6d6;border-bottom:1px solid #d6d6d6;-webkit-box-shadow:0 1px 4px rgba(0,0,0,.15);-moz-box-shadow:0 1px 4px rgba(0,0,0,.15);box-shadow:0 1px 4px rgba(0,0,0,.15);padding:4px 0}.PostActions__item,.r .wia_item{font-size:14px;color:#426997}@media (max-width: 319px){.PostActions__toggler,.r .wi_actions_btn{top:0;right:0;padding:4px 10px}.PostActions__item,.r .wia_item{font-size:13px}.PostActions__dropdownTriangleIcon,.r .wi_actions_wrap .i_pointer{right:12px}.PostActions__dropdown,.r .upanel .wi_actions_wrap{top:35px}.PostActions__dropdown_reverse,.r .upanel .wi_actions_top{top:4px}}@media (min-width: 400px){.PostActions__toggler,.r .wi_actions_btn{top:6px;right:6px}.PostActions__item,.r .wia_item{font-size:15px}.PostActions__dropdownTriangleIcon,.r .wi_actions_wrap .i_pointer{right:20px}.PostActions__dropdown,.r .upanel .wi_actions_wrap{top:45px}.PostActions__dropdown_reverse,.r .upanel .wi_acti


h.floor(count80))
	end
end
-- 行动结束
function Skill4942004:OnActionOver(caster, target, data)
	-- 8063
	if SkillJudger:CasterIsEnemy(self, caster, target, true) then
	else
		return
	end
	-- 8070
	if SkillJudger:TargetIsSelf(self, caster, target, true) then
	else
		return
	end
	-- 4101912
	self:AddBuff(SkillEffect[4101912], caster, self.card, data, 4101912)
end
-- 行动结束2
function Skill4942004:OnActionOver2(caster, target, data)
	-- 8063
	if SkillJudger:CasterIsEnemy(self, caster, target, true) then
	else
		return
	end
	-- 8071
	if SkillJudger:TargetIsFriend(self, caster, target, true) then
	else
		return
	end
	-- 8633
	local count633 = SkillApi:GetDamage(self, caster, target,1)
	-- 4704024
	self:AddBuff(SkillEffect[4704024], caster, caster, data, 302301)
	-- 4704034
	self:AddHp(SkillEffect[4704034], caster, caster, data, math.floor(-count633*0.25))
end


                                                                                \
    explicit rule_name(double weight) : PopulationMutationRule(weight) {}                         \
    ResultKind Apply(SketchPolicyNode* policy, State* state, std::mt19937* rand_gen) const final; \
  };

/*! \brief The rule that mutates tile size by randomly dividing a tile size by a factor
    and multipling it to another tile size. */
DEFINE_MUTATE_POPULATION_RULE(MutateTileSize);

/*! \brief The rule that mutates the number of fused outer iterators annotated by parallel. */
DEFINE_MUTATE_POPULATION_RULE(MutateParallel);

/*! \brief The rule that randomly changes the computation location for some stages that do not
 * need tiling and are not strictly inlineable(e.g. data padding). */
DEFINE_MUTATE_POPULATION_RULE(MutateComputeLocation);

/*! \brief The rule that mutates the value of a randomly selected auto unroll pragma step. */
DEFINE_MUTATE_POPULATION_RULE(MutateAutoUnroll);

}  // namespace auto_scheduler
}  // namespace tvm

#endif  // TVM_AUTO_SCHEDULER_SEARCH_POLICY_SKETCH_POLICY_RULES_H_


        lookup.put("END_STONE", "blocks/end_stone");
        lookup.put("ENDER_CHEST", "blocks/ender_chest_front");
        lookup.put("FEATHER", "items/feather");
        lookup.put("GLOWSTONE", "blocks/glowstone");
        lookup.put("GRANITE", "blocks/stone_granite");
        lookup.put("GREEN_WOOL", "blocks/wool_colored_green");
        lookup.put("HOPPER", "blocks/hopper_outside");
        lookup.put("IRON_BARS", "blocks/iron_bars");
        lookup.put("IRON_BLOCK", "blocks/iron_block");
        lookup.put("IRON_INGOT", "items/iron_ingot");
        lookup.put("IRON_TRAPDOOR", "blocks/iron_trapdoor");
        lookup.put("LANTERN", "items/lantern");
        lookup.put("MOSSY_COBBLESTONE", "blocks/cobblestone_mossy");
        lookup.put("MOSSY_STONE_BRICKS", "blocks/stonebrick_mossy");
        lookup.put("NETHER_BRICKS", "blocks/chiseled_nether_bricks");
        lookup.put("NETHER_QUARTZ_ORE", "blocks/quartz_ore");
        lookup.put("NETHERRACK", "blocks/netherrack");
        lookup.put("OAK_FENCE", "blocks/planks_oak");
        lookup.put("OAK_LOG", "blocks/log_oak");
        lookup.put("ORANGE_WOOL", "blocks/wool_colored_orange");
        lookup.put("PINK_WOOL", "blocks/wool_colored_pink");
        lookup.put("PRISMARINE", "blocks/prismarine_bricks");
        lookup.put("QUARTZ_BLOCK", "blocks/quartz_block_side");
        lookup.put("RAIL", "blocks/rail_normal");
        lookup.put("RED_TERRACOTTA", "blocks/hardened_clay_stained_red");
        lookup.put("RED_WOOL", "blocks/wool_colored_red");
        lookup.put("SANDSTONE", "blocks/sandstone_normal");
        lookup.put("SNOW_BLOCK", "blocks/snow");
        lookup.put("SPRUCE_LEAVES", "blocks/leaves_spruce_opaque");
        lookup.put("STONE_BRICK_STAIRS", "blocks/stone_slab_top");
        lookup.put("STONE_BRICKS", "blocks/stonebrick");
        lookup.put("TERRACOTTA", "blocks/hardened_clay");
        lookup.put("WHITE_WOOL", "blocks/wool_colored_white");
        lookup.put("YELLOW_CONCRETE", "blocks/concrete_yellow");
        lookup.put("YELLOW_WOOL", "blocks/wool_colored_yellow");
    }
}
/*
 * Copyright (C) 2025 eccentric_nz
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
package me.eccentric_nz.TARDIS.utility;

import me.eccentric_nz.TARDIS.TARDIS;
import me.eccentric_nz.TARDIS.database.resultset.ResultSetCurrentLocation;
import org.bukkit.entity.ArmorStand;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Interaction;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.world.ChunkLoadEvent;
import org.bukkit.persistence.PersistentDataType;

import java.util.HashMap;

public class ChunkCleanListener implements Listener {


n should be the point where the search starts and the @end position
# should be where it ends oppose to the current behaviour.
#
# TODO should word the same as view.find() and return Region(-1, -1), rather than None, when not found
def reverse_search(view, term: str, start: int, end: int, flags: int = 0):
    if start < 0 or end > view.size():
        return None

    lo_line = view.full_line(start)
    hi_line = view.full_line(end)

    while True:
        low_row, hi_row = view.rowcol(lo_line.a)[0], view.rowcol(hi_line.a)[0]
        middle_row = (low_row + hi_row) // 2

        middle_line = view.full_line(view.text_point(middle_row, 0))

        lo_region = Region(lo_line.a, middle_line.b)
        hi_region = Region(middle_line.b, min(hi_line.b, end))

        if find_in_range(view, term, hi_region.a, hi_region.b, flags):
            lo_line = view.full_line(middle_line.b)
        elif find_in_range(view, term, lo_region.a, lo_region.b, flags):
            hi_line = view.full_line(middle_line.a)
        else:
            return None

        if lo_line == hi_line:
            # we found the line we were looking for, now extract the match.
            return find_last_in_range(view, term, hi_line.a, min(hi_line.b, end), flags)

def reverse_search_by_pt(view, term: str, start: int, end: int, flags: int = 0):
    if start < 0 or end > view.size():
        return None

    lo_line = view.full_line(start)
    hi_line = view.full_line(end)

    while True:
        low_row, hi_row = view.rowcol(lo_line.a)[0], view.rowcol(hi_line.a)[0]
        middle_row = (low_row + hi_row) // 2

        middle_line = view.full_line(view.text_point(middle_row, 0))

        lo_region = Region(lo_line.a, middle_line.b)
        hi_region = Region(middle_line.b, min(hi_line.b, end))

        if find_in_range(view, term, hi_region.a, hi_region.b, flags):
            lo_line = view.full_line(middle_line.b)
        elif find_in_range(view, term, lo_region.a, lo_region.b, flags):
            hi_line = view.full_line(middle_line.a)
        else:
            return None

        if lo_line == hi_line:
            # we found the line we were looking for, now extract the match.
            return find_last_in_range(view, term, max(hi_line.a, start), min(hi_line.b, end), flags)


.indexOf(q.toLowerCase())>=0;
}});
})(jQuery);

if ($.fn.pagination){
	$.fn.pagination.defaults.beforePageText = '第';
	$.fn.pagination.defaults.afterPageText = '共{pages}页';
	$.fn.pagination.defaults.displayMsg = '显示{from}到{to},共{total}记录';
}
if ($.fn.datagrid){
	$.fn.datagrid.defaults.loadMsg = '正在处理，请稍待。。。';
}
if ($.fn.treegrid && $.fn.datagrid){
	$.fn.treegrid.defaults.loadMsg = $.fn.datagrid.defaults.loadMsg;
}
if ($.messager){
	$.messager.defaults.ok = '确定';
	$.messager.defaults.cancel = '取消';
}
$.map(['validatebox','textbox','passwordbox','filebox','searchbox',
		'combo','combobox','combogrid','combotree',
		'datebox','datetimebox','numberbox',
		'spinner','numberspinner','timespinner','datetimespinner'], function(plugin){
	if ($.fn[plugin]){
		$.fn[plugin].defaults.missingMessage = '该输入项为必输项';
	}
});
if ($.fn.validatebox){
	$.fn.validatebox.defaults.rules.email.message = '请输入有效的电子邮件地址';
	$.fn.validatebox.defaults.rules.url.message = '请输入有效的URL地址';
	$.fn.validatebox.defaults.rules.length.message = '输入内容长度必须介于{0}和{1}之间';
	$.fn.validatebox.defaults.rules.remote.message = '请修正该字段';
}
if ($.fn.calendar){
	$.fn.calendar.defaults.weeks = ['日','一','二','三','四','五','六'];
	$.fn.calendar.defaults.months = ['一月','二月','三月','四月','五月','六月','七月','八月','九月','十月','十一月','十二月'];
}
if ($.fn.datebox){
	$.fn.datebox.defaults.currentText = '今天';
	$.fn.datebox.defaults.closeText = '关闭';
	$.fn.datebox.defaults.okText = '确定';
	$.fn.datebox.defaults.formatter = function(date){
		var y = date.getFullYear();
		var m = date.getMonth()+1;
		var d = date.getDate();
		return y+'-'+(m<10?('0'+m):m)+'-'+(d<10?('0'+d):d);
	};
	$.fn.datebox.defaults.parser = function(s){
		if (!s) return new Date();
		var ss = s.split('-');
		var y = parseInt(ss[0],10);
		var m = parseInt(ss[1],10);
		var d = parseInt(ss[2],10);
		if (!isNaN(y) && !isNaN(m) && !isNaN(d)){
			return new Date(y,m-1,d);
		} else {
			return new Date();
		}
	};
}
if ($.fn.datetimebox && $.fn.datebox){
	$.extend($.fn.datetimebox.defaults,{
		currentText: $.fn.datebox.defaults.currentText,
		closeText: $.fn.datebox.defaults.closeText,
		okText: $.fn.datebox.defaults.okText
	});
}
if ($.fn.datetimespinner){
	$.fn.datetimespinner.defaults.selections = [[0,4],[5,7],[8,10],[11,13],[14,16],[17,19]]
}
'use strict';

/* jshint quotmark: double */
window.SwaggerTranslator.learn({
    "Warning: Deprecated":"Aviso: Depreciado",
    "Implementation Notes":"Not


<>();
        parameters.put("email", "test@test.com");
        parameters.put("id", 5);
        String path = router.uriFor(route.getUriPattern(), parameters);

        assertThat(path, equalTo("/user/test@test.com/test/5"));
    }

    @Test
    public void testUriForWithSplat() throws Exception {
        Route route = Route.GET("/repository/{repo: .*}/ticket/{id: .*}", emptyHandler);
        router.addRoute(route);

        Map<String, Object> parameters = new HashMap<>();
        parameters.put("repo", "test/myrepo");
        parameters.put("id", 5);
        String path = router.uriFor(route.getUriPattern(), parameters);

        assertThat(path, equalTo("/repository/test/myrepo/ticket/5"));

        List<RouteMatch> matches = router.findRoutes(HttpConstants.Method.GET, "/repository/test/myrepo/ticket/5");

        assertFalse(matches.isEmpty());
        assertEquals("test/myrepo", matches.get(0).getPathParameters().get("repo"));
        assertEquals("5", matches.get(0).getPathParameters().get("id"));
    }

    @Test
    public void testUriForWithRegexAndQueryParameters() throws Exception {
        Route route = Route.GET("/user/{email}/{id: .*}", emptyHandler);
        router.addRoute(route);

        Map<String, Object> parameters = new HashMap<>();
        parameters.put("email", "test@test.com");
        parameters.put("id", 5);
        parameters.put("query", "recent_changes");
        String path = router.uriFor(route.getUriPattern(), parameters);

        assertThat(path, equalTo("/user/test@test.com/5?query=recent_changes"));
    }

    @Test
    public void testUriForWithEncodedParameters() throws Exception {
        Route route = Route.GET("/user/{email}", emptyHandler);
        router.addRoute(route);

        Map<String, Object> parameters = new HashMap<>();
        parameters.put("email", "test@test.com");
        parameters.put("name", "Decebal Suiu");
        String path = router.uriFor(route.getUriPattern(), parameters);

        assertThat(path, equalTo("/user/test@test.com?name=Decebal+Suiu"));
    }

    @Test
    public void testExclusionFilter() throws Exception {
        Route route = Route.ANY("^(?!/(webjars|public)/).*", emptyHandler);
        router.addRoute(route);

        List<RouteMatch> matches = router.findRoutes(HttpConstants.Method.GET, "/test/route");
        assertEquals(1, matches.size());

        matches = router.findRoutes(HttpConstants.Method.GET, "/webjars/route");
        assertEquals(0, matches.size());

        matches = router.findRoutes(HttpConstants.Method.GET, "/public/route");
        assertEquals(0, matches.size());
    }

    @Test
    public void testOptionalSuffixGroup() throws Exception {
        Route route = Route.ANY("/api/contact/{id: [0-9]+}(\\.(json|xml|yaml))?", emptyHandler);
        router.addRoute(route);

        List<RouteMatch> matches = router.findRoutes(HttpConstants.Method.GET, "/api/contact/5");
        assertEquals(1, matches.size());

        matches = router.findRoutes(HttpConstants.Method.GET, "/api/contact/5.json");
        assertEquals(1, matches.size());

        matches = router.findRoutes(HttpConstants.Method.GET, "/api/contact/5.xml");
        assertEquals(1, matches.size());

        matches = router.findRoutes(HttpConstants.Method.GET, "/api/contact/5.yaml");
        assertEquals(1, matches.size());

        matches = router.findRoutes(HttpConstants.Method.GET, "/api/contact/5.unknown");
        assertEquals(0, matches.size());
    }

    @Test
    public void testRequiredSuffixGroup() throws Exception {
        Route route = Route.ANY("/api/contact/{id: [0-9]+}(\\


rue
 *       ｜-- 接口中 success = true，return response
 *       ｜-- 接口中 success = false
 *           ｜-- 判断 isErrorShow = true，throw response
 *           ｜-- 判断 isErrorShow = false，不做处理
 *   ｜-- 判断 isErrorIntercept = false，return response
 * ▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
 * ▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼
 * -- 处理异常
 *   ｜-- 判断 isErrorShow 为 true，显示错误内容
 *   ｜-- 判断 isErrorShow 为 false，不显示错误内容
 * ▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
 */
axios.interceptors.response.use(
  response => {
    const { status, data, config } = response || {};
    if (status === 200) {
      const isErrorIntercept = (config as any)?.isErrorIntercept === true;
      const isErrorShow = (config as any)?.isErrorShow === true;
      if (isErrorIntercept) {
        if (data?.success) {
          return response;
        }
        if (isErrorShow) {
          throw new Error(data?.errorMsg);
        }
      }
      return response;
    }
    throw new Error(codeMessage[status]);
  },
  error => {
    const { status, statusText } = error?.response || {};
    throw new Error(codeMessage[status] || statusText);
  },
);

/**
 * @author zhiqian_shi
 * @date 2021/7/8 14:13
 * @Description: 处理异常
 * @param {*} error 不为空 错误信息
 * @return {*} null
 */
const handleError = (error: any): void => {
  const { message } = error;
  notification.error({
    message: '通知',
    description: message || '发现一个未知的错误，请联系网站管理员！',
  });
};

/**
 * @author zhiqian_shi
 * @date 2021/7/8 10:16
 * @Description: post请求
 * @param {string} url 不为空 接口地址
 * @param {object} params 可为空 参数
 * @param {object} config 可为空 isErrorIntercept是否拦截后端返回的错误内容（默认true），isErrorShow是否提示错误内容（默认true）
 * @return {prom


     ;aka WMI_BSS_FILTER_CMD
  000Ah  WMI_SET_PROBED_SSID_CMD
  000Bh  WMI_SET_LISTEN_INT_CMD
  000Ch  WMI_SET_BMISS_TIME_CMD
  000Dh  WMI_SET_DISC_TIMEOUT_CMD    ;aka WMI_SET_DISCONNECT_TIMEOUT
  000Eh  WMI_GET_CHANNEL_LIST_CMD    ;reply 000Eh  ;aka WMI_CHANNEL_LIST
  000Fh  WMI_SET_BEACON_INT_CMD
  0010h  WMI_GET_STATISTICS_CMD      ;reply WMI_REPORT_STATISTICS
  0011h  WMI_SET_CHANNEL_PARAMS_CMD  ;aka WMI_CHANNEL_PARAMS_CMD
  0012h  WMI_SET_POWER_MODE_CMD      ;aka WMI_POWER_MODE_CMD
  0013h  WMI_SET_IBSS_PM_CAPS_CMD    ;aka WMI_IBSS_PM_CAPS_CMD
  0014h  WMI_SET_POWER_PARAMS_CMD    ;aka WMI_POWER_PARAMS_CMD
  0015h  WMI_SET_POWERSAVE_TIMERS_POLICY_CMD  ;aka WMI_POWERSAVE...
  0016h  WMI_ADD_CIPHER_KEY_CMD
  0017h  WMI_DELETE_CIPHER_KEY_CMD   ;\
  0018h  WMI_ADD_KRK_CMD             ; ignored dummy commands on DSi
  0019h  WMI_DELETE_KRK_CMD          ;/
  001Ah  WMI_SET_PMKID_CMD
  001Bh  WMI_SET_TX_PWR_CMD
  001Ch  WMI_GET_TX_PWR_CMD          ;aka WMI_TX_PWR ;reply 001Ch
  001Dh  WMI_SET_ASSOC_INFO_CMD
  001Eh  WMI_ADD_BAD_AP_CMD
  001Fh  WMI_DELETE_BAD_AP_CMD
  0020h  WMI_SET_TKIP_COUNTERMEASURES_CMD
  0021h  WMI_RSSI_THRESHOLD_PARAMS_CMD
  0022h  WMI_TARGET_ERROR_REPORT_BITMASK_CMD
  0023h  WMI_SET_ACCESS_PARAMS_CMD
  0024h  WMI_SET_RETRY_LIMITS_CMD
  0025h  WMI_SET_OPT_MODE_CMD
  0026h  WMI_OPT_TX_FRAME_CMD
  0027h  WMI_SET_VOICE_PKT_SIZE_CMD
  0028h  WMI_SET_MAX_SP_LEN_CMD
  0029h  WMI_SET_ROAM_CTRL_CMD
  002Ah  WMI_GET_ROAM_TBL_CMD ;aka REPORT_ROAM_TBL,TARGET_ROAM_TBL ;reply 100Fh
  002Bh  WMI_GET_ROAM_DATA_CMD       ;reply 1015h ?    ;\
  002Ch  WMI_ENABLE_RM_CMD                             ; not implemented in DSi
  002Dh  WMI_SET_MAX_OFFHOME_DURATION_CMD              ;/
  002Eh  WMI_EXTENSION_CMD   ;prefix for WMIX "Non-wireless extensions"...
  002Eh:2001h  WMIX_DSETOPEN_REPLY_CMD ;reply to 3001h ;\not implemented in DSi
  002Eh:2002h  WMIX_DSETDATA_REPLY_CMD ;reply to 3003h ;/
  002Eh:2003h  WMIX_GPIO_OUTPUT_SET_CMD   ;reply=3006h          ;\
  002Eh:2004h  WMIX_GPIO_INPUT_GET_CMD    ;reply=3005h          ;
  002Eh:2005h  WMIX_GPIO_REGISTER_SET_CMD ;reply=3006h, too     ; GPIO
  002Eh:2006h  WMIX_GPIO_REGISTER_GET_CMD ;reply=3005h, too     ;
  002Eh:2007h  WMIX_GPIO_INTR_ACK_CMD ;reply to 3004h           ;/
  002Eh:2008h  WMIX_HB_CHALLENGE_RESP_CMD ;reply=3007h          ;-HB=heartbeat
  002Eh:2009h  W


 = 0;

					// global coordinates of limit
					matrix3x4_t limitMatrix;
					ConcatTransforms( goalMX, pitchMatrix, limitMatrix );

					Vector limitLeft( limitMatrix.m_flMatVal[0][0],
									  limitMatrix.m_flMatVal[1][0],
									  limitMatrix.m_flMatVal[2][0] );

					Vector limitUp( limitMatrix.m_flMatVal[0][1],
									limitMatrix.m_flMatVal[1][1],
									limitMatrix.m_flMatVal[2][1] );

					Vector limitForward( limitMatrix.m_flMatVal[0][2],
										 limitMatrix.m_flMatVal[1][2],
										 limitMatrix.m_flMatVal[2][2] );

#ifdef CLIENT_DLL
					if (cl_jiggle_bone_debug_pitch_constraints.GetBool())
					{
						float dT = 0.01f;
						const float axisSize = 10.0f;
						if ( debugoverlay )
						{
							debugoverlay->AddLineOverlay( goalBasePosition, goalBasePosition + axisSize * limitLeft, 0, 255, 255, true, dT );
							debugoverlay->AddLineOverlay( goalBasePosition, goalBasePosition + axisSize * limitUp, 255, 255, 0, true, dT );
							debugoverlay->AddLineOverlay( goalBasePosition, goalBasePosition + axisSize * limitForward, 255, 0, 255, true, dT );
						}
					}
#endif // CLIENT_DLL

					Vector limitAlong( DotProduct( limitLeft, along ),
									   DotProduct( limitUp, along ),
									   DotProduct( limitForward, along ) );

					// clip to limit plane
					data->tipPos = goalBasePosition + limitAlong.x * limitLeft + limitAlong.z * limitForward;

					// removed friction and velocity clipping against constraint - was causing simulation blowups (MSB 12/9/2010)
					data->tipVel.Zero();
				}
			}
		}

		// needed for matrix assembly below
		Vector forward = data->tipPos - goalBasePosition;
		forward.NormalizeInPlace();

		if ( jiggleInfo->flags & JIGGLE_HAS_ANGLE_CONSTRAINT )
		{
			// enforce max angular error
			Vector error = goalTip - data->tipPos;
			float dot = DotProduct( forward, goalForward );
			float angleBetween = acos( dot );
			if ( dot < 0.0f )
			{
				angleBetween = 2.0f * M_PI - angleBetween;
			}

			if ( angleBetween > jiggleInfo->angleLimit )
			{
				// at angular limit
				float maxBetween = jiggleInfo->length * sin( jiggleInfo->angleLimit );

				Vector delta = goalTip - data->tipPos;
				delta.NormalizeInPlace();

				data->tipPos = goalTip - maxBetween * delta;

				forward = data->tipPos - goalBasePosition;
				forward.NormalizeInPlace();
			}
		}

		if ( jiggleInfo->flags & JIGGLE_HAS_LENGTH_CONSTRAINT )
		{
			// enforce spring length
			data->tipPos = goalBasePosition + jiggleInfo->length * forward;

			// zero velocity along forward bone axis
			data->tipVel -= DotProduct( data->tipVel, forward ) * forward;
		}

		//
		// Build bone matrix to align along current tip direction
		//
		Vector left = CrossProduct( goalUp, forward );
		left.NormalizeInPlace();

		if ( DotProduct( left, data->lastLeft ) < 0.0f )
		{
			// The bone has rotated so far its on the other side of the up vector
			// resulting in the cross product result flipping 180 degrees around the up
			// vector.  Flip it back.
			left = -left;
		}
		data->lastLeft = left;

#ifdef CLIENT_DLL
		if ( cl


 title: String,
      @Prop subtitle: String
  ): Component =
      Column.create(c)
          .paddingDip(ALL, 16f)
          .backgroundColor(color)
          .child(Text.create(c).text(title).textSizeSp(40f))
          .child(Text.create(c).text(subtitle).textSizeSp(20f))
          .build()
}
/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * 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 com.facebook.litho.widget.collection

import androidx.recyclerview.widget.DiffUtil
import com.facebook.litho.testing.testrunner.LithoTestRunner
import org.assertj.core.api.Assertions.assertThat
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.annotation.LooperMode

@LooperMode(LooperMode.Mode.LEGACY)
@RunWith(LithoTestRunner::class)
class CollectionDiffTest {

  val testCases =
      listOf(
          // Empty Lists
          Pair(emptyList(), emptyList()),

          // Identical Lists
          Pair(listOf(Item(1, "a"), Item(2, "b")), listOf(Item(1, "a"), Item(2, "b"))),

          // Completely Different Lists
          Pair(listOf(Item(1, "a"), Item(2, "b")), listOf(Item(3, "c"), Item(4, "d"))),

          // Single Item Change
          Pair(listOf(Item(1, "a")), listOf(Item(1, "b"))),

          // Multiple Item Changes
          Pair(listOf(Item(1, "a"), Item(2, "b")), listOf(Item(1, "c"), Item(2, "d"))),

          // Reordered Items
          Pair(listOf(Item(1, "a"), Item(2, "b")), listOf(Item(2, "b"), Item(1, "a"))),

          // Single Item Insertion
          Pair(listOf(Item(1, "a")), listOf(Item(1, "a"), Item(2, "b"))),

          // Multiple Items Insertions
          Pair(listOf(Item(1, "a")), listOf(Item(1, "a"), Item(2, "b"), Item(3, "c"))),

          // Single Item Deletion
          Pair(listOf(Item(1, "a"), Item(2, "b")), listOf(Item(1, "a"))),

          // Multiple Items Deletions
          Pair(listOf(Item(1, "a"), Item(2, "b"), Item(3, "c")), listOf(Item(1, "a"))),

          // Mixed Operations
          Pair(listOf(Item(1, "a"), Item(2, "b")), listOf(Item(1, "c"), Item(3, "d"))))

  private fun calculateDiff(oldData: List<Item>, newData: List<Item>): List<CollectionOperation> {
    val itemComparator = { a: Item, b: Item -> a.id == b.id }
    val contentComparator = { a: Item, b: Item -> a.content == b.content }
    val diffCallback = CollectionDiffCallback(oldData, newData, itemComparator, contentComparator)
    val listUpdateCallback = CollectionUpdateOperation(oldData, newData)
    DiffUtil.calculateDiff(diffCallback).dispatchUpdatesTo(listUpdateCallback)
    return listUpdateCallback.operations
  }

  @Test
  fun `test two empty lists end up no change`() {
    val operations = calculateDiff(te


ftDown = true;
      return;
    }

    // this will throw an error for special keys
    this._simplified += codeToCharacter(stroke.value, this._shiftDown);
  }

  parseSend(stroke: Stroke) {
    this._simplified += stroke.value;
  }

  parseUp(stroke: Stroke) {
    if (stroke.value.includes("Shift")) {
      this._shiftDown = false;
    }
  }

  public simplify(): string {
    this._strokes.forEach(stroke => {
      if (stroke.type === "→") this.parseSend(stroke);
      else if (stroke.type === "↓") this.parseDown(stroke);
      else if (stroke.type === "↑") this.parseUp(stroke);
    });

    return this._simplified;
  }
}

export const simplifyStrokes = (strokes: Stroke[]): string => {
  /**
   * Simplify strokes to a plain string if possible.
   * Throw an error if not possible.
   */
  const parser = new StrokeParser(strokes);
  return parser.simplify();
};
import { Module } from "webpack";

const resolves = {};
const rejects = {};
let globalMsgId = 0;

// Activate calculation in the worker, returning a promise
function sendMsg(payload, worker: Worker) {
  const msgId = globalMsgId++;
  const msg = {
    id: msgId,
    payload
  };
  return new Promise(function(resolve, reject) {
    // save callbacks for later
    resolves[msgId] = resolve;
    rejects[msgId] = reject;
    worker.postMessage(msg);

    // TODO: CHECK FOR MEMORY LEAK
  });
}
// Handle incoming calculation result
function handleMsg(msg) {
  const { id, err, payload } = msg.data;
  if (payload) {
    const resolve = resolves[id];
    if (resolve) {
      resolve(payload);
    }
  } else {
    // error condition
    const reject = rejects[id];
    if (reject) {
      if (err) {
        reject(new Error(err));
      } else {
        reject("Got nothing");
      }
    }
  }

  // purge used callbacks
  delete resolves[id];
  delete rejects[id];
}

export class Wrapper {
  worker: Worker;

  constructor(worker: Worker) {
    this.worker = worker;
    this.worker.onmessage = handleMsg;
  }

  send(str): Promise<any> {
    return sendMsg(str, this.worker);
  }
}

export function getWorker(Worker) {
  return new Wrapper(new Worker());
}
import { Controller } from '@nestjs/common';
import { Body, Get, HttpStatus, Post, Res ,Param,Delete, Patch} from '@nestjs/common';
import {CreateLotDto} from '../lots/dto/create-lot.dto';
import { UpdateLotDto} from '../lots/dto/update-lot.dto';
import {LotsService} from '../lots/lots.service';
import {Lot} from './Models/lot.model';
@Controller('lots')
export class LotsController {

    constructor(private readonly lotsService: LotsService) { }

    @Post('/')
    async createLot(@Body() craeteLotDto: CreateLotDto, @Res() res) {
        await this.lotsService.createLot(craeteLotDto);
        return res.status(HttpStatus.OK).json({ message: 'Lot has been created.' })
    }

    @Get('/')
    async getLots(@Res() res) {
        const lots = await this.lotsService.getLots();
        return res.status(HttpStatus.OK).json(lots);
    }
    @Get(':lotId')
    async getLot(@Res() res ,@Param('lotId') lotId:number): Promise<Lot>{
        const lot = await this.lotsService.getLot(lotId);


         """.trimIndent()
   }

   "Nested diffs are shown with correct indentation" {
      val actual = DataClass3(88, DataClass2(1, 3.4F, DataClass1(2, 4.6F)), 44.4)
      val expected = DataClass3(99, DataClass2(2, 4.4F, DataClass1(99, 7.6F)), 44.6)

      val throwable = assertThrows<Throwable> {
         actual shouldBe expected
      }
      throwable.message shouldStartWith """
         data class diff for com.sksamuel.kotest.eq.DataClass3
         ├ x: expected:<99> but was:<88>
         ├ y: data class diff for com.sksamuel.kotest.eq.DataClass2
         │  ├ x: expected:<2> but was:<1>
         │  ├ y: expected:<4.4f> but was:<3.4f>
         │  └ z: data class diff for com.sksamuel.kotest.eq.DataClass1
         │     ├ a: expected:<99> but was:<2>
         │     └ b: expected:<7.6f> but was:<4.6f>
         └ z: expected:<44.6> but was:<44.4>
         """.trimIndent()
   }

   "Only properties in the primary constructor are used in the diff" {
      DataClassWithMultipleConstructors(1, 2.2F, "hello") shouldBe
         DataClassWithMultipleConstructors(1, 2.2F, "goodbye")
   }

   "Only print differences of properties in the primary constructor in the diff" {
      val actual = DataClassWithMultipleConstructors(1, 2.2F, "hello")
      val expected = DataClassWithMultipleConstructors(2, 2.2F, "goodbye")

      val throwable = assertThrows<Throwable> { actual shouldBe expected }

      throwable.message shouldStartWith """
         data class diff for com.sksamuel.kotest.eq.DataClassWithMultipleConstructors
         └ a: expected:<2> but was:<1>
         """.trimIndent()
   }

   "Data class diffs are disabled when data class nesting is greater than 10 references deep" {
      val actual = (0..10).fold(null) { acc: CircularDataClass?, i ->
         CircularDataClass(i, acc)
      }
      val expected = (-1..11).fold(null) { acc: CircularDataClass?, i ->
         CircularDataClass(i, acc)
      }

      val throwable = assertThrows<Throwable> { actual shouldBe expected }

      throwable.message shouldNotStartWith "data class diff"
   }
})

class `DataClassEq AssertionConfig Tests` : StringSpec({

   afterTest { (_, _) ->
      System.setProperty("kotest.assertions.show-data-class-diffs", "true")
   }

   "Data class diffs can be disabled with a system property" {
      System.setProperty("kotest.assertions.show-data-class-diffs", "false")

      val throwable = assertThrows<Throwable> { DataClass1(1, 3.4F) shouldBe DataClass1(2, 3.5F) }

      throwable.message shouldBe "expected:<DataClass1(a=2, b=3.5)> but was:<DataClass1(a=1, b=3.4)>"
   }
})

data class CustomException(private val value: String) : Exception()
package com.sksamuel.kotest.matchers.date

import io.kotest.core.spec.style.FreeSpec
import io.kotest.matchers.date.plusOrMinus
import io.kotest.matchers.date.shouldBeAfter
import io.kotest.matchers.date.shouldBeBefore
import io.kotest.matchers.date.shouldBeBetween
import io.kotest.matchers.date.shouldBeCloseTo
import io.kotest.matchers.date.shouldNotBeAfter
import io.kotest.matchers.date.shouldNotBeBefore
import io.kotest.matchers.date.shouldNotBeBetween
import io.kotest.matchers.date.shouldNotBeCloseTo
import io.kotest.matchers.shouldBe
import io.kotest.matchers.shouldNotBe
import java.time.Instant
import kotlin.time.Duration.Companion.milliseconds
import kotlin


/* Change access and modification times of open file.  Linux version.
   Copyright (C) 2007-2024 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library 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.

   The GNU C Library 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 the GNU C Library; if not, see
   <https://www.gnu.org/licenses/>.  */

#include <errno.h>
#include <sys/stat.h>
#include <sysdep.h>
#include <time.h>
#include <kernel-features.h>

/* Helper function defined for easy reusage of the code which calls utimensat
   and utimensat_time64 syscall.  */
int
__utimensat64_helper (int fd, const char *file,
                      const struct __timespec64 tsp64[2], int flags)
{
#ifndef __NR_utimensat_time64
# define __NR_utimensat_time64 __NR_utimensat
#endif

#ifdef __ASSUME_TIME64_SYSCALLS
  return INLINE_SYSCALL_CALL (utimensat_time64, fd, file, &tsp64[0], flags);
#else
  /* For UTIME_NOW and UTIME_OMIT the value of tv_sec field is ignored.  */
# define TS_SPECIAL(ts) \
  ((ts).tv_nsec == UTIME_NOW || (ts).tv_nsec == UTIME_OMIT)

  bool need_time64 = tsp64 != NULL
		     && ((!TS_SPECIAL (tsp64[0])
			  && !in_int32_t_range (tsp64[0].tv_sec))
			 || (!TS_SPECIAL (tsp64[1])
			     && !in_int32_t_range (tsp64[1].tv_sec)));
  if (need_time64)
    {
      int r = INLINE_SYSCALL_CALL (utimensat_time64, fd, file, &tsp64[0],
				   flags);
      if (r == 0 || errno != ENOSYS)
	return r;
      __set_errno (EOVERFLOW);
      return -1;
    }

  struct timespec tsp32[2], *ptsp32 = NULL;
  if (tsp64)
    {
      tsp32[0] = valid_timespec64_to_timespec (tsp64[0]);
      tsp32[1] = valid_timespec64_to_timespec (tsp64[1]);
      ptsp32 = tsp32;
    }

  return INLINE_SYSCALL_CALL (utimensat, fd, file, ptsp32, flags);
#endif
}
libc_hidden_def (__utimensat64_helper)

/* Change the access time of FILE to TSP[0] and
   the modification time of FILE to TSP[1].

   Starting with 2.6.22 the Linux kernel has the utimensat syscall.  */
int
__utimensat64 (int fd, const char *file, const struct __timespec64 tsp64[2],
               int flags)
{
  if (file == NULL)
    return INLINE_SYSCALL_ERROR_RETURN_VALUE (EINVAL);

  return __utimensat64_helper (fd, file, &tsp64[0], flags);
}

#if __TIMESIZE != 64
libc_hidden_def (__utimensat64)

int
__utimensat (int fd, const char *file, const struct timespec tsp[2],
             int flags)
{
  struct __timespec64 tsp64[2];
  if (tsp)
    {
      tsp64[0] = valid_timespec_to_timespec64 (tsp[0]);
      tsp64[1] = valid_timespec_to_timespec64 (tsp[1]);
    }

  return __utimensat64 (fd, file, tsp ? &tsp64[0] : NULL, flags);
}
#endif
weak_alias (__utimensat, utimensat)


        /// </summary>
        /// <param name="operationJson">The json object representing operation(s) provided on the request.</param>
        /// <param name="mapJson">A map to connect files to appropriate variables in the operations collection.</param>
        /// <param name="files">The files found on the request.</param>
        /// <param name="cancellationToken">The cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
        /// <returns>A Task<MultiPartRequestGraphQLPayload> representing the asynchronous operation.</returns>
        protected virtual Task<MultiPartRequestGraphQLPayload> AssemblePayload(
            string operationJson,
            string mapJson = null,
            IReadOnlyDictionary<string, FileUpload> files = null,
            CancellationToken cancellationToken = default)
        {
            operationJson = Validation.ThrowIfNullWhiteSpaceOrReturn(operationJson, nameof(operationJson));
            mapJson = mapJson?.Trim();

            JsonNode topNode;

            try
            {
                topNode = JsonNode.Parse(operationJson, _nodeOptions, _documentOptions);
            }
            catch (Exception ex)
            {
                throw new InvalidMultiPartOperationException(
                    $"Unable to parse the '{MultipartRequestConstants.Web.OPERATIONS_FORM_KEY}' form field. The provided value is not a " +
                    $"valid json string. See inner exception for details.",
                    ex);
            }

            if (topNode.IsArray() && !_config.RequestMode.IsBatchProcessingEnabled())
            {
                throw new InvalidMultiPartOperationException(
                  $"Unable to parse the '{MultipartRequestConstants.Web.OPERATIONS_FORM_KEY}' form field. The target schema does not allow " +
                  $"batch operations.");
            }

            this.InjectMappedFileMarkers(topNode, mapJson);

            MultiPartRequestGraphQLPayload payload;
            if (!topNode.IsArray())
            {
                // single query; No Batch Processing
                var query = this.ConvertNodeToQueryData(topNode, files: files);
                payload = new MultiPartRequestGraphQLPayload(query);
            }
            else
            {
                // multiple queries; Batch Processing
                var queries = new List<GraphQueryData>();
                var i = 0;
                foreach (var node in topNode.AsArray())
                {
                    var query = this.ConvertNodeToQueryData(node, i++, files);
                    queries.Add(query);
                }

                payload = new MultiPartRequestGraphQLPayload(queries);
            }

            return Task.FromResult(payload);
        }
    }
}


thod = getEstimateSwapExactAmountInMethod =
              io.grpc.MethodDescriptor.<osmosis.gamm.v1beta1.QueryOuterClass.QuerySwapExactAmountInRequest, osmosis.gamm.v1beta1.QueryOuterClass.QuerySwapExactAmountInResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "EstimateSwapExactAmountIn"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  osmosis.gamm.v1beta1.QueryOuterClass.QuerySwapExactAmountInRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  osmosis.gamm.v1beta1.QueryOuterClass.QuerySwapExactAmountInResponse.getDefaultInstance()))
              .setSchemaDescriptor(new QueryMethodDescriptorSupplier("EstimateSwapExactAmountIn"))
              .build();
        }
      }
    }
    return getEstimateSwapExactAmountInMethod;
  }

  private static volatile io.grpc.MethodDescriptor<osmosis.gamm.v1beta1.QueryOuterClass.QuerySwapExactAmountOutRequest,
      osmosis.gamm.v1beta1.QueryOuterClass.QuerySwapExactAmountOutResponse> getEstimateSwapExactAmountOutMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "EstimateSwapExactAmountOut",
      requestType = osmosis.gamm.v1beta1.QueryOuterClass.QuerySwapExactAmountOutRequest.class,
      responseType = osmosis.gamm.v1beta1.QueryOuterClass.QuerySwapExactAmountOutResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<osmosis.gamm.v1beta1.QueryOuterClass.QuerySwapExactAmountOutRequest,
      osmosis.gamm.v1beta1.QueryOuterClass.QuerySwapExactAmountOutResponse> getEstimateSwapExactAmountOutMethod() {
    io.grpc.MethodDescriptor<osmosis.gamm.v1beta1.QueryOuterClass.QuerySwapExactAmountOutRequest, osmosis.gamm.v1beta1.QueryOuterClass.QuerySwapExactAmountOutResponse> getEstimateSwapExactAmountOutMethod;
    if ((getEstimateSwapExactAmountOutMethod = QueryGrpc.getEstimateSwapExactAmountOutMethod) == null) {
      synchronized (QueryGrpc.class) {
        if ((getEstimateSwapExactAmountOutMethod = QueryGrpc.getEstimateSwapExactAmountOutMethod) == null) {
          QueryGrpc.getEstimateSwapExactAmountOutMethod = getEstimateSwapExactAmountOutMethod =
              io.grpc.MethodDescriptor.<osmosis.gamm.v1beta1.QueryOuterClass.QuerySwapExactAmountOutRequest, osmosis.gamm.v1beta1.QueryOuterClass.QuerySwapExactAmountOutResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "EstimateSwapExactAmountOut"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  osmosis.gamm.v1beta1.QueryOuterClass.QuerySwapExactAmountOutRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  osmosis.gamm.v1beta1.QueryOuterClass.QuerySwapExactAmountOutResponse.


text-decoration:none; vertical-align:baseline">Vô số các kiếm kích được thi triển dội về phía trước rồi phía trước nữa nhanh chóng xuyên thủng hàng rào Ma Giáo dày đặc tựa như một chiếc dùi.

Không nhất thiết phải nhắm vào đầu. Việc mà bọn hắn phải làm không phải là giết chết hay quật ngã kẻ địch. Chỉ cần tạo ra một con đường hướng thẳng đến tửu lầu mà thôi!

“Lũ chó chết các ngươi!!!”

Các Chấp Pháp Sứ Giả nghiến răng lao về phía Thanh Minh. Bọn chúng tự biết phải ưu tiên giết kẻ nào trước.

Ầmm!

Nhưng Tuệ Nhiên cùng các đệ tử Hoa Sơn như thể đã hẹn nhau từ trước, bọn hắn không chỉ mở đường mà còn ngăn chặn sự tấn công từ tứ phương tám hướng của các Chấp Pháp Sứ Giả.<span style="color:#252525; font-family:Roboto; font-size:11.5pt; font-style:normal; font-variant:normal; vertical-align:b


           attrNID = NID_title;
            break;
        case kOID_AttributeType_Name:
            attrNID = NID_name;
            break;
        case kOID_AttributeType_GivenName:
            attrNID = NID_givenName;
            break;
        case kOID_AttributeType_Initials:
            attrNID = NID_initials;
            break;
        case kOID_AttributeType_GenerationQualifier:
            attrNID = NID_generationQualifier;
            break;
        case kOID_AttributeType_DNQualifier:
            attrNID = NID_dnQualifier;
            break;
        case kOID_AttributeType_Pseudonym:
            attrNID = NID_pseudonym;
            break;
        case kOID_AttributeType_DomainComponent:
            attrNID = NID_domainComponent;
            break;
        case kOID_AttributeType_MatterNodeId:
            attrNID = gNIDChipNodeId;
            break;
        case kOID_AttributeType_MatterFirmwareSigningId:
            attrNID = gNIDChipFirmwareSigningId;
            break;
        case kOID_AttributeType_MatterICACId:
            attrNID = gNIDChipICAId;
            break;
        case kOID_AttributeType_MatterVidVerificationSignerId:
            attrNID = gNIDChipVidVerificationSignerId;
            break;
        case kOID_AttributeType_MatterRCACId:
            attrNID = gNIDChipRootId;
            break;
        case kOID_AttributeType_MatterFabricId:
            attrNID = gNIDChipFabricId;
            break;
        case kOID_AttributeType_MatterCASEAuthTag:
            attrNID = gNIDChipCASEAuthenticatedTag;
            break;
        default:
            ExitNow(res = false);
        }

        char chipAttrStr[std::max(kChip64bitAttrUTF8Length, kChip32bitAttrUTF8Length)] = { 0 };
        int type                                                                       = V_ASN1_UTF8STRING;
        uint8_t * attrStr                                                              = reinterpret_cast<uint8_t *>(chipAttrStr);
        int attrLen                                                                    = 0;

        if (IsChip64bitDNAttr(rdn[i].mAttrOID))
        {
            VerifyOrReturnError(Encoding::Uint64ToHex(rdn[i].mChipVal, chipAttrStr, kChip64bitAttrUTF8Length,
                                                      Encoding::HexFlags::kUppercase) == CHIP_NO_ERROR,
                                false);
            attrLen = kChip64bitAttrUTF8Length;
        }
        else if (IsChip32bitDNAttr(rdn[i].mAttrOID))
        {
            VerifyOrReturnError(Encoding::Uint32ToHex(static_cast<uint32_t>(rdn[i].mChipVal), chipAttrStr, kChip32bitAttrUTF8Length,
                                                      Encoding::HexFlags::kUppercase) == CHIP_NO_ERROR,
                                false);
            attrLen = kChip32bitAttrUTF8Length;
        }
        else
        {
            if (rdn[i].mAttrOID == kOID_AttributeType_DomainComponent)
            {
                type = V_ASN1_IA5STRING;
            }
            else if (rdn[i].mAttrIsPrintableString)
            {
                type = V_ASN1_PRINTABLESTRING;
            }
            attrStr = reinterpret_cast<uint8_t *>(const_cast<char *>(rdn[i].mString.data()));
            attrLen = static_cast<int>(rdn[i].mString.size());
        }

        if (!X509_NAME_add_entry_by_NID(name, attrNID, type, attrStr, attrLen, -1, 0))
        {
            ReportOpenSSLErrorAndExit("X


une(modulePath, this.configuration.packagerOptions, version).tap(() => {
                      if (this.log) {
                        this.log.verbose(`Prune: ${modulePath} [${_.now() - startPrune} ms]`);
                      } else {
                        this.options.verbose &&
                          this.serverless.cli.log(`Prune: ${modulePath} [${_.now() - startPrune} ms]`);
                      }
                    });
                  });
                })
                .then(() => {
                  // Prune extraneous packages - removes not needed ones
                  const startRunScripts = _.now();
                  return packager.runScripts(modulePath, _.keys(packageScripts)).tap(() => {
                    if (this.log) {
                      this.log.verbose(`Run scripts: ${modulePath} [${_.now() - startRunScripts} ms]`);
                    } else {
                      this.options.verbose &&
                        this.serverless.cli.log(`Run scripts: ${modulePath} [${_.now() - startRunScripts} ms]`);
                    }
                  });
                });
            })
            .return();
        });
    });
  }
};
'use strict';
/**
 * NPM packager.
 */

const _ = require('lodash');
const BbPromise = require('bluebird');
const Utils = require('../utils');
const { join } = require('path');
const fse = require('fs-extra');
const fs = require('fs');

class NPM {
  // eslint-disable-next-line lodash/prefer-constant
  static get lockfileName() {
    return 'package-lock.json';
  }

  // eslint-disable-next-line lodash/prefer-constant
  static get mustCopyModules() {
    return true;
  }

  static copyPackageSectionNames(packagerOptions) {
    const options = packagerOptions || {};
    return options.copyPackageSectionNames || [];
  }

  static getPackagerVersion(cwd) {
    const command = /^win/.test(process.platform) ? 'npm.cmd' : 'npm';
    const args = ['-v'];

    return Utils.spawnProcess(command, args, { cwd })
      .catch(err => {
        return BbPromise.resolve({ stdout: err.stdout });
      })
      .then(processOutput => processOutput.stdout);
  }

  static getProdDependencies(cwd, depth, packagerOptions) {
    // Try to use NPM lockfile v2 when possible
    const options = packagerOptions || {};
    const lockPath = join(cwd, options.lockFile || NPM.lockfileName);
    if (fse.pathExistsSync(lockPath)) {
      const lock = Utils.safeJsonParse(fs.readFileSync(lockPath));
      if (lock.lockfileVersion === 2) {
        return BbPromise.resolve(lock);
      }
    }

    // Get first level dependency graph
    const command = /^win/.test(process.platform) ? 'npm.cmd' : 'npm';
    const args = [
      'ls',
      '-prod', // Only prod dependencies
      '-json',
      `-depth=${depth || 1}`
    ];

    const ignoredNpmErrors = [
      { npmError: 'code ELSPROBLEMS', log: false }, // npm >= 7
      { npmError: 'extraneous', log: false },
      { npmError: 'missing', log: false },
      { npmError: 'peer dep missing', log: true }
    ];

    return Utils.spawnProcess(command, args, {
      cwd: cwd
    })
      .catch(err => {
        if (err instanceof Utils.SpawnError) {
          // Only exit with an error if we have critical npm errors for 2nd level inside
          // ignoring any extra output from npm >= 7
          const lines = _.split(err.stderr, '\n');
          const errors = _.takeWhile(lines, line


ral.String.Regex */
.codehilite.github-dark .s1 { color: #A5D6FF } /* Literal.String.Single */
.codehilite.github-dark .ss { color: #A5D6FF } /* Literal.String.Symbol */
.codehilite.github-dark .bp { color: #E6EDF3 } /* Name.Builtin.Pseudo */
.codehilite.github-dark .fm { color: #D2A8FF; font-weight: bold } /* Name.Function.Magic */
.codehilite.github-dark .vc { color: #79C0FF } /* Name.Variable.Class */
.codehilite.github-dark .vg { color: #79C0FF } /* Name.Variable.Global */
.codehilite.github-dark .vi { color: #79C0FF } /* Name.Variable.Instance */
.codehilite.github-dark .vm { color: #79C0FF } /* Name.Variable.Magic */
.codehilite.github-dark .il { color: #A5D6FF } /* Literal.Number.Integer.Long */
.codehilite.github-dark-colorblind .hll { background-color: #58a6ff70 }
.codehilite.github-dark-colorblind { background: #0d1117; color: #C9D1D9 }
.codehilite.github-dark-colorblind .c { color: #B1BAC4 } /* Comment */
.codehilite.github-dark-colorblind .err { color: #EC8E2C } /* Error */
.codehilite.github-dark-colorblind .k { color: #EC8E2C } /* Keyword */
.codehilite.github-dark-colorblind .l { color: #FDAC54 } /* Literal */
.codehilite.github-dark-colorblind .n { color: #D2A8FF } /* Name */
.codehilite.github-dark-colorblind .o { color: #A5D6FF } /* Operator */
.codehilite.github-dark-colorblind .p { color: #C9D1D9 } /* Punctuation */
.codehilite.github-dark-colorblind .ch { color: #B1BAC4 } /* Comment.Hashbang */
.codehilite.github-dark-colorblind .cm { color: #B1BAC4 } /* Comment.Multiline */
.codehilite.github-dark-colorblind .cp { color: #B1BAC4 } /* Comment.Preproc */
.codehilite.github-dark-colorblind .cpf { color: #B1BAC4 } /* Comment.PreprocFile */
.codehilite.github-dark-colorblind .c1 { color: #B1BAC4 } /* Comment.Single */
.codehilite.github-dark-colorblind .cs { color: #B1BAC4 } /* Comment.Special */
.codehilite.github-dark-colorblind .gd { color: #79C0FF } /* Generic.Deleted */
.codehilite.github-dark-colorblind .ge { font-style: italic } /* Generic.Emph */
.codehilite.github-dark-colorblind .gr { color: #EC8E2C } /* Generic.Error */
.codehilite.github-dark-colorblind .gh { color: #79C0FF } /* Generic.Heading */
.codehilite.github-dark-colorblind .gs { font-weight: bold } /* Generic.Strong */
.codehilite.github-dark-colorblind .gu { color: #79C0FF } /* Generic.Subheading */
.codehilite.github-dark-colorblind .kc { color: #79C0FF } /* Keyword.Constant */
.codehilite.github-dark-colorblind .kd { color: #EC8E2C } /* Keyword.Declaration */
.codehilite.github-dark-colorblind .kn { color: #EC


|s| s.to_string().into()).collect();
        // Format bar will panic with some potentially confusing message, better to panic here
        // with a message explicitly informing of the problem
        assert!(
            self.progress_chars.len() >= 2,
            "at least 2 tick strings required"
        );
        self
    }

    /// Sets the progress characters `(filled, current, to do)`
    ///
    /// You can pass more than three for a more detailed display.
    /// All passed grapheme clusters need to be of equal width.
    pub fn progress_chars(mut self, s: &str) -> ProgressStyle {
        self.progress_chars = segment(s);
        // Format bar will panic with some potentially confusing message, better to panic here
        // with a message explicitly informing of the problem
        assert!(
            self.progress_chars.len() >= 2,
            "at least 2 progress chars required"
        );
        self.char_width = width(&self.progress_chars);
        self
    }

    /// Adds a custom key that references a `&ProgressState` to the template
    pub fn with_key(mut self, key: &'static str, f: Format) -> ProgressStyle {
        self.format_map.0.insert(key, f);
        self
    }

    /// Sets the template string for the progress bar
    ///
    /// Review the [list of template keys](./index.html#templates) for more information.
    pub fn template(mut self, s: &str) -> ProgressStyle {
        self.template = s.into();
        self
    }

    /// Sets the finish behavior for the progress bar
    ///
    /// This behavior is invoked when [`ProgressBar`] or
    /// [`ProgressBarIter`] completes and
    /// [`ProgressBar::is_finished()`] is false.
    /// If you don't want the progress bar to be automatically finished then
    /// call `on_finish(None)`.
    ///
    /// [`ProgressBar`]: crate::ProgressBar
    /// [`ProgressBarIter`]: crate::ProgressBarIter
    /// [`ProgressBar::is_finished()`]: crate::ProgressBar::is_finished
    pub fn on_finish(mut self, finish: ProgressFinish) -> ProgressStyle {
        self.on_finish = finish;
        self
    }

    /// Returns the tick char for a given number
    #[deprecated(since = "0.13.0", note = "Deprecated in favor of get_tick_str")]
    pub fn get_tick_char(&self, idx: u64) -> char {
        self.get_tick_str(idx).chars().next().unwrap_or(' ')
    }

    /// Returns the tick string for a given number
    pub fn get_tick_str(&self, idx: u64) -> &str {
        &self.tick_strings[(idx as usize) % (self.tick_strings.len() - 1)]
    }

    /// Returns the tick char for the finished state
    #[deprecated(since = "0.13.0", note = "Deprecated in favor of get_final_tick_str")]
    pub fn get_final_tick_char(&self) -> char {
        self.get_final_tick_str().chars().next().unwrap_or(' ')
    }

    /// Returns the tick string for the finished state
    pub fn get_final_tick_str(&self) -> &str {
        &self.tick_strings[self.tick_strings.len() - 1]
    }

    /// Returns the finish behavior
    pub fn get_on_finish(&self) -> &ProgressFinish {
        &self.on_finish
    }

    pub(crate) fn format_bar(&self, fract: f32, width: usize, alt_style: Option<&Style>) -> String {
        // The number of clusters from progress


// Base text effects.
var (
	reset      = "\x1b[0m"
	bold       = "\x1b[1m"
	dim        = "\x1b[2m"
	underscore = "\x1b[4m"
	blink      = "\x1b[5m"
	reverse    = "\x1b[7m"

	// Effects reset.
	boldReset       = "\x1b[22m" // 21 actually causes underline instead
	dimReset        = "\x1b[22m"
	underscoreReset = "\x1b[24m"
	blinkReset      = "\x1b[25m"
	reverseReset    = "\x1b[27m"
)

// SetDefaultCommandHighlight allows the user to change the highlight color for a command in the default syntax
// highlighter using an ansi code.
// This action has no effect if a custom syntax highlighter for the shell is set.
// By default, the highlight code is green ("\x1b[32m").
func (c *Console) SetDefaultCommandHighlight(seq string) {
	c.cmdHighlight = seq
}

// SetDefaultFlagHighlight allows the user to change the highlight color for a flag in the default syntax
// highlighter using an ansi color code.
// This action has no effect if a custom syntax highlighter for the shell is set.
// By default, the highlight code is grey ("\x1b[38;05;244m").
func (c *Console) SetDefaultFlagHighlight(seq string) {
	c.flagHighlight = seq
}

// highlightSyntax - Entrypoint to all input syntax highlighting in the Wiregost console.
func (c *Console) highlightSyntax(input []rune) (line string) {
	// Split the line as shellwords
	args, unprocessed, err := split(string(input), true)
	if err != nil {
		args = append(args, unprocessed)
	}

	highlighted := make([]string, 0)   // List of processed words, append to
	remain := args                     // List of words to process, draw from
	trimmed := trimSpacesMatch(remain) // Match stuff against trimmed words

	// Highlight the root command when found.
	cmd, _, _ := c.activeMenu().Find(trimmed)
	if cmd != nil {
		highlighted, remain = c.highlightCommand(highlighted, args, cmd)
	}

	// Highlight command flags
	highlighted, remain = c.highlightCommandFlags(highlighted, remain, cmd)

	// Done with everything, add remainind, non-processed words
	highlighted = append(highlighted, remain...)

	// Join all words.
	line = strings.Join(highlighted, "")

	return line
}

func (c *Console) highlightCommand(done, args []string, _ *cobra.Command) ([]string, []string) {
	highlighted := make([]string, 0)
	var rest []string

	if len(args) == 0 {
		return done, args
	}

	// Highlight the root command when found, or any of its aliases.
	for _, cmd := range c.activeMenu().Commands() {
		// Change 1: Highlight based on first arg in usage rather than the entire usage itself
		cmdFound := strings.Split(cmd.Use, " ")[0] == strings.TrimSpace(args[0])

		for _, alias := range cmd.Aliases {
			if alias == strings.TrimSpace(args[0]) {
				cmdFound = true
				break
			}
		}

		if cmdFound {
			highlighted = append(highlighted, bold+c.cmdHighlight+args[0]+seqFgReset+boldReset)
			rest = args[1:]

			return append(done, highlighted...), rest
		}
	}

	return append(done, highlighted...), args
}

func (c *Console) highlightCommandFlags(done, args []string, _ *cobra.Command) ([]string, []string) {
	highlighted := make([]string, 0)
	var rest []string

	if len(args) == 0 {
		return done, args
	}

	for _, arg := range args {
		if strings.HasPrefix(arg, "-") || strings.HasPrefix(arg, "--") {
			highlighted = append(highlighted, bold+c.flagHighlight+arg+seqFgReset+boldRes


Fórmula: encantar brazales: espíritu menor",
[6345] = "Fórmula: imbuir capa: protección",
[6346] = "Fórmula: encantar pechera: maná inferior",
[6347] = "Fórmula: encantar brazales: fuerza menor",
[6348] = "Fórmula: encantar arma: Destripadora de bestias menor",
[6349] = "Fórmula: encantar arma de 2M: intelecto inferior",
[6350] = "Botas de bronce férreas",
[6351] = "Cajón abollado",
[6352] = "Cajón encharcado",
[6353] = "Cofre pequeño",
[6354] = "Cofre cerrado pequeño",
[6355] = "Cofre cerrado robusto",
[6356] = "Cofre maltrecho",
[6357] = "Cajón sellado",
[6358] = "Bocanegra graso",
[6359] = "Pargo de fuego",
[6360] = "Pez de escamas de acero",
[6361] = "Atún blanco arco iris crudo",
[6362] = "Bacalao piedrescama crudo",
[6363] = "Siluro de 14 kilos",
[6364] = "Siluro de 16 kilos",
[6365] = "Caña de pescar fuerte",
[6366] = "Caña de pescar Leñoscuro",
[6367] = "Caña de pescar de hierro grande",
[6368] = "Receta: atún blanco arco iris",
[6369] = "Receta: bacalao piedrescama",
[6370] = "Aceite de bocanegra",
[6371] = "Aceite de Fuego",
[6372] = "Poción de velocidad de nado",
[6373] = "Elixir de poder de Fuego",
[6374] = "Partículas encantadas",
[6375] = "Fórmula: encantar brazales: espíritu inferior",
[6376] = "Fórmula: encantar botas: aguante menor",
[6377] = "Fórmula: encantar botas: agilidad menor",
[6378] = "Manteo de vidente",
[6379] = "Cinturón de cuero con inscripciones",
[6380] = "Rodela con inscripciones",
[6381] = "Capa brillante",
[6382] = "Cinturón de cuero de bosque",
[6383] = "Rodela de bosque",
[6384] = "Camisa azul con estilo",
[6385] = "Camisa verde con estilo",
[6386] = "Musleras de malla de luz trémula",
[6387] = "Brazales de malla de luz trémula",
[6388] = "Espaldares de malla de luz trémula",
[6389] = "Almófar de malla de luz trémula",
[6390] = "Patrón: camisa azul con estilo",
[6391] = "Patrón: camisa verde con estilo",
[6392] = "Cinturón de Arugal",
[6393] = "Guantes de hilo de plata",
[6394] = "Botas de hilo de plata",
[6395] = "Amito de hilo de plata",
[6396] = "Pechera blasonada",
[6397] = "Guantes blasonados",
[6398] = "Cinturón blasonado",
[6399] = "Sobrehombros blasonados",
[6400] = "Escudo de luz trémula",
[


using Avalonia.Animation;
using Avalonia.Styling;
using Garyon.Extensions;
using Garyon.Objects;
using Syndiesis.Updating;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;

namespace Syndiesis.Controls.Updating;

public partial class UpdateProgressBar : UserControl
{
    private ProgressColumnDistributor _progressBarColumnDistributor;

    public UpdateProgressBar()
    {
        InitializeComponent();
        InitializeEvents();
        InitializeDistribution();
        UpdateProgress();
        UpdateGradientDisplay();
        SetFlowAnimation();
    }

    [MemberNotNull(nameof(_progressBarColumnDistributor))]
    private void InitializeDistribution()
    {
        var columns = progressBarGrid.ColumnDefinitions;
        _progressBarColumnDistributor = new(
            columns[0], columns[1]);
    }

    private void InitializeEvents()
    {
        var updateManager = Singleton<UpdateManager>.Instance;
        updateManager.UpdaterPropertyChanged += HandlePropertyChanged;
        updateManager.UpdaterStateChanged += HandleStateChanged;
    }

    private void HandleStateChanged(object? sender, UpdateManager.State state)
    {
        Dispatcher.UIThread.InvokeAsync(UpdateGradientDisplay);
    }

    private void UpdateGradientDisplay()
    {
        var manager = Singleton<UpdateManager>.Instance;
        var state = manager.UpdateState;
        bool isDownloaded = state is UpdateManager.State.ReadyToInstall;
        gradientAnimationBorder.Opacity = isDownloaded ? 1 : 0;
    }

    private void HandlePropertyChanged(object? sender, PropertyChangedEventArgs e)
    {
        Dispatcher.UIThread.InvokeAsync(UpdateProgress);
    }

    private void UpdateProgress()
    {
        var manager = Singleton<UpdateManager>.Instance;
        var progress = manager.DownloadProgress;
        bool isDownloading = ShouldShowDownloadProgress(manager.UpdateState);

        noUpdateInformationText.IsVisible = !isDownloading;
        downloadProgressTextGrid.IsVisible = isDownloading;

        if (!isDownloading)
        {
            return;
        }

        var progressRatio = progress!.Value.Progress;
        _progressBarColumnDistributor.SetProgressRatio(progressRatio);

        downloadedMegabytesText.Text = MegabyteString(progress!.Value.DownloadedBytes);
        updateMegabytesText.Text = MegabyteString(progress!.Value.TotalBytes.ZeroOrGreater());
    }

    private static bool ShouldShowDownloadProgress(UpdateManager.State state)
    {
        return state
            is UpdateManager.State.DiscoveredUpdate
            or UpdateManager.State.Downloading
            or UpdateManager.State.ReadyToInstall
            or UpdateManager.State.Installing
            or UpdateManager.State.InstallationFailed
            ;
    }

    private static string MegabyteString(long bytes)
    {
        const double megabyteSize = 1024 * 1024;
        var megabytes = bytes / megabyteSize;
        return megabytes.ToString("N2");
    }

    private void SetFlowAnimation()
    {
        Styles.Add(new Style(x => x.OfType<Border>().Name(nameof(gradientAnimationBorder)))
        {
            Animations =
            {
                CreateFlowAnimation(),
            }
        });
    }

    private static Animation CreateFlowAnimation()
    {
        var parameters


dcdcdc,#e3e3e3 25%,#e9e9e9 45%);background-image:linear-gradient(bottom,#dcdcdc,#e3e3e3 25%,#e9e9e9 45%)}.x-nlg .x-tab-default-bottom-mc{background-image:url('../../extjs/resources/themes/images/default/tab/tab-default-bottom-bg.gif');background-color:#e9e9e9}.x-nbr .x-tab-default-bottom{padding:0!important;border-width:0!important;-webkit-border-radius:0;-moz-border-radius:0;-ms-border-radius:0;-o-border-radius:0;border-radius:0;background-color:transparent;background-position:1100000px 1000404px}.x-nbr .x-tab-default-bottom-tl,.x-nbr .x-tab-default-bottom-bl,.x-nbr .x-tab-default-bottom-tr,.x-nbr .x-tab-default-bottom-br,.x-nbr .x-tab-default-bottom-tc,.x-nbr .x-tab-default-bottom-bc,.x-nbr .x-tab-default-bottom-ml,.x-nbr .x-tab-default-bottom-mr{zoom:1;background-image:url('../../extjs/resources/themes/images/default/tab/tab-default-bottom-corners.gif')}.x-nbr .x-tab-default-bottom-ml,.x-nbr .x-tab-default-bottom-mr{zoom:1;background-image:url('../../extjs/resources/themes/images/default/tab/tab-default-bottom-sides.gif');background-position:0 0}.x-nbr .x-tab-default-bottom-mc{padding:0}.x-strict .x-ie7 .x-tab-default-bottom-tl,.x-strict .x-ie7 .x-tab-default-bottom-bl{position:relative;right:0}.x-tab{z-index:1;margin:0 0 0 2px;display:inline-block;zoom:1;*display:inline;white-space:nowrap;height:20px;border-color:#b4b4b4;cursor:pointer;cursor:hand}.x-tab button{cursor:pointer;cursor:hand}.x-tab em{display:block;padding:0 6px;line-height:1px}.x-tab button{background:0;border:0;padding:0;margin:0;-webkit-appearance:none;font-size:11px;font-weight:bold;font-family:Helvetica Neue,Arial,sans-serif;color:#6e6e6e;outline:0 none;overflow-x:visible}.x-tab button::-moz-focus-inner{border:0;padding:0}.x-tab button .x-tab-inner{background-color:transparent;background-repeat:no-repeat;background-position:0 -2px;display:block;text-align:center;white-space:nowrap;text-overflow:ellipsis;-o-text-overflow:ellipsis;overflow:hidden}.x-tab img{display:none}.x-border-box .x-tab-default-top{height:21px}.x-border-box .x-tab-default-bottom{height:21px}* html .x-ie .x-tab button{width:1px}.x-strict .x-ie6 .x-tab .x-frame-mc,.x-strict .x-ie7 .x-tab .x-frame-mc{height:100%}.x-ie .x-tab-active button:active{position:relative;top:-1px;left:-1px}.x-tab-default-top{-webkit-box-shadow:white 0 1px 0 0 inset,white -1px 0 0 0 inset,white 1px 0 0 0 inset;-moz-box-shadow:white 0 1px 0 0 inset,white -1px 0 0 0 inset,white 1px 0 0 0 inset;box-shadow:white 0 1px 0 0 inset,white -1px 0 0 0 inset,white 1px 0 0 0 inset;border-bottom:1px solid #bfbfbf!importa


8, 4:7, vgx2], { z17.b, z18.b }, z0.b
// CHECK-ENCODING: [0x29,0x02,0x20,0xc1]
// CHECK-ERROR: instruction requires: sme2
// CHECK-UNKNOWN: c1200229 <unknown>

smlsll  za.s[w8, 4:7], {z17.b - z18.b}, z0.b  // 11000001-00100000-00000010-00101001
// CHECK-INST: smlsll  za.s[w8, 4:7, vgx2], { z17.b, z18.b }, z0.b
// CHECK-ENCODING: [0x29,0x02,0x20,0xc1]
// CHECK-ERROR: instruction requires: sme2
// CHECK-UNKNOWN: c1200229 <unknown>

smlsll  za.s[w8, 4:7, vgx2], {z1.b, z2.b}, z14.b  // 11000001-00101110-00000000-00101001
// CHECK-INST: smlsll  za.s[w8, 4:7, vgx2], { z1.b, z2.b }, z14.b
// CHECK-ENCODING: [0x29,0x00,0x2e,0xc1]
// CHECK-ERROR: instruction requires: sme2
// CHECK-UNKNOWN: c12e0029 <unknown>

smlsll  za.s[w8, 4:7], {z1.b - z2.b}, z14.b  // 11000001-00101110-00000000-00101001
// CHECK-INST: smlsll  za.s[w8, 4:7, vgx2], { z1.b, z2.b }, z14.b
// CHECK-ENCODING: [0x29,0x00,0x2e,0xc1]
// CHECK-ERROR: instruction requires: sme2
// CHECK-UNKNOWN: c12e0029 <unknown>

smlsll  za.s[w10, 0:3, vgx2], {z19.b, z20.b}, z4.b  // 11000001-00100100-01000010-01101000
// CHECK-INST: smlsll  za.s[w10, 0:3, vgx2], { z19.b, z20.b }, z4.b
// CHECK-ENCODING: [0x68,0x42,0x24,0xc1]
// CHECK-ERROR: instruction requires: sme2
// CHECK-UNKNOWN: c1244268 <unknown>

smlsll  za.s[w10, 0:3], {z19.b - z20.b}, z4.b  // 11000001-00100100-01000010-01101000
// CHECK-INST: smlsll  za.s[w10, 0:3, vgx2], { z19.b, z20.b }, z4.b
// CHECK-ENCODING: [0x68,0x42,0x24,0xc1]
// CHECK-ERROR: instruction requires: sme2
// CHECK-UNKNOWN: c1244268 <unknown>

smlsll  za.s[w8, 0:3, vgx2], {z12.b, z13.b}, z2.b  // 11000001-00100010-00000001-10001000
// CHECK-INST: smlsll  za.s[w8, 0:3, vgx2], { z12.b, z13.b }, z2.b
// CHECK-ENCODING: [0x88,0x01,0x22,0xc1]
// CHECK-ERROR: instruction requires: sme2
// CHECK-UNKNOWN: c1220188 <unknown>

smlsll  za.s[w8, 0:3], {z12.b - z13.b}, z2.b  // 11000001-00100010-00000001-10001000
// CHECK-INST: smlsll  za.s[w8, 0:3, vgx2], { z12.b, z13.b


 dibujar una flecha triangular para el `Popover`.
///
/// Esta clase extiende de `CustomPainter` y permite dibujar una flecha triangular
/// que se utilizará para el indicador del popover.
/// El color de la flecha es configurable a través del parámetro `fillColor`, que se
/// pasa al constructor. La flecha se dibuja utilizando el `Canvas` para crear el
/// triángulo, que tiene una base en la parte inferior y un vértice en la parte superior.
///
/// Se dibuja un triángulo apuntando hacia arriba o hacia abajo segun el parametro
/// [isPointingUp].
class TrianglePainter extends CustomPainter {
  // COLOR QUE SE UTILIZA PARA RELLENAR EL TRIANGULO
  final Color fillColor;
  // SI ES TRUE, LA FLECHA APUNTA HACIA ARRIBA Y SI NO, HACIA ABAJO
  final bool isPointingUp;

  TrianglePainter({required this.fillColor, this.isPointingUp = true,});

  @override
  void paint(Canvas canvas, Size size) {
    // SE CREA UN OBJETO Paint PARA DEFINIR LAS PROPIEDADES DE ESTILO DEL TRIANGULO
    final paint = Paint()
      ..color = fillColor // ESTABLECE EL COLOR DEL TRIANGULO
      ..style = PaintingStyle.fill; // SE ESTABLECE EL ESTILO DE RELLENO (SIN BORDES)

    // OBJETO PATH PARA DIBUJAR LA FORMA DEL TRIANGULO
    final path = Path();

    // COMIENZA EL TRAZO DEL TRIANGULO DESDE LA ESQUINA INFERIOR IZQUIERDA
    path.moveTo(0, isPointingUp ? size.height : 0);

    // LINEA HACIA EL VERTICE SUPERIOR DEL TRIANGULO
    path.lineTo(size.width / 2, isPointingUp ? 0 : size.height);

    // LINEA DESDE EL VERTICE HASTA LA ESQUINA INFERIOR DERECHA
    path.lineTo(size.width, isPointingUp ? size.height : 0);

    // SE CIERRA EL TRIANGULO CONECTANDO EL ULTIMO PUNTO CON EL PRIMERO
    path.close();

    // SE DIBUJA EL TRIANGULO CON EL COLOR Y ESTILO DEFINIDO
    canvas.drawPath(path, paint);
  }

  @override
  bool shouldRepaint(covariant CustomPainter oldDelegate) {
    // NO ES NECESARIO REPINTAR, YA QEU EL TRIANGULO NO CAMBIA DESPUES DE SER DIBUJADO
    return false;
  }
}import 'package:esteladevega_tfg_cubex/data/dao/supebase/cubetype_dao_sb.dart';
import 'package:esteladevega_tfg_cubex/data/database/database_helper.dart';
import 'package:flutter/cupertino.dart';
import 'package:provider/provider.dart';

import '../../model/session.dart';
import '../../viewmodel/current_cube_type.dart';
import '../../viewmodel/current_session.dart';

/// Clase encargada de gestionar las operaciones CRUD sobre las **sesiones**.
///
/// Esta clase permite interactuar con la base de datos para obtener, insertar,
/// eliminar o verificar la existencia de sesiones. Utiliza la clase `DatabaseHelper`
/// para realizar las consultas y operaciones necesarias sobre la base de datos.
class SessionDao {
  /// Método para insertar una nueva sesión en la base de datos.
  ///
  /// Este método recibe un objeto [Session] que contiene los detalles de la sesión a insertar,
  /// como el [idUser], [sessionName], [idCubeType], y [creationDate].
  ///
  /// Parámetros:
  /// - `session`: Objeto de tipo [Session] que contiene los datos de la sesión a insertar.
  ///


#pragma once

// clang-format off
/*!
 * @brief アイテム生成条件フラグ
 */
enum class ItemGenerationTraitType {
	INSTA_ART         =  0, //!< 固定アーティファクトになる / Item must be an artifact
    QUESTITEM         =  1, //!< クエスト専用アイテム / quest level item -KMW-
    XTRA_POWER        =  2, //!< 追加能力を得る / Extra power
    ONE_SUSTAIN       =  3, //!< 追加維持を得る / One sustain
    XTRA_RES_OR_POWER =  4, //!< 追加能力or耐性を得る / Extra resistance or power
    XTRA_H_RES        =  5, //!< 追加上位耐性を得る / Extra high resistance
    XTRA_E_RES        =  6, //!< 追加元素耐性を得る / Extra element resistance
    XTRA_L_RES        =  7, //!< 王者の加護版追加耐性を得る / Extra lordly resistance
    XTRA_D_RES        =  8, //!< ドラゴン的追加耐性を得る / Extra dragon resistance
    XTRA_RES          =  9, //!< 追加耐性を得る / Extra resistance
    CURSED            = 10, //!< 呪われている / Item is Cursed
    HEAVY_CURSE       = 11, //!< 重い呪い / Item is Heavily Cursed
    PERMA_CURSE       = 12, //!< 永遠の呪い / Item is Perma Cursed
    RANDOM_CURSE0     = 13, //!< 軽い呪い効果を付ける / Item is Random Cursed
    RANDOM_CURSE1     = 14, //!< 呪い効果を付ける(太古と反感以外) / Item is Random Cursed
    RANDOM_CURSE2     = 15, //!< 重い呪い効果を付ける / Item is Random Cursed
    XTRA_DICE         = 16, //!< ダイス数を増やす / Extra dice
    POWERFUL          = 17, //!< 呪われているが修正値を正にする / Item has good value even if Cursed
    LIGHT_WEIGHT      = 18, //!< 重量を軽くする(2/3倍) / Make lighten (エゴ用、他は重量を普通に設定でよい)
    HEAVY_WEIGHT      = 19, //!< 重量を重くする(4/3倍) / Make heavy (エゴ用、他は重量を普通に設定でよい)
    XTRA_AC           = 20, //!< ベースACを上げる / Add base AC (エゴ用、他はACを普通に設定でよい)
    HIGH_TELEPATHY    = 21, //!< 高水準のテレパシーを付ける(テレパシーの冠) / Add high quarity esps.
    LOW_TELEPATHY     = 22, //!< 中水準のテレパシーを付ける(鋭敏) / Add middle quarity esps.
    XTRA_L_ESP        = 23, //!< 種族テレパシーを得る / Extra racial esp.
    MOD_ACCURACY      = 24, //!< 命中偏重の殺戮修正にする / Adjust to-hit more than to-dam.
    MOD_VELOCITY      = 25, //!< ダメージ偏重の殺戮修正にする / Adjust to-dam more than to-hit.
    XTRA_DICE_SIDE    = 26, //!< ダイス面を増やす / Extra dice side
    ADD_DICE          = 27, //!< ダイス数を1増やす / Add dice number
    DOUBLED_DICE      = 28, //!< ダイス数を2倍にする / Doubled dice number
    MAX,
};
// clang-format on


aApiKeyTemplate().adjustIndex(loginId, session);
	}

	/**
	 * 获取指定 loginId 的 ApiKey 列表记录
	 * @param loginId /
	 * @return /
	 */
	public static List<ApiKeyModel> getApiKeyList(Object loginId) {
		return SaApiKeyManager.getSaApiKeyTemplate().getApiKeyList(loginId);
	}

}
/*
 * Copyright 2020-2099 sa-token.cc
 *
 * 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 cn.dev33.satoken.context.dubbo.model;

import cn.dev33.satoken.context.model.SaResponse;
import org.apache.dubbo.rpc.RpcContext;

/**
 * 对 SaResponse 包装类的实现（Dubbo 版）
 *
 * @author click33
 * @since 1.34.0
 */
public class SaResponseForDubbo implements SaResponse {

	/**
	 * 底层Request对象
	 */
	protected RpcContext rpcContext;

	/**
	 * 实例化
	 * @param rpcContext rpcContext对象
	 */
	public SaResponseForDubbo(RpcContext rpcContext) {
		this.rpcContext = rpcContext;
	}

	/**
	 * 获取底层源对象
	 */
	@Override
	public Object getSource() {
		return rpcContext;
	}

	/**
	 * 设置响应状态码
	 */
	@Override
	public SaResponse setStatus(int sc) {
		// 不回传 status 状态
		return this;
	}

	/**
	 * 在响应头里写入一个值
	 */
	@Override
	public SaResponse setHeader(String name, String value) {
		// 不回传 header响应头
		return this;
	}

	/**
	 * 在响应头里添加一个值
	 * @param name 名字
	 * @param value 值
	 * @return 对象自身
	 */
	public SaResponse addHeader(String name, String value) {
		// 不回传 header响应头
		return this;
	}

	/**
	 * 重定向
	 */
	@Override
	public Object redirect(String url) {
		// 不回传 重定向 动作
		return null;
	}

}
/*
 * Copyright 2020-2099 sa-token.cc
 *
 * 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 cn.dev33.satoken


;
    word-spacing: normal;
    word-break: normal;
    word-wrap: normal;
	background: #f5f7ff;
	color: #474d62;
    -moz-tab-size: 4;
    -o-tab-size: 4;
    tab-size: 4;
    -webkit-hyphens: none;
    -moz-hyphens: none;
    -ms-hyphens: none;
    hyphens: none;
}

[data-theme="light"] pre > code[class*="language-"] {
	font-size: 1em;
}

[data-theme="light"] pre[class*="language-"]::-moz-selection,
[data-theme="light"] pre[class*="language-"] ::-moz-selection,
[data-theme="light"] code[class*="language-"]::-moz-selection,
[data-theme="light"] code[class*="language-"] ::-moz-selection {
	text-shadow: none;
	background: #dfe2f1;
}

[data-theme="light"] pre[class*="language-"]::selection,
[data-theme="light"] pre[class*="language-"] ::selection,
[data-theme="light"] code[class*="language-"]::selection,
[data-theme="light"] code[class*="language-"] ::selection {
	text-shadow: none;
	background: #dfe2f1;
}

/* Code blocks */
[data-theme="light"] pre[class*="language-"] {
    margin: 0.5em 0;
    padding: 1.25em 1em;
	overflow: auto;
}

/* Inline code */
[data-theme="light"] :not(pre) > code[class*="language-"] {
	padding: .1em;
	border-radius: .3em;
}

[data-theme="light"] .token.comment,
[data-theme="light"] .token.prolog,
[data-theme="light"] .token.doctype,
[data-theme="light"] .token.cdata {
	color: #898ea4;
}

[data-theme="light"] .token.punctuation {
	color: #012dde;
}

[data-theme="light"] .token.namespace {
	opacity: .7;
}

[data-theme="light"] .token.boolean,
[data-theme="light"] .token.operator,
[data-theme="light"] .token.number {
	color: #c76b29;
}

[data-theme="light"] .token.builtin {
	color: #a39c3f;
}
[data-theme="light"] .token.property {
	color: #8f5d08;
}

[data-theme="light"] .token.tag {
	color: #3d8fd1;
}

[data-theme="light"] .token.string {
	color: #28985a;
}

[data-theme="light"] .token.selector {
	color: #6679cc;
}

[data-theme="light"] .token.attr-name {
	color: #c76b29;
}

[data-theme="light"] .token.entity,
[data-theme="light"] .token.url,
[data-theme="light"] .language-css .token.string,
[data-theme="light"] .style .token.string {
	color: #22a2c9;
}

[data-theme="light"] .language-javascript {
	color: #c91db8;
}

[data-theme="light"] .token.attr-value,
[data-theme="light"] .token.control,
[data-theme="light"] .token.directive,
[data-theme="light"] .token.unit {
	color: #ac9739;
}

[data-theme="light


/*
    SPDX-FileCopyrightText: 2019 Kai Uwe Broulik <kde@privat.broulik.de>

    SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
*/

#pragma once

#include "notificationmanager_export.h"

#include <QObject>
#include <QString>
#include <memory>

#include <qqmlregistration.h>

namespace NotificationManager
{
/**
 * @short Information about the notification server
 *
 * Provides information such as vendor, name, version of the notification server.
 *
 * @author Kai Uwe Broulik <kde@privat.broulik.de>
 **/
class NOTIFICATIONMANAGER_EXPORT ServerInfo : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_UNCREATABLE("Can only access ServerInfo via Server")

    Q_PROPERTY(Status status READ status NOTIFY statusChanged)

    Q_PROPERTY(QString vendor READ vendor NOTIFY vendorChanged)

    Q_PROPERTY(QString name READ name NOTIFY nameChanged)

    Q_PROPERTY(QString version READ version NOTIFY versionChanged)

    Q_PROPERTY(QString specVersion READ specVersion NOTIFY specVersionChanged)

public:
    explicit ServerInfo(QObject *parent = nullptr);
    ~ServerInfo() override;

    enum class Status {
        Unknown = -1,
        NotRunning,
        Running,
    };
    Q_ENUM(Status)

    Status status() const;
    QString vendor() const;
    QString name() const;
    QString version() const;
    QString specVersion() const;

Q_SIGNALS:
    void statusChanged(Status status);
    void vendorChanged(const QString &vendor);
    void nameChanged(const QString &name);
    void versionChanged(const QString &version);
    void specVersionChanged(const QString &specVersion);

private:
    class Private;
    std::unique_ptr<Private> d;
};

} // namespace NotificationManager


.0,
//            width: 21.0,
//            child: new CircleAvatar(
//              backgroundColor: Colors.white,
//            ),
//          ),
//        ),
//      ),
      new Positioned(
        top: -5.0,
        right: -5.0,
        child: new Offstage(
          offstage: true,
          child: new SizedBox(
            height: 21.0,
            width: 21.0,
            child: new CircleAvatar(
              backgroundColor: Colors.red,
              child: new Text(
                '2',
                style: new TextStyle(fontSize: 12.0),
              ),
            ),
          ),
        ),
      ),
//      new Offstage(
//        offstage: ,
//      )
    ]..addAll(<Widget>[
        new Positioned(
          top: -5.0,
          right: -5.0,
          child: new Offstage(
            offstage: !inSelect,
            child: new SizedBox(
              height: 21.0,
              width: 21.0,
              child: new Container(
                padding: EdgeInsets.zero,
                margin: const EdgeInsets.only(bottom: 1.0),
                decoration: new BoxDecoration(
                    color: Colors.white,
                    shape: BoxShape.circle,
                    border: new Border.all(color: Colors.red, width: 1.0)),
              ),
            ),
          ),
        ),
        new Positioned(
          top: -7.0,
          right: -4.0,
          child: new Offstage(
            offstage: !inSelect || !checkSelected(),
            child: new SizedBox(
              height: 21.0,
              width: 21.0,
              child: new Container(
                decoration: new BoxDecoration(
                    color: Colors.white, shape: BoxShape.circle),
                child: new Icon(
                  Icons.check_circle,
                  color: Colors.red,
                  size: 24.0,
                ),
              ),
            ),
          ),
        ),
      ]);
  }

  @override
  Widget build(BuildContext context) {
    return new GestureDetector(
      onTap: () => onTap(book),
      onLongPress: () => onLongPress(book),
      child: new Container(
        child: new Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: <Widget>[
            new Flexible(
              child: new Stack(
                children: buildCover(context),
                overflow: Overflow.visible,
              ),
            ),
            new Container(
              height: showReadProgress ? 68.0 : 48.0,
              child: new Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: <Widget>[
                  new Container(
                    margin: const EdgeInsets.only(top: 8.0),
                    child: new Text(
                      book.title,
                      maxLines: 2,
                      textAlign: TextAlign.start,
                      overflow: TextOverflow.ellipsis,
                    ),
                  ),
                  new Offstage(
                      offstage: !showReadProgress,
                      child: new Text(
                        '已阅读3%',
                        style: Theme
                            .of(context)
                            .textTheme
                            .body2
                            .copyWith(color: Colors.grey),
                      )),
                ],
              ),
            )
          ],
        ),
      ),
    );
  }
}
// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'package:flutter/foundation.dart';
import 'package:flutter/ma


ipSprite.PersonalVehicleCar
        blip.Name = location.name
        blip.Color = Cfx.BlipColor.Green
        blip.ShowRoute = true
        this.currentBlip = blip

        let playerIsClose = false

        while (!playerIsClose) {
            await Delay(1)
            const playerPos = Cfx.Game.PlayerPed.Position
            if (Vdist2(playerPos.x, playerPos.y, 0, location.x, location.y, 0) < 30){
                playerIsClose = true
            }
        }
    }

    async startDelivery(pickup: LocationData, dropoff: LocationData, type: DeliveryType): Promise<void> {
        const thisDelivery = {pickup: pickup, dropoff: dropoff, type: type } as DeliveryData
        if (_.isEqual(this.currentDelivery, thisDelivery )) {
            this.core.notify('This job has already been started!')
            return null
        } else {
            if (this.currentBlip) { this.currentBlip.delete() }
        }

        this.currentDelivery = thisDelivery
        await this.goTo(pickup)
        this.core.notify('Delivery items picked up! Proceed to dropoff desintation to complete delivery.')
        this.currentBlip.delete()

        await this.goTo(dropoff)
        this.core.notify('Delivery complete!')
        this.currentBlip.delete()
        const dist = Vdist2(dropoff.x, dropoff.y, 0, pickup.x, pickup.y, 0)
        emitNet('GTAPlusServer:updateMoney', dist / 20_000)
    }
}import {Component, Input, OnChanges, SimpleChange, OnInit} from "angular2/core";
import {Observable} from "rxjs/Observable";

export enum TimerEvent {
  START,
  STOP,
  RESET
}

@Component({
  selector: 'timer',
  template: `

{{ time }}

  <progress
    class="timer__progress"
    [max]="seconds"
    [value]="accurateSeconds"
  ></progress>

`
})
export class TimerComponent implements OnChanges, OnInit {
  public time: string;
  public accurateSeconds: number;
  public isOverTime: boolean;
  public total: number;

  @Input()
  public seconds: number;

  @Input()
  public control: Observable<TimerEvent>;

  @Input()
  public large: any;
  public isLarge: boolean;

  private isRunning: boolean;
  private startTime: number;
  private doStep: (timestamp: number) => void;

  constructor() {
    this.doStep = this.step.bind(this);
  }

  ngOnInit() {
    this.setIsLarge();
    this.control.subscribe((event: TimerEvent) => {
      switch (event) {
        case TimerEvent.START:
          this.toggle(true);
          break;
        case TimerEvent.STOP:
          this.toggle(false);
          break;
        case TimerEvent.RESET:
          this.reset();
          break;
      }
    });
  }

  ngOnChanges(changes: {[key: string]: SimpleChange}): void {
    if (changes['seconds']) {
      this.reset();
    }
    if (changes['large']) {
      this.setIsLarge();
    }
  }

  private setIsLarge(){
    if (typeof this.large === 'undefined') {
      this.isLarge = false;
    } else if (typeof this.large === 'boolean') {
      this.isLarge = !!this.large;
    } else {
      this.isLarge = true;
    }
  }

  privat


<TITLE>Aiuto Nuovi NewsGroup</TITLE>

Aiuto Nuovi NewsGroup

La finestra Nuovi NewsGroup mostra l'elenco dei Gruppi creati dopo una
certa data ed orario. La data e l'orario sono inseriti dall'utente in un
dialogo. Questo elenco può essere richiamato e qualsiasi Gruppo può
essere selezionato ed iscritto. Quando viene effettuata l'iscrizione, il
nome del gruppo e' inserito nella finestra dei NewsGroup Iscritti, ed
e' immediatamente disponibile all'uso. Un doppio click con il tasto
sinistro del mouse, o selezionare Iscrivi dal menu' 'Speciale' esegue
la funzione di Iscrizione.

Se disponete di sufficiente memoria, verra' eseguito un riordino. Questo
rimuovera' anche le informazioni estranee dal file NEWGRP.TXT (perciò
riducendone le dimensioni) e creera' un file NEWGRP.IDX che verra' usato
per ridurre il tempo richiesto a scorrere il file.

  Uso del Mouse:

Un click Singolo seleziona (evidenzia) il nome su cui si trova il mouse.

Un doppio click richiama il dialogo Iscrivi, per iscrivere il Gruppo
scelto nella finestra corrente dei gruppi iscritti.

I Controlli e la barra scorrimento della finestra sono standard.

Uso dei tasti:

Le freccie su/giu' muovono su/giu' di una linea.

Shift+freccie su/giu' scrollano di una pagina.

Il tasto 's' richiama il dialogo 'Ricerca' per cercare nell'elenco il successivo
Gruppo corrispondente. (non e' disponibile lo scorrimento).

Il tasto 'm' richiama il dialogo 'Corrisponde' per mostrare tutti i Gruppi
corrispondenti al tasto (non e' disponibile lo scorrimento).

<title> Ayuda del servidor de FTP </title>

Servidor de FTP

El propósito de esta ventana es la de permitir la
selección de un servidor de FTP para establecer una
conexión, la edición o el borrado del mismo. Adicionalmente,
se puede realizar la inserción de un nuevo servidor.

Uso con el ratón:

Una doble pulsación del botón del ratón se abre
una conexión con el servidor FTP seleccionado.

Una sola pulsación se selecciona el servidor (queda indicado con
otro color).

Las funciones normales de las v


125, 0.5);
    border: 6px solid rgba(0, 0, 0, 0);
    background-clip: content-box;
  }
  .euiResizablePanel__content--scrollable::-webkit-scrollbar-corner,
  .euiResizablePanel__content--scrollable::-webkit-scrollbar-track {
    background-color: rgba(0, 0, 0, 0);
  }
  .euiResizablePanel-isCollapsed {
    overflow: hidden;
  }
  .euiResizablePanel-isCollapsed .euiResizablePanel__content * {
    display: none;
  }
  .euiResizableContainer--horizontal .euiResizablePanel-isCollapsed {
    min-width: 0 !important;
  }
  .euiResizableContainer--horizontal
    .euiResizablePanel--collapsible.euiResizablePanel-isCollapsed {
    min-width: 24px !important;
  }
  .euiResizableContainer--vertical .euiResizablePanel-isCollapsed {
    min-height: 0 !important;
  }
  .euiResizableContainer--vertical
    .euiResizablePanel--collapsible.euiResizablePanel-isCollapsed {
    min-height: 24px !important;
  }
  .euiSideNav__mobileToggle {
    height: auto;
    border-bottom: 1px solid #d3dae6;
    width: 100%;
    text-align: left;
    border-radius: 0 !important;
    font-size: 18px;
    padding: 0 16px;
  }
  .euiSideNav__mobileToggle .euiSideNav__mobileToggleText {
    padding: 16px 0;
  }
  .euiSideNav__mobileToggle .euiSideNav__mobileToggleContent {
    justify-content: space-between;
  }
  .euiSideNav__heading {
    margin-bottom: 24px;
  }
  @media only screen and (max-width: 574px) {
    .euiSideNav__contentMobile-xs {
      overflow: hidden;
      visibility: hidden;
      opacity: 0;
      max-height: 0;
      padding: 0 24px;
    }
    .euiSideNav-isOpenMobile .euiSideNav__contentMobile-xs {
      visibility: visible;
      opacity: 1;
      padding: 24px;
      max-height: 5000px;
    }
  }
  @media only screen and (max-width: 574px) and (prefers-reduced-motion: no-preference) {
    .euiSideNav-isOpenMobile .euiSideNav__contentMobile-xs {
      transition: all 250ms cubic-bezier(0.694, 0.0482, 0.335, 1);
    }
  }
  @media only screen and (min-width: 575px) and (max-width: 767px) {
    .euiSideNav__contentMobile-s {
      overflow: hidden;
      visibility: hidden;
      opacity: 0;
      max-height: 0;
      padding: 0 24px;
    }
    .euiSideNav-isOpenMobile .euiSideNav__contentMobile-s {
      visibility: visible;
      opacity: 1;
      padding: 24px;
      max-height: 5000px;
    }
  }
  @media only screen and (min-width: 575px) and (max-width: 767px) and (prefers-reduced-motion: no-preference) {
    .euiSideNav-isOpenMobile .euiSideNav__contentMobile-s {
      transition: all 250ms cubic-bezier(0.694, 0.0482, 0.335, 1);
    }
  }
  @media only screen and (min-width: 768px) and (max-width: 991px) {
    .euiSideNav__contentMobile-m {
      overflow: hidden;
      visibility: hidden;
      opacity: 0;
      max-height: 0;
      padding: 0 24px;
    }
    .euiSideNav-isOpenMobile .euiSideNav__contentMobile-m {
      visibility: visible;
      opacity: 1;
      padding: 24px;
      max-height: 5000px;


tent is set to the ViewportHeight of the ScrollViewer.
        /// </summary>
        Disabled = 0,

        /// <summary>
        /// A ScrollBar appears and the dimension of the ScrollViewer is applied to the
        /// content when the viewport cannot display all of the content. For a horizontal
        /// ScrollBar, the width of the content is set to the ViewportWidth of the ScrollViewer.
        /// For a vertical ScrollBar, the height of the content is set to the ViewportHeight
        /// of the ScrollViewer.
        /// </summary>
        Auto = 1,

        /// <summary>
        /// A ScrollBar does not appear even when the viewport cannot display all of
        /// the content. The dimension of the ScrollViewer is not applied to the content.
        /// </summary>
        Hidden = 2,

        /// <summary>
        /// A ScrollBar always appears. The dimension of the ScrollViewer is applied
        /// to the content. For a horizontal ScrollBar, the width of the content is set
        /// to the ViewportWidth of the ScrollViewer. For a vertical ScrollBar, the height
        /// of the content is set to the ViewportHeight of the ScrollViewer.
        /// </summary>
        Visible = 3,
    }
}


@click.option(
    "--min-orgs", type=int, help="Minimum organizations for global aggregation"
)
@click.option("--min-silos", type=int, help="Minimum silos per organization")
@click.option("--min-participants", type=int, help="Minimum participants per silo")
@click.option("--max-rounds", type=int, help="Maximum federation rounds")
@click.option("--convergence-threshold", type=float, help="Convergence threshold")
def update(
    min_orgs: Optional[int],
    min_silos: Optional[int],
    min_participants: Optional[int],
    max_rounds: Optional[int],
    convergence_threshold: Optional[float],
):
    """Update configuration"""
    if min_orgs is not None:
        cli.coordinator.config.min_organizations = min_orgs
    if min_silos is not None:
        cli.coordinator.config.min_silos_per_org = min_silos
    if min_participants is not None:
        cli.coordinator.config.min_participants_per_silo = min_participants
    if max_rounds is not None:
        cli.coordinator.config.max_rounds = max_rounds
    if convergence_threshold is not None:
        cli.coordinator.config.convergence_threshold = convergence_threshold

    cli.save_config()
    console.print("[green]Configuration updated successfully[/green]")

if __name__ == "__main__":
    main()


ible: {e}')
            traceback.print_exc()
            return

        try:
            merged_df = merge_dataframes(visits_df, ground_truth_df, suffixes=suffixes)
        except Exception as e:
            logging.critical(f'Error merging dataframes. Benchmarking not possible: {e}')
            traceback.print_exc()
            return

        try:
            all_results = calculate_metrics(merged_df, min_detections=min_detections, column='visit_ids', suffixes=suffixes)
            rel_results = calculate_metrics(merged_df, min_detections=min_detections, column='relevant_visit_ids', suffixes=suffixes)
        except Exception as e:
            logging.critical(f'Error calculating metrics. Benchmarking failed: {e}')
            traceback.print_exc()
            return None, None

        try:
            plot_coverage(merged_df, frame_gap, output_dir, column='visit_ids', suffixes=suffixes)
            plot_coverage(merged_df, frame_gap, output_dir, column='relevant_visit_ids', suffixes=suffixes)
        except Exception as e:
            logging.error(f"Error comparing visits to ground truth: {e}")
            traceback.print_exc()

        return all_results, rel_results