), ANY.Wood, U*8);
		OM.data(ST.make(BlocksGT.BeamB         , 1, W), ANY.Wood, U*8);
		OM.data(ST.make(BlocksGT.BeamBFireProof, 1, W), ANY.Wood, U*8);
		OM.data(ST.make(BlocksGT.BeamC         , 1, W), ANY.Wood, U*8);
		OM.data(ST.make(BlocksGT.BeamCFireProof, 1, W), ANY.Wood, U*8);
		OM.data(ST.make(BlocksGT.BeamD         , 1, W), ANY.Wood, U*8);
		OM.data(ST.make(BlocksGT.BeamDFireProof, 1, W), ANY.Wood, U*8);
	}
}
/**
 * Copyright (c) 2021 GregTech-6 Team
 *
 * This file is part of GregTech.
 *
 * GregTech 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 3 of the License, or
 * (at your option) any later version.
 *
 * GregTech 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 GregTech. If not, see <http://www.gnu.org/licenses/>.
 */

package gregtech.loaders.a;

import static gregapi.data.CS.*;

import gregapi.block.MaterialMachines;
import gregapi.block.MaterialScoopable;
import gregapi.block.multitileentity.MultiTileEntityBlock;
import gregapi.block.multitileentity.MultiTileEntityRegistry;
import gregapi.data.CS.BooksGT;
import gregapi.data.CS.Sandwiches;
import gregapi.data.MD;
import gregapi.render.BlockTextureDefault;
import gregapi.render.IconContainerCopied;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.init.Blocks;

public class Loader_Others implements Runnable {
	@Override
	public void run() {
		new MultiTileEntityRegistry("gt.multitileentity");

		MultiTileEntityBlock.getOrCreate(MD.GT.mID, "iron"          , Material.iron                 , Block.soundTypeMetal  , TOOL_pickaxe      , 0, 0, 15, F, F);
		MultiTileEntityBlock.getOrCreate(MD.GT.mID, "iron"          , Material.iron                 , Block.soundTypeMetal  , TOOL_shovel       , 0, 0, 15, F, F);
		MultiTileEntityBlock.getOrCreate(MD.GT.mID, "machine"       , MaterialMachines.instance     , Block.soundTypeMetal  , TOOL_cutter       , 0, 0, 15, F, F);
		MultiTileEntityBlock.getOrCreate(MD.GT.mID, "machine"       , MaterialMachines.instance     , Block.soundTypeMetal  , TOOL_wrench       , 0, 0, 15, F, F);
		MultiTileEntityBlock.getOrCreate(MD.GT.mID, "wood"          , Material.wood                 , Block.soundTypeWood   , TOOL_axe          , 0, 0, 15, F, F);
		MultiTileEntityBlock.getOrCreate(MD.GT.mID, "leaves"        , Material.leaves               , Block.soundTypeGrass  , TOOL_axe          , 0, 0, 15, F, F);
		MultiTileEntityBlock.getOrCreate(MD.GT.mID, "rock"          , Material.rock


ロード3 群衆の正義 | NHK | 日语 |  |  | A
地狱男爵动画版：风暴之剑 | 电影 | 动作/战争/剧情/科幻/冒险/动画 | 6.0 | 2007-02-06 周二 | Hellboy Animated: Sword of Storms |  | 英语 |  | 8450.0 | A
我的表兄维尼 | 电影 | 喜剧 | 6.0 | 1992-08-07 周五 | My Cousin Vinny |  | 英语 |  | 8491.0 | A
续写哈姆雷特 | 电影 | 喜剧 | 6.0 | 2008-01-01 周二 | Hamlet 2 |  | 英语 |  | 8617.0 | A
五口之家 | 美剧 | 剧情 | 5.9 | 2020-01-09 周四 | Party of Five | FREEFORM | 英语 |  |  | A
生死竞赛 | 电影 | 动作/剧情 | 5.9 | 2018-06-15 | 3 Race 3 |  | 印度语 |  | 8843.0 | A
我的开心果 | 电影 | 青春/爱情/童话/幻想 | 5.9 | 2019-03-14 周四 |  MY PISTCAHIO |  | 韩语 |  | 8846.0 | A
怒海仁心 | 电影 | 剧情 | 5.9 | 2018-02-16 | Styx |  | 德语 |  | 8854.0 | A
少年追梦情 | 电影 | 剧情 | 5.9 | 2018-09-07 | Teen Spirit |  | 英语 |  | 8838.0 | A
王者少年 | 电影 | 冒险 | 5.9 | 2019-01-25 | The Kid Who Would Be King |  | 英语 |  | 8829.0 | A
十二宫骑士：圣斗士星矢 | 日剧 | 动画 | 5.9 | 2019-07-19 周五 | Knights of the Zodiac: Saint Seiya | Netflix | 日语 |  |  | A
梦想食堂的料理人～1964东京奥运会选手村的故事～ | 日剧 | 剧情 | 5.9 | 2019-07-23 周二 | Yume Shokudou no Ryourinin 1964 Tokyo Olympic Senshumura Monogatari | NHK | 日语 |  |  | A
哈德森与雷克斯 | 加剧 | 剧情/悬疑 | 5.9 | 2019-02-07 周四 | Hudson.and.Rex | CBS | 英语 |  |  | A
明天你十八岁 | 越剧 | 喜剧/生活/爱情/童话 | 5.8 | 2018-11-28 周三 | Ngày Mai Anh 18 | 其他 | 其他 |  |  | A
高校Rapper | 韩剧 | 真人秀 | 5.8 | 2019-01-22 | 第三季 고등래퍼3 | 其他 | 韩语 |  |  | A
猎分男孩 | 泰剧 | 偶像/真人秀/综艺 | 5.8 | 2019-01-24 周四 | หนุ่มล่าเเต้ม | 其他 | 泰语 |


te, "send", playerid, {"kick","顶替下线"})
		s.call(pnode, pgate, "kick", playerid)
	end
	--上线
	local player = mgrplayer()
	player.playerid = playerid
	player.node = node
	player.gate = gate
    player.agent = nil
	player.status = STATUS.LOGIN
	players[playerid] = player
	local agent = s.call(node, "nodemgr", "newservice", "agent", "agent", playerid)
	player.agent = agent
	player.status = STATUS.GAME
	return true, agent
end

s.resp.reqkick = function(source, playerid, reason)
	local mplayer = players[playerid]
	if not mplayer then
		return false
	end

	if mplayer.status ~= STATUS.GAME then
		return false
	end

	local pnode = mplayer.node
	local pagent = mplayer.agent
	local pgate = mplayer.gate
	mplayer.status = STATUS.LOGOUT

	s.call(pnode, pagent, "kick")
	s.send(pnode, pagent, "exit")
	s.send(pnode, pgate, "kick", playerid)
	players[playerid] = nil

	return true
end

--情况 永不下线

s.start(...)


Builder {
        crate::input::untag_resource_input::Builder::default()
    }
    /// Creates a new `UntagResource` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UntagResource {
    type Output =
        std::result::Result<crate::output::UntagResourceOutput, crate::error::UntagResourceError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_untag_resource_error(response)
        } else {
            crate::operation_deser::parse_untag_resource_response(response)
        }
    }
}
use std::sync::Arc;
use std::time::Duration;

use anyhow::{Context, Result};
use futures::StreamExt;
use signal_hook::consts::TERM_SIGNALS;
use sqlx::postgres::PgPool;
use svc_agent::{
    mqtt::{Agent, AgentBuilder, AgentNotification, ConnectionMode, IncomingMessage, QoS},
    request::Dispatcher,
    AgentId, Authenticable, SharedGroup, Subscription,
};
use svc_authn::token::jws_compact;
use svc_authz::cache::AuthzCache;
use svc_authz::ClientMap as Authz;
use svc_error::{extension::sentry, Error as SvcError};
use tracing::{error, info};

use crate::clients::event::{EventClient, TowerClient};
use crate::clients::tq::{HttpTqClient, TqClient};
use crate::config::{self, Config};
use crate::{
    app::metrics::MqttMetrics,
    clients::conference::{ConferenceClient, MqttConferenceClient},
};
pub use authz::AuthzObject;
use tide_state::message_handler::MessageHandler;
pub use tide_state::{AppContext, Publisher, TideState};

pub const API_VERSION: &str = "v1";

pub async fn run(db: PgPool, authz_cache: Option<Box<dyn AuthzCache>>) -> Result<()> {
    let config = config::load().context("Failed to load config")?;
    info!("App config: {:?}", config);

    let agent_id = AgentId::new(&config.agent_label, config.id.clone());
    info!("Agent id: {:?}", &agent_id);

    let token = jws_compact::TokenBuilder::new()
        .issuer(&agent_id.as_account_id().audience().to_string())
        .subject(&agent_id)
        .key(config.id_token.algorithm, config.id_token.key.as_slice())
        .build()
        .context("Error creating an id token")?;

    let mut agent_config = config.mqtt.clone();
    agent_config.set_password(&token);

    let (mut agent, mut rx) = AgentBuilder::new(agent_id.clone(), API_VERSION)
        .connection_mode(ConnectionMode::Service)
        .start(&agent_config)
        .context("Failed to create an agent")?;

    let dispatcher = Arc::new(Dispatcher::new(&agent));
    let event_client = build_event_client(&config, dispatcher.clone());
    let conference_client = build_conference_client(&config, dispatcher.clone());
    let tq_client = build_tq_client(&config, &token);
    let authz = Authz::new(&config.id, authz_cache, config.authz.clone(), None)
        .context("Error converting authz config to clients")?;

    let state = TideState::new(
        db,
        config.clone(),
        event_client,
        conference_client,
        tq_client,
        agent.clone(),
        authz,
    );
    let state = Arc::new(state) as Arc<dyn AppContext>;
    let state_ = state.clone();

    let message_handler = Arc::new(MessageHandler::new(state_, dispatcher));
    tokio::


-- chunkname: @scripts/managers/account/xbox_privileges.lua

local PrivilegesManagerConstants = require("scripts/managers/privileges/privileges_manager_constants")
local FGRLLimits = require("scripts/foundation/utilities/fgrl_limits")

XboxPrivileges = class("XboxPrivileges")

local DEFAULT_PRIVILEGES = DEFAULT_PRIVILEGES or {}
local ATTEMPT_RESOLUTION_PRIVILEGES = ATTEMPT_RESOLUTION_PRIVILEGES or {}
local XBOX_PRIVILEGE_LUT = XBOX_PRIVILEGE_LUT or {}
local XBOX_PERMISSION_LUT = XBOX_PERMISSION_LUT or {}
local ANONYMOUSE_USER_TYPES_LUT = ANONYMOUSE_USER_TYPES_LUT or {}
local DEFAULT_PERMISSIONS = DEFAULT_PERMISSIONS or {}
local DEFAULT_ANONYMOUS_USER_TYPES = DEFAULT_ANONYMOUS_USER_TYPES or {}
local XBOX_PERMISSION_DENY_REASON_LUT = XBOX_PERMISSION_DENY_REASON_LUT or {}
local BATCH_WAIT_TIMES = {
	CHAT_HUB = 10,
	CHAT_MISSION = 0,
	CHAT_PARTY = 0,
}
local BATCH_SEND_DELAY = 3

local function debug_log(...)
	return
end

XboxPrivileges.init = function (self)
	self:reset()
end

XboxPrivileges.reset = function (self)
	self._initialized = false
	self._has_error = nil
	self._privileges_data = {}
	self._async_privileges = {}
	self._crossplay_restrictions = {}
	self._user_restrictions = {}
	self._batched_user_restrictions = {}
	self._batch_wait_timer = {}
	self._batch_send_timer = {}
end

XboxPrivileges.verify_user_restriction_batched = function (self, xuid, restriction, batch_type)
	if Managers.account:user_detached() then
		return
	end

	local user_data = self._user_restrictions[xuid]

	if user_data and user_data[restriction] ~= nil then
		return
	end

	local batch = self._batched_user_restrictions[batch_type]

	if not batch then
		batch = {
			restrictions = {},
			xuids = {},
		}
		self._batched_user_restrictions[batch_type] = batch
	end

	batch.restrictions[restriction] = true
	batch.xuids[xuid] = true
end

XboxPrivileges._update_batched_user_restrictions = function (self, dt, t)
	local batches = self._batched_user_restrictions

	if table.is_empty(batches) then
		return
	end

	for batch_type, data in pairs(batches) do
		local wait_timer = self._batch_wait_timer[batch_type] or 0
		local send_timer = self._batch_send_timer[batch_type] or nil

		if wait_timer <= t and not send_timer then
			self._batch_wait_timer[batch_type] = t + BATCH_WAIT_TIMES[batch_type]
			self._batch_send_timer[batch_type] = t + BATCH_SEND_DELAY
		elseif send_timer and send_timer <= t then
			self:_send_batched_user_restrictions(batch_type, t)
		end
	end
end

XboxPrivileges._send_batched_user_restrictions = function (self, batch_type, t)
	local batch = self._batched_user_restrictions[batch_type]
	local xuids = table.keys(batch.xuids)
	local restrictions = table.keys(batch.restrictions)

	self._batched_user_restrictions[batch_type] = nil
	self._batch_send_timer[batch_type] = nil

	if Managers.account:user_detached() then
		return
	end

	Log.info("XboxP


estamps(source,toCompare,operator);}
else{ans=(source>toCompare);}
break;case KAMPYLE_CONSTANT.OPERATORS.SMALLER_THAN:ans=(source<toCompare);break;case KAMPYLE_CONSTANT.OPERATORS.EARLIER_THAN:if(varType==='datetime')
{ans=KAMPYLE_UTILS.kampyleCompareTimestamps(source,toCompare,operator);}
else{ans=(source>toCompare);}
break;case KAMPYLE_CONSTANT.OPERATORS.CONTAINS:ans=(!!source&&source.indexOf&&source.indexOf(toCompare)!==-1);break;case KAMPYLE_CONSTANT.OPERATORS.DOES_NOT_CONTAIN:ans=(!!source&&source.indexOf&&source.indexOf(toCompare)===-1);break;case KAMPYLE_CONSTANT.OPERATORS.STARTS_WITH:ans=(!!source&&source.indexOf&&source.indexOf(toCompare)===0);break;case KAMPYLE_CONSTANT.OPERATORS.ENDS_WITH:ans=(!!source&&source.indexOf&&source.length&&source.indexOf(toCompare,source.length-source.length)!==-1);break;case KAMPYLE_CONSTANT.OPERATORS.HAS_VALUE:ans=(!!source||source===''||source===false||source===0);break;case KAMPYLE_CONSTANT.OPERATORS.REGEX:try{var regex=new RegExp(toCompare);ans=(!!source&&regex.exec(source)!==null);}catch(e){ans=false;}
break;default:break;}
return ans;},setNestedPropertyValue:function(obj,propString,value){var schema=obj;var pList=propString.split('.');var len=pList.length;for(var i=0;i<len-1;i++){var elem=pList[i];if(!schema[elem]){schema[elem]={};}
schema=schema[elem];}
schema[pList[len-1]]=value;},getNestedPropertyValue:function(obj,propString,fallback){if(!obj||!propString||typeof propString!=='string'){return null;}
var propNameDotPlaceholder='#DOT#';var props=propString.split('.');var tmpObj=obj;var len=props.length;for(var i=0;i<len;i++){var currProp=props[i].split(propNameDotPlaceholder).join('.');if(!!tmpObj&&(tmpObj.hasOwnProperty(currProp)||tmpObj[currProp])){tmpObj=tmpObj[currProp];}else{return typeof fallback==="undefined"?null:fallback;}}
return tmpObj;},validateKampyleDomain:function(url){var urlRegex=/(^https?:\/\/[A-Za-z0-9\-]+\.kampyle\.com(\/[A-Za-z0-9\-\._~:\/\?#\[\]@!$&'\(\)\*\+,;\=]*)?)/;var result=urlRegex.test(url);if(!result){console.warn('Invalid url in validateKampyleDomain: '+url);}
return result;},camelToDash:function(str){if(typeof str!=='string'){return str;}
else{return str.replace(/\W+/g,'-').replace(/([a-z\d])([A-Z])/g,'$1-$2').toLowerCase();}},objectPropertyObserver:function(obj,pathToProperty,callback){var MAX_TIMEOUT_RUNS=100;var timeoutMs=100;var runsCounter=0;function timoutCallback(){var propertyValue=KAMPYLE_UTILS.getNestedPropertyValue(obj,pathToProperty);if(!!propertyValue&&callback instanceof Function){return callback(propertyValue);}
if(runsCounter++<MAX_TIMEOUT_RUNS){window.setTimeout(timoutCallback,timeoutMs);}}
window.setTimeout(timoutCallback,timeoutMs);},showInvite:function(){var inviteIframe=document.getElementById('kampyleInvite');KAMPYLE_UTILS.setElement


1", "00"
  ///   ).unwrap()))).unwrap()))),
  ///   Value::datetime_full_from_int(2010, 4, 10, 1, 2, 3, 135, '-', 11, 0).unwrap());
  /// ```
  pub fn datetime_full_from_int(year: usize, month: usize, day: usize, hour: usize, minute: usize, second: usize, frac: u64, posneg: char, off_hour: usize, off_minute: usize) -> Result<Value<'a>, TOMLError> {
    let y = format!("{:0>4}", year);
    let m = format!("{:0>2}", month);
    let d = format!("{:0>2}", day);
    let h = format!("{:0>2}", hour);
    let min = format!("{:0>2}", minute);
    let s = format!("{:0>2}", second);
    let f = format!("{}", frac);
    let oh = format!("{:0>2}", off_hour);
    let omin = format!("{:0>2}", off_minute);
    let mut pn = "".to_string();
    pn.push(posneg);
    match Date::from_str(y, m, d) {
      Ok(date) => {
        match TimeOffsetAmount::from_str(pn, oh, omin) {
          Ok(offset) => {
            match Time::from_str(h, min, s, Some(f), Some(TimeOffset::Time(offset))) {
              Ok(time) => Ok(Value::DateTime(DateTime::new(date, Some(time)))),
              Err(error) => Err(error),
            }
          },
          Err(error) => Err(error),
        }
      },
      Err(error) => Err(error),
    }
  }

  /// Convenience function for creating a `Value::DateTime` containing a date and time with fractional seconds and a
  /// timezone offset from UTC from string values. Returns `Ok(DateTime)` on success and `Err(TOMLError)` on failure.
  ///
  /// # Examples
  ///
  /// ```
  /// use tomllib::types::{Value, DateTime, Date, Time, TimeOffset, TimeOffsetAmount};
  ///
  /// assert_eq!(Value::DateTime(DateTime::new(Date::from_str("2011", "05", "11").unwrap(),
  ///   Some(Time::from_str("02", "03", "04", Some("0864".into()), Some(TimeOffset::Time(TimeOffsetAmount::from_str(
  ///     "+", "09", "30"
  ///   ).unwrap()))).unwrap()))),
  ///   Value::datetime_full_from_str("2011", "05", "11", "02", "03", "04", "0864","+", "09", "30").unwrap());
  /// ```
  pub fn datetime_full_from_str<S>(year: S, month: S, day: S, hour: S, minute: S, second: S, frac: S, posneg: S, off_hour: S, off_minute: S) -> Result<Value<'a>, TOMLError> where S: Into<String> + Clone {
    match Date::from_str(year.clone().into(), month.clone().into(), day.clone().into()) {
      Ok(date) => {
        match TimeOffsetAmount::from_str(posneg.clone().into(), off_hour.clone().into(), off_minute.clone().into()) {
          Ok(offset) => {
            match  Time::from_str(hour.clone().into(), minute.clone().into(), second.clone().into(), Some(frac.clone().into()), Some(
                TimeOffset::Time(offset)
              )) {
              Ok(time) => Ok(Value::DateTime(DateTime::new(date, Some(time)))),
              Err(error) => Err(error),
            }
          },
          Err(error) => Err(error),
        }
      },
      Err(error) => Err(error),
    }
  }

  ///


Boolean(*b),
            serde_json::Value::Null => Val::Empty,
            serde_json::Value::Array(l) => {
                let mut vs = Vec::with_capacity(l.len());
                for aval in l {
                    vs.push(Rc::new(self.convert_json_val(aval)?));
                }
                Val::List(vs)
            }
            serde_json::Value::Object(m) => {
                let mut fs = Vec::with_capacity(m.len());
                for (key, value) in m {
                    fs.push((key.to_string(), Rc::new(self.convert_json_val(value)?)));
                }
                Val::Tuple(fs)
            }
        })
    }

    fn write(&self, v: &Val, w: &mut dyn Write) -> ConvertResult {
        let jsn_val = self.convert_value(v)?;
        serde_json::to_writer_pretty(w, &jsn_val)?;
        Ok(())
    }
}

impl Converter for JsonConverter {
    fn convert(&self, v: Rc<Val>, mut w: &mut dyn Write) -> ConvertResult {
        self.write(&v, &mut w)
    }

    fn file_ext(&self) -> String {
        String::from("json")
    }

    fn description(&self) -> String {
        "Convert ucg Vals into valid json.".to_string()
    }

    #[allow(unused_must_use)]
    fn help(&self) -> String {
        include_str!("json_help.txt").to_string()
    }
}

impl Importer for JsonConverter {
    fn import(&self, bytes: &[u8]) -> ImportResult {
        let json_val = serde_json::from_slice(bytes)?;
        Ok(Rc::new(self.convert_json_val(&json_val)?))
    }
}
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::thread;
use std::time::Duration;

use eframe::epaint::Rgba;
use egui::{ColorImage, Pos2, TextureHandle, Vec2, Visuals};
use image::codecs::gif::GifDecoder;
use image::AnimationDecoder;
use kira::manager::backend::DefaultBackend;
use kira::manager::AudioManagerSettings;
use kira::sound::static_sound::{StaticSoundData, StaticSoundSettings};

static GIF_DATA: &[u8] = include_bytes!("../cat.gif");

pub struct Vibin {
    pos: Pos2,
    images: Vec<(TextureHandle, u32)>,
    current: Arc<AtomicUsize>,
}

impl Vibin {
    pub fn new(cc: &eframe::CreationContext<'_>, images: Vec<(TextureHandle, u32)>) -> Self {
        cc.egui_ctx.set_visuals(Visuals::dark());

        let current = Arc::new(AtomicUsize::new(0));
        let size = images.len();

        // UI update thread
        // Change the gif frame to display
        let delay = images[0].1;
        let ctx_clone = cc.egui_ctx.clone();
        let curr_clone = current.clone();
        thread::spawn(move || {
            let mut manager =
                kira::manager::AudioManager::<DefaultBackend>::new(AudioManagerSettings::default())
                    .expect("Can't initialize audio context");

            let sound = StaticSoundData::from_file("test.mp3", StaticSoundSettings::default())
                .expect("Can't load sound file");
            manager.play(sound).expect("Can't play sound");

            loop {
                thread::sleep(Duration::from_micros(delay as u64));
                curr_clone
                    .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |c| {
                        Some((c + 1) % size)
                    })
                    .unwrap();
                ctx_clone.request_repaint


mbina",nil},
[27461] = {"Bambina",nil},
[27462] = {"Chasseur de la brigade de la marche de l'Ouest",nil},
[27463] = {"Tirailleur blessé",nil},
[27464] = {"Aumana",nil},
[27465] = {"Ame oubliée",nil},
[27466] = {"Kill Credit Bunny - Wounded Skirmishers",nil},
[27467] = {"Chasseur ambrepin",nil},
[27468] = {"Sergent Hartsman",nil},
[27469] = {"Ivan",nil},
[27470] = {"Grunt du bastion de la Conquête",nil},
[27471] = {"Crédit de quête du Fusilier oublié",nil},
[27472] = {"Crédit de quête du Paysan oublié",nil},
[27473] = {"Crédit de quête du Chevalier oublié",nil},
[27474] = {"Captain Luc D'Merud Quest Credit",nil},
[27475] = {"Soldat d'infanterie de la brigade de la marche de l'Ouest",nil},
[27476] = {"Capitaine Luc Valensort",nil},
[27477] = {"Caden Brasselorge","Club de la bière du mois"},
[27478] = {"Larkin Tonnebière","Club de la bière du mois"},
[27479] = {"Trappeur tué",nil},
[27480] = {"Muradin",nil},
[27481] = {"Cadavre de soldat d'infanterie de la marche de l'Ouest",nil},
[27482] = {"Soldat d'infanterie de la marche de l'Ouest blessé",nil},
[27483] = {"Roi Dred",nil},
[27484] = {"Rheanna",nil},
[27485] = {"Bambina vengeresse",nil},
[27486] = {"Sergei",nil},
[27487] = {"Club de la bière du mois","Vendeur de bière"},
[27488] = {"Lohger","Club de la bière du mois"},
[27489] = {"Ray'ma","Club de la bière du mois"},
[27490] = {"Chauve-souris drakkari cosmétique",nil},
[27491] = {"Trajet en griffon (Howling Fjord -> Dragonblight - DND)",nil},
[27492] = {"Emissaire de l'Alliance",nil},
[27493] = {"Sergent Bris'os",nil},
[27494] = {"Mystique Tomkin",nil},
[27495] = {"Barbillonneur",nil},
[27496] = {"Déchiqueteur remis à neuf",nil},
[27497] = {"Trappeuse capturée",nil},
[27499] = {"Prisonnier en cage",nil},
[27500] = {"Berserker du bastion de la Conquête",nil},
[27501] = {"Soldat de marine de la brigade de la marche de l'Ouest",nil},
[27504] = {"Chevaucheur de griffons du Norfendre",nil},
[27505] = {"Griffon d'élevage",nil},
[27506] = {"Ceristrasz",nil},
[27507] = {"Unu'pe Vision - Blue Dragon (DND)",nil},
[27508] = {"Nécro-seigneur Amarion",nil},
[27509] = {"Capitaine Brilleflot",nil},
[27510] = {"Ombre de Thel'zan le Portebrune",nil},
[27511] = {"Capitaine Zorna",nil},
[27512] = {"Unu'pe Vision - Tuskarr (DND)",nil},
[27513] = {"Geist avide",nil},
[27514] = {"Unu'pe Vision - Vrykul (DND)",nil},
[27515] = {"Unu'pe Vision - Gorloc (DND)",nil},
[27516] = {"Etal


sult_opr()->as_register();
  int divisor = -1;

  /*
  TODO: For some reason, using the Rscratch that gets passed in is
  not possible because the register allocator does not see the tmp reg
  as used, and assignes it the same register as Rdividend. We use rscratch1
   instead.

  assert(Rdividend != Rscratch, "");
  assert(Rdivisor  != Rscratch, "");
  */

  if (Rdivisor == noreg && is_power_of_2(divisor)) {
    // convert division by a power of two into some shifts and logical operations
  }

  if (op->code() == lir_irem) {
    __ corrected_idivl(Rresult, Rdividend, Rdivisor, true, rscratch1);
   } else if (op->code() == lir_idiv) {
    __ corrected_idivl(Rresult, Rdividend, Rdivisor, false, rscratch1);
  } else
    ShouldNotReachHere();
}

void LIR_Assembler::emit_opBranch(LIR_OpBranch* op) {
#ifdef ASSERT
  assert(op->block() == NULL || op->block()->label() == op->label(), "wrong label");
  if (op->block() != NULL)  _branch_target_blocks.append(op->block());
  if (op->ublock() != NULL) _branch_target_blocks.append(op->ublock());
#endif

  if (op->cond() == lir_cond_always) {
    if (op->info() != NULL) add_debug_info_for_branch(op->info());
    __ b(*(op->label()));
  } else {
    Assembler::Condition acond;
    if (op->code() == lir_cond_float_branch) {
      bool is_unordered = (op->ublock() == op->block());
      // Assembler::EQ does not permit unordered branches, so we add
      // another branch here.  Likewise, Assembler::NE does not permit
      // ordered branches.
      if ((is_unordered && op->cond() == lir_cond_equal)
          || (!is_unordered && op->cond() == lir_cond_notEqual))
        __ br(Assembler::VS, *(op->ublock()->label()));
      switch(op->cond()) {
      case lir_cond_equal:        acond = Assembler::EQ; break;
      case lir_cond_notEqual:     acond = Assembler::NE; break;
      case lir_cond_less:         acond = (is_unordered ? Assembler::LT : Assembler::LO); break;
      case lir_cond_lessEqual:    acond = (is_unordered ? Assembler::LE : Assembler::LS); break;
      case lir_cond_greaterEqual: acond = (is_unordered ? Assembler::HS : Assembler::GE); break;
      case lir_cond_greater:      acond = (is_unordered ? Assembler::HI : Assembler::GT); break;
      default:                    ShouldNotReachHere();
      }
    } else {
      switch (op->cond()) {
        case lir_cond_equal:        acond = Assembler::EQ; break;
        case lir_cond_notEqual:     acond = Assembler::NE; break;
        case lir_cond_less:         acond = Assembler::LT; break;
        case lir_cond_lessEqual:    acond = Assembler::LE; break;
        case lir_cond_greaterEqual: acond = Assembler::GE; break;
        case lir_cond_greater:      acond = Assembler::GT; break;
        case lir_cond_belowEqual:   acond = Assembler::LS; break;
        case lir_cond_aboveEqual:   acond = Assembler::HS; break;
        default:


A binary payload, with a human readable description
    BinaryRaw(BinMessage<'a>),

    /// A type chosen by the user as a general communication protocol
    ProtocolMessage(T),
}

/// A binary payload with UTF-8 Description
#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
pub struct BinMessage<'a> {
    description: &'a str,
    data: &'a [u8],
}

/// A binary logging interface, using UARTE0.
///target
/// In the future other serial interfaces might be supported
pub struct Logger<SEND, RECV>
where
    SEND: Sender,
    RECV: Receiver,
{
    uart: Uarte<UARTE0>,
    _send: SEND,

    #[allow(dead_code)]
    recv: RECV,
    pub good_msgs: usize,
    pub good_bytes: usize,
    pub dropped_bytes: usize,
    pub dropped_msgs: usize,
    pub bad_cobs: usize,
    pub full_buf: usize,
    pub full_msg: usize,
    pub ttl_got: usize,
}

impl<SEND, RECV> Logger<SEND, RECV>
where
    SEND: Sender + Default,
    RECV: Receiver + Default,
{
    pub fn new(mut uart: Uarte<UARTE0>) -> Self {
        // Send termination character
        // NOTE: this only ever returns an error if the buffer passed in is >= DMA_SIZE.
        // Since we always use a fixed buffer of 1, this can never fail
        uart.write(&[0x00]).unwrap();

        Self {
            uart,
            _send: SEND::default(),
            recv: RECV::default(),
            dropped_msgs: 0,
            dropped_bytes: 0,
            bad_cobs: 0,
            full_buf: 0,
            full_msg: 0,
            good_msgs: 0,
            good_bytes: 0,
            ttl_got: 0,
        }
    }
}

#[cfg(feature = "unstable")]
impl<SEND, T, BUFSZ, MSGCT> Logger<SEND, RealReceiver<T, BUFSZ, MSGCT>>
where
    T: DeserializeOwned,
    BUFSZ: ArrayLength<u8>,
    MSGCT: ArrayLength<T>,
    SEND: Sender + Default,
{
    /// Start the receive process using the internal double-buffers
    pub fn start_receive(&mut self) -> Result<(), ()> {
        if self.recv.ppm != PingPongMode::Idle {
            return Err(());
        }

        self.recv.ppm = PingPongMode::AActive;

        let periph = unsafe { &*UARTE0::ptr() };
        periph.events_rxdrdy.write(|w| unsafe { w.bits(0) });

        interrupt::free(|cs| unsafe {
            // NOTE: this only ever returns an error if the buffer passed in is >= DMA_SIZE.
            // Since we always use a fixed buffer of 255, this can never fail
            start_read(&mut *A_SIDE.borrow(cs).get(), false).unwrap();
        });

        Ok(())
    }

    /// Obtain any pending bytes in the active buffer. This also causes
    /// the internal double buffers to flip. When this function is successful,
    /// a sub-slice of `output` is returned, containing the read bytes.
    ///
    /// Bytes are obtained as they are received on the line, so decoding
    /// and deserialization must be performed manually.
    ///
    /// NOTE: Either this function or `service_receive()` must be polled
    /// periodically, or there will be data loss! In general, the calculation
    /// for "how often do I need to poll this" is `1 / (BAUDRATE /


def bellman_ford(vertices, edges, source):
    dist = [float('inf')] * vertices
    dist[source] = 0
    predecessor = [-1] * vertices
    print(f"Initial distances: {dist}")

    for i in range(vertices - 1):
        print(f"\nIteration {i+1}:")
        updated = False  # Flag to check if any distance was updated in this iteration
        for u, v, w in edges:
            if dist[u] != float('inf') and dist[u] + w < dist[v]:
                dist[v] = dist[u] + w
                predecessor[v] = u
                updated = True
        print(f"Distances: {dist}")
        if not updated:
            print("No more updates in this iteration.")
            break  # Optimization: If no updates, no negative cycle will be found later

    # Check for negative-weight cycles
    for u, v, w in edges:
        if dist[u] != float('inf') and dist[u] + w < dist[v]:
            print("\nGraph contains a negative-weight cycle")
            return

    print("\nFinal shortest distances from source:")
    for i in range(vertices):
        print(f"Vertex {i}: {dist[i]}")

V = int(input("Enter number of vertices: "))
E = int(input("Enter number of edges: "))
edges = []

print("Enter each edge in format: source destination weight (0-based index).")

for _ in range(E):
    try:
        u, v, w = map(int, input().split())
        edges.append((u, v, w))
        if not (0 <= u < V and 0 <= v < V):
            print("Invalid vertex index. Please ensure vertex indices are within the range [0, V-1].")
            exit()
    except ValueError:
        print("Invalid input format. Please enter source, destination, and weight separated by spaces.")
        exit()

source = int(input(f"Enter source Vertex (0 to {V-1}): "))
if not (0 <= source < V):
    print("Invalid source vertex index.")
else:
    bellman_ford(V, edges, source)


uxer {
	muxer := new(PsMuxer)
	muxer.firstframe = true
	muxer.system = new(SystemHeader)
	muxer.system.RateBound = 26234
	muxer.psm = new(ProgramStreamMap)
	muxer.psm.CurrentNextIndicator = 1
	muxer.psm.ProgramStreamMapVersion = 1
	muxer.OnPacket = nil
	return muxer
}

func (muxer *PsMuxer) AddStream(cid PsStreamType) uint8 {
	if cid == PsStreamH265 || cid == PsStreamH264 {
		es := NewElementaryStream(uint8(PesStreamVideo) + muxer.system.VideoBound)
		es.PStdBufferBoundScale = 1
		es.PStdBufferSizeBound = 400
		muxer.system.Streams = append(muxer.system.Streams, es)
		muxer.system.VideoBound++
		muxer.psm.StreamMap = append(muxer.psm.StreamMap, NewElementaryStreamElem(uint8(cid), es.StreamId))
		muxer.psm.ProgramStreamMapVersion++
		return es.StreamId
	} else {
		es := NewElementaryStream(uint8(PesStreamAudio) + muxer.system.AudioBound)
		es.PStdBufferBoundScale = 0
		es.PStdBufferSizeBound = 32
		muxer.system.Streams = append(muxer.system.Streams, es)
		muxer.system.AudioBound++
		muxer.psm.StreamMap = append(muxer.psm.StreamMap, NewElementaryStreamElem(uint8(cid), es.StreamId))
		muxer.psm.ProgramStreamMapVersion++
		return es.StreamId
	}
}

func (muxer *PsMuxer) Write(sid uint8, frame []byte, pts uint64, dts uint64) error {
	var stream *ElementaryStreamElem = nil
	for _, es := range muxer.psm.StreamMap {
		if es.ElementaryStreamId == sid {
			stream = es
			break
		}
	}
	if stream == nil {
		return errNotFound
	}
	if len(frame) <= 0 {
		return nil
	}
	var withaud bool = false
	var idrFlag bool = false
	var first bool = true
	var vcl bool = false
	if stream.StreamType == uint8(PsStreamH264) || stream.StreamType == uint8(PsStreamH265) {
		SplitFrame(frame, func(nalu []byte) bool {
			if stream.StreamType == uint8(PsStreamH264) {
				naluType := avc.ParseNaluType(nalu[0])
				if naluType == avc.NaluTypeAud {
					withaud = true
					return false
				} else if naluType >= avc.NaluTypeSlice && naluType <= avc.NaluTypeIdrSlice {
					if naluType == avc.NaluTypeIdrSlice {
						idrFlag = true
					}
					vcl = true
					return false
				}
				return true
			} else {
				naluType := hevc.ParseNaluType(nalu[0])
				if naluType == hevc.NaluTypeAud {
					withaud = true
					return false
				} else if naluType >= hevc.NaluTypeSliceBlaWlp && naluType <= hevc.NaluTypeSliceRsvIrapVcl23 ||
					naluType >= hevc.NaluTypeSliceTrailN && naluType <= hevc.NaluTypeSliceRaslR {
					if naluType >= hevc.NaluTypeSliceBlaWlp && naluType <= hevc.NaluTypeSliceRsvIrapVcl23 {
						idrFlag = true
					}
					vcl = true
					return false
				}
				return true
			}
		})
	}

	dts = dts * 90
	pts = pts * 90
	bsw := NewBitStreamWriter(1024)
	var pack PsPackHeader
	pack.SystemClockReferenceBase = dts


3 = i.toString(3).padStart(dim, '0');
    if (base3 === '1'.repeat(dim)) {
      continue;
    }
    const neighborPos = coords.map((v, i) => v + (+base3[i] - 1));
    neighbors.add(cordsToString(...neighborPos));
  }

  return neighbors
}

function checkPoint(point: string, state: Set<string>): boolean {
  const neighbors = getNeighbors(point);
  const activeCount = Array.from(neighbors).filter(neighbor => state.has(neighbor)).length;

  return state.has(point) ?
    (activeCount >= 2 && activeCount <= 3) :
    (activeCount === 3)
}

function step(state: Set<string>): Set<string> {
  const allNeighbors: Set<string> = new Set();
  state.forEach(v => getNeighbors(v).forEach(point => allNeighbors.add(point)));
  const allPointsToCheck = new Set([...Array.from(state), ...Array.from(allNeighbors)]);
  const newState: Set<string> = new Set();
  allPointsToCheck.forEach(point => {
    if (checkPoint(point, state)) {
      newState.add(point);
    }
  })

  return newState;
}

function calculatePart1(input: Set<string>) {
  let state = new Set(Array.from(input).map(v => v + ':0'));
  for(let i = 0; i < 6; i++) {
    state = step(state);
  }
  return state.size;
}

function calculatePart2(input: Set<string>) {
  let state = new Set(Array.from(input).map(v => v + ':0:0'));
  for(let i = 0; i < 6; i++) {
    state = step(state);
  }
  return state.size;
}

function parse(input: string): Set<string> {
  const result: Set<string> = new Set();
  const rows = input.split('\n');
  for (let y = 0; y < rows.length; y++) {
    for (let x = 0; x < rows[y].length; x++) {
      if (rows[y][x] === '#') {
        result.add(cordsToString(x, y));
      }
    }
  }
  return result;
}

export async function run() {
  const input: string = await getInput(DAY);
  const result1 = calculatePart1(parse(input));
  const result2 = calculatePart2(parse(input));
  return [result1, result2]
}

function tests() {
  const part1Test = getTestFunction((input) => calculatePart1(parse(input)));
  const part2Test = getTestFunction((input) => calculatePart2(parse(input)));
  part1Test(`.#.
..#
###`, 112);
  console.log('---------------------');

  part2Test(`.#.
..#
###`, 848);

  console.log('---------------------');
}
/**
 * 路由-菜单配置文件
 * @author donghui
 */
import { ComponentClass, FC, lazy } from "react";
// 使用延迟加载的方式引入组件
const User = lazy(()=> import("../pages/System/User/User"))
const Device = lazy(()=>import("../pages/Device"))
const Criterion = lazy(()=>import("../pages/Criterion"))
const DeviceType = lazy(()=>import("../pages/BasicData/DeviceType"))
const Institution = lazy(()=>import("../pages/BasicData/Institution"))
const Certificate = lazy(()=>import("../pages/Certificate"))
const Task = lazy(()=>import("../pages/Task"))
const TaskRun = lazy(()=>import("../pages/Task/Run"))
const TaskRun2 = lazy(()=>import("../pages/Task/Run/TaskRun2"))
const Data = lazy(()=>import("../pages/System/Data"))
const Config = lazy(()=>import("../pages/System/Config"))

// 主页路径
export const HOME_PATH = "device/list";

/**
 * 页面/路由配置
 * 多级菜单可根据业务需求调整数据结构，但考虑到后续权限控制的实现，推荐将所有菜单项平铺，通过字段逻辑来进行分组或嵌套
 */
const


2-.452-.23-.163-1.464-1.612-2.177-3.49-.65-1.712-1.493-4.871-2.532-6.059-.066-.073-.144-.166-.233-.264.245-.029.658-.107 1.292-.142.803-.043 4.111 3.009 4.396 3.909.28.9-.024 1.25 1.363 4.259 1.384 3.008 2.032 3.71 2.032 3.71h.241s-1.258-2.064-2.1-3.798zM349.447 209.404s2.402 1.515 3.114 1.713a9.806 9.806 0 0 0 1.233.264s.358 4.38 2.11 6.847c1.75 2.472 3.179 3.36 3.179 3.36s.065 4.772 1.364 8.067c1.3 3.291 1.558 7.275 1.266 7.9-.293.625-1.397-1.942-2.108-4.214-.716-2.273-1.398-4.739-1.884-6.255-.486-1.515-1.818-3.789-2.563-4.413-.75-.626-.147-.558.291-.165.438.396 1.704 1.959 2.516 4.48.81 2.517 1.134 5.069 1.573 5.086.438.016.777-.412.764-.923-.018-.507-.568-1.827-.972-4.18-.409-2.355-.815-3.967-1.204-4.626-.391-.658-.958-.774-2.465-3.408-1.51-2.634-2.176-4.099-2.436-5.318-.26-1.219.047-1.102-.213-1.284-.257-.18-.452.018-1.602-.624-1.153-.643-1.963-2.306-1.963-2.306z",fill:"#202020",key:179}),a.createElement("path",{d:"M355.671 208.513s1.471 1.142 2.293 1.492c.823.351 2.012.416 2.012.416s-.3 4.15 1.322 6.85c1.623 2.7 3.31 4.28 3.31 4.28s.26 1.01.78 6.803c.52 5.798.54 5.905.69 8.232.153 2.326.225 10.571-.109 10.317-1.253-.966-.215-5.444-.842-7.286-.627-1.846-1.622-2.154-2.834-7.375-1.213-5.226-.435-6.412-1.298-8.364-.865-1.955-2.012-2.13-2.012-2.13s1.6.308 2.271 1.954c.673 1.646.775 6.02 1.322 8.188 1.233 4.894 2.92 7.374 2.92 7.374s-.368-6.146-.844-9.635c-.477-3.493-.453-6.409-1.102-7.748-.652-1.342-2.058-2.417-2.9-4.195-.844-1.777-1.147-5.267-1.56-6.167-.41-.9-.644-.62-1.231-.855-1.905-.77-2.187-2.152-2.187-2.152z",fill:"#202020",key:180}),a.createElement("path",{d:"M360.106 206.235s1.298 1.447 3.112 2.524c1.821 1.075 2.728.747 3.01.966.281.22-.368 3.907 1.537 7.309 1.905 3.403 2.597 3.468 2.64 3.932.043.457.39 10.49.628


string>? _imagePullSecretsValuesPaths;

        /// <summary>
        /// The image pull secrets values path list.
        /// </summary>
        public InputList<string> ImagePullSecretsValuesPaths
        {
            get => _imagePullSecretsValuesPaths ?? (_imagePullSecretsValuesPaths = new InputList<string>());
            set => _imagePullSecretsValuesPaths = value;
        }

        [Input("registryValuesPaths")]
        private InputList<string>? _registryValuesPaths;

        /// <summary>
        /// The registry values path list.
        /// </summary>
        public InputList<string> RegistryValuesPaths
        {
            get => _registryValuesPaths ?? (_registryValuesPaths = new InputList<string>());
            set => _registryValuesPaths = value;
        }

        public HelmArtifactProfileArgs()
        {
        }
        public static new HelmArtifactProfileArgs Empty => new HelmArtifactProfileArgs();
    }
}


ct that if you use a custom parsing function, you will also
need to pass in a custom `format` function in order for the formatted date to be
correctly parsed back to a date object.

Here is an example using [date-fns](https://date-fns.org/):

```vue
<template>
  <DatePicker :format="customFormatter" :parser="customParser"></DatePicker>
</template>

<script>
import { format, parse } from 'date-fns'

export default {
  data() {
    return {
      format: 'dd.MM.yyyy',
    }
  },
  methods: {
    customFormatter(date) {
      return format(date, this.format)
    },
    customParser(date) {
      return parse(date, this.format, new Date())
    },
  },
}
</script>
```
# Pytorch + StableBaselines3 Implementation of RoboCLIP
This repository contains the implementation for the NeurIPS 2023 paper, [RoboCLIP: One Demonstration is Enough to Learn Robot Policies](https://arxiv.org/abs/2310.07899).

## Setting up the env

We recommend using conda for installation and provide a `.yml` file for installation.

```sh
git clone https://github.com/sumedh7/RoboCLIP.git --recursive
cd RoboCLIP
conda env create -f environment_roboclip.yml
conda activate roboclip
pip install -e mjrl
pip install -e Metaworld
pip install -e kitchen_alt
pip install -e kitchen_alt/kitchen/envs
wget https://www.rocq.inria.fr/cluster-willow/amiech/howto100m/s3d_howto100m.pth
wget https://www.rocq.inria.fr/cluster-willow/amiech/howto100m/s3d_dict.npy
mv S3D_HowTo100M/s3dg.py ./
```

If you're running into download issues with the S3D weights (last 2 commands), the two files can also be obtained from our google drive:
https://drive.google.com/file/d/1DN8t1feS0t5hYYTfXQfZd596Pu9yXJIr/view?usp=sharing
https://drive.google.com/file/d/1p_CMGppAQk3B0_Z0i1r2AN_D1FM3kUFW/view?usp=sharing

## How To use it ?

To run experiments on the Metaworld environment suite with the sparse learnt reward, we need to first define what the demonstration to be used is. For textual input, uncomment line 222 and comment 223 and add the string prompt you would like to use in the `text_string` param. Similarly, if you would like to use human demonstration, uncomment line 223 and pass the path of the gif of the demonstration you would like to use. Similarly, for a metaworld video demo, set `human=False` and set the `video_path`.

We provide the gifs used in our experiments within the `gifs/`.
Then run:
```sh
python metaworld_envs.py --env-type sparse_learnt --env-id drawer-open-v2-goal-hidden --dir-add <add experiment identifier>
```

To run the Kitchen experiments, similarly specify the gif path on line 345 and then run the following line with `--env-id` as `Kettle`, `Hinge` or `Slide`.

```sh
python kitchen_env_wrappers.py --env-type sparse_learnt --env-id Kettle --dir-add <add experiment identifier>
```

These runs should produce default tensorboard experiments which save the best eval policy obtained by training on the RoboCLIP reward to disk. The plots in the paper are visualized by finetuning these policies for a handful of episodes. To replicate the Metaworld finetuning,  run:

```sh
python metaworld_envs.py --env-type dense_original --env-id drawer-open-v2-goal-hidden --pretrained <path_to_best_policy> --dir-add <add_experiment_identifier>
```
## FAQ for Debugging
Please use the older version of Metaworld, i.e., pre Farama Foundation. Also rendering can be an issue sometimes, so setting the right renderer is necessary. We found `egl` to be useful.
```sh
export


/*
 * Hedgewars, a free turn based strategy game
 * Copyright (c) 2004-2015 Andrey Korotaev <unC0Rr@gmail.com>
 *
 * 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; version 2 of the License
 *
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef GAMECONFIG_H
#define GAMECONFIG_H

#include <QSettings>
#include <QStringList>
#include <QRect>
#include <QEvent>
#include <QList>
#include <utility>
#include "binds.h"

class HWForm;
class QSettings;

class GameUIConfig : public QSettings
{
        Q_OBJECT

    public:
        HWForm * Form;
        GameUIConfig(HWForm * FormWidgets, const QString & fileName);
        QStringList GetTeamsList();
        QRect vid_Resolution();
        std::pair<QRect, QRect> vid_ResolutionPair();
        bool vid_Maximized();
        void vid_SetMaximized(bool isMaximized);
        bool vid_Fullscreen();
        quint32 translateQuality();
        bool isSoundEnabled();
        bool isFrontendSoundEnabled();
        QString language();
        bool isMusicEnabled();
        bool isFrontendMusicEnabled();
        bool isAudioDampenEnabled();
        bool isShowFPSEnabled();
        bool isAltDamageEnabled();
        bool appendDateTimeToRecordName();
        int chatSize();
        quint8 volume();
        quint8 timerInterval();
        QString netNick();
        QString getRandomNick();
        QByteArray netPasswordHash();
        int netPasswordLength();
        void clearPasswordHash();
        void setPasswordHash(const QString & passwordhash);
        QString passwordHash();
        void clearTempHash();
        void setTempHash(const QString & temphash);
        QString tempHash();
        void setNetPasswordLength(int passwordLength);
        bool isReducedQuality() const;
        bool isFrontendEffects() const;
        bool isFrontendFullscreen() const;
        quint16 zoom();
        bool isHolidaySillinessEnabled() const;
        int quickGameExperience() const;
        void setQuickGameExperience(int exp);
        void resizeToConfigValues();
        quint32 stereoMode() const;
        void setValue(const QString & key, const QVariant & value);
        QString bind(int bindID);
        void setBind(int bindID, QString & strbind);

        QString AVFormat();
        QString videoCodec();
        QString audioCodec();
        QRect rec_Resolution();
        int rec_Framerate();
        int rec_Bitrate();
        bool recordAudio();

#ifdef __APPLE__
#ifdef SPARKLE_ENABLED
        bool isAutoUpdateEnabled();
#endif
#endif
        void reloadValues();
        void reloadVideosValues();

    signals:
        void frontendFullscreen(bool value);

    public slots:
        void SaveOptions();
        void SaveVideosOptions();
        void updNetNick();
    private:
        bool netPasswordIsValid();
        bool eventFilter(QObject *object, QEvent *event);
        QString temphash;
        QList<BindAction> m_binds;

        void applyProxySettings();
        bool pIsEngineWindowMaximized;

        QString cachedRandomNick;
};

#endif


l litet vatten över oss eller [kasta till oss] något av det som Gud har skänkt er!\" De skall svara: \"Bådadera har Gud nekat dem som avvisade tron"
  },
  {
    "surah_number": 7,
    "verse_number": 51,
    "content":
        "de som såg sin religion som en lek och ett tidsfördriv, därför att de hade fångats av det jordiska livets [lockelser].\" [Och Gud skall säga:] \"I dag har Vi glömt dem, liksom de glömde mötet denna Dag och inte trodde på Våra budskap"
  },
  {
    "surah_number": 7,
    "verse_number": 52,
    "content":
        "Ändå gav Vi dem en Skrift, där [allt] framställs fast och klart med [sann] kunskap, en vägledning och [en källa] till nåd för alla som tror"
  },
  {
    "surah_number": 7,
    "verse_number": 53,
    "content":
        "Väntar [förnekarna] bara på att [det som har förutsagts] skall bli verklighet? Men [den Dag] då det blir verklighet skall de glömska säga: \"Sändebuden från Vår Herre kom med sanningen! Om det nu finns någon som kan vara vår talesman, låt honom tala! Eller låt oss få återvända [till livet]! Då skall vi handla helt annorlunda än vi gjorde.\" De har förverkat sina själar och deras förmenta [beskyddare] har övergett dem"
  },
  {
    "surah_number": 7,
    "verse_number": 54,
    "content":
        "ER HERRE är förvisso Gud som skapade himlarna och jorden under sex dagar och som tronar i Sin allmakts härlighet [över skapelsen]. Han låter natten svepa dagen [i sitt mörker] - den ena följer den andra i snabb följd. Sol, måne och stjärnor lyder Hans bud. Skapelsen är Hans och Han befaller över allt. Välsignad vare Gud, världarnas Herre"
  },
  {
    "surah_number": 7,
    "verse_number": 55,
    "content":
        "Åkalla er Herre i det tysta med ödmjukt sinne; Han älskar inte dem som går till överdrift"
  },
  {
    "surah_number": 7,
    "verse_number": 56,
    "content":
        "Och stör inte ordningen och sprid inte sedefördärv på jorden, sedan allt där har ställts till rätta. Åkalla Honom med bävan och hopp! Guds nåd är nära dem som gör det goda och det rätta"
  },
  {
    "surah_number": 7,
    "verse_number": 57,
    "content":
        "Och det är Han som sänder ut vindarna som varslar om Hans nåd; det regndigra moln de driver fram låter Vi komma in över dött land och så faller regnet med vilket Vi frambringar [växter som bär] frukt av många slag. Så skall Vi låta de döda stiga fram [till nytt liv] - kanske skall ni ägna eftertanke åt [detta]"
  },
  {
    "surah_number": 7,
    "verse_number": 58,
    "content":
        "Ur den goda jorden spirar med dess Herres vilja [rik] växtlighet, men den magra bär inte skörd annat än med stor möda. Så förtydligar Vi budskap


: p21 = *(uint32 *) (table1 + p21)
# asm 1: lduw [<table1=int64#10+<p21=int64#21],>p21=int64#21
# asm 2: lduw [<table1=%o0+<p21=%l4],>p21=%l4
lduw [%o0+%l4],%l4

# qhasm: p31 = (uint32) y3 >> 12
# asm 1: srl <y3=int64#14,12,>p31=int64#24
# asm 2: srl <y3=%o4,12,>p31=%l7
srl %o4,12,%l7

# qhasm: z0 ^= p11
# asm 1: xor <z0=int64#5,<p11=int64#20,>z0=int64#5
# asm 2: xor <z0=%i4,<p11=%l3,>z0=%i4
xor %i4,%l3,%i4

# qhasm: p22 = *(uint32 *) (table2 + p22)
# asm 1: lduw [<table2=int64#12+<p22=int64#22],>p22=int64#20
# asm 2: lduw [<table2=%o2+<p22=%l5],>p22=%l3
lduw [%o2+%l5],%l3

# qhasm: z1 ^= p10
# asm 1: xor <z1=int64#8,<p10=int64#15,>z1=int64#8
# asm 2: xor <z1=%g4,<p10=%o5,>z1=%g4
xor %g4,%o5,%g4

# qhasm: z3 ^= p12
# asm 1: xor <z3=int64#17,<p12=int64#19,>z3=int64#15
# asm 2: xor <z3=%l0,<p12=%l2,>z3=%o5
xor %l0,%l2,%o5

# qhasm: p32 = (uint32) y3 >> 4
# asm 1: srl <y3=int64#14,4,>p32=int64#17
# asm 2: srl <y3=%o4,4,>p32=%l0
srl %o4,4,%l0

# qhasm: z2 ^= p13
# asm 1: xor <z2=int64#18,<p13=int64#11,>z2=int64#11
# asm 2: xor <z2=%l1,<p13=%o1,>z2=%o1
xor %l1,%o1,%o1

# qhasm: p23 = *(uint32 *) (table3 + p23)
# asm 1: lduw [<table3=int64#1+<p23=int64#13],>p23=int64#13
# asm 2: lduw [<table3=%i0+<p23=%o3],>p23=%o3
lduw [%i0+%o3],%o3

# qhasm: p30 = (uint32) y3 >> 20
# asm 1: srl <y3=int64#14,20,>p30=int64#14
# asm 2: srl <y3=%o4,20,>p30=%o4
srl %o4,20,%o4

# qhasm: p33 &= 4080
# asm 1: and <p33=int64#23,4080,>p33=int64#18
# asm 2: and <p33=%l6,4080,>p33=%l1
and %l6,4080,%l1

# qhasm: p33 = *(uint32 *) (table3 + p33)
# asm 1: lduw [<table3=int64#1+<p33=int64#18],>p33=int64#


, bottomLeft, topLeft))
                contour.add(interpolate(pointTopRight, pointTopLeft, topRight, topLeft))
            }
            8 -> {
                contour.add(interpolate(pointBottomLeft, pointTopLeft, bottomLeft, topLeft))
                contour.add(interpolate(pointTopLeft, pointTopRight, topLeft, topRight))
            }
            9 -> {
                contour.add(interpolate(pointBottomLeft, pointBottomRight, bottomLeft, bottomRight))
                contour.add(interpolate(pointTopLeft, pointTopRight, topLeft, topRight))
            }
            10 -> {
                contour.add(interpolate(pointBottomLeft, pointTopLeft, bottomLeft, topLeft))
                contour.add(interpolate(pointBottomRight, pointTopRight, bottomRight, topRight))
            }
            11 -> {
                contour.add(interpolate(pointBottomRight, pointTopRight, bottomRight, topRight))
                contour.add(interpolate(pointTopLeft, pointTopRight, topLeft, topRight))
            }
            12 -> {
                contour.add(interpolate(pointBottomLeft, pointTopLeft, bottomLeft, topLeft))
                contour.add(interpolate(pointBottomRight, pointTopRight, bottomRight, topRight))
            }
            13 -> {
                contour.add(interpolate(pointBottomLeft, pointBottomRight, bottomLeft, bottomRight))
                contour.add(interpolate(pointBottomRight, pointTopRight, bottomRight, topRight))
            }
            14 -> {
                contour.add(interpolate(pointBottomLeft, pointBottomRight, bottomLeft, bottomRight))
                contour.add(interpolate(pointBottomLeft, pointTopLeft, bottomLeft, topLeft))
            }
        }

        return contour
    }

    private fun contourLevels(interval: Int): List<Int> {
        val bounds = tile.elevationBounds
        val lower = (floor(bounds.min.meters).toInt() / interval) * interval
        val upper = (ceil(bounds.max.meters).toInt() / interval) * interval
        return (lower..upper step interval).filter { !isSeaLevel(it) }.toList()
    }

    private fun isSeaLevel(it: Int) = it == 0

    private fun close(p1: DoublePoint, p2: DoublePoint): Boolean {
        val delta = 0.01
        return p1 == p2 || (abs(p1.x - p2.x) <= delta && abs(p1.y - p2.y) <= delta)
    }

    private fun findContour(endToContour: Map<DoublePoint, MutableList<DoublePoint>>, end: DoublePoint): MutableList<DoublePoint>? {
        return endToContour[end] ?: endToContour.entries.firstOrNull { close(it.key, end) }?.value
    }

}/*
 * Copyright 2023 Treetracker
 *
 * 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 org.greenstand.android.TreeTracker.sessionnote

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.launch
import org.greenstand.android.TreeTracker.models.setupflow.CaptureSetupScopeManager

data class SessionNoteState(
    val note: String = "",
    val userImagePath: String = "",
)

class SessionNoteViewModel : ViewModel() {

    private val _state = MutableStateFlow(SessionNoteState())
    val state: Flow<SessionNoteState> = _state

    init {
        v


_t)(rle_z_count - 3); \
  } else { \
    d->m_huff_count[2][18] = (uint16_t)(d->m_huff_count[2][18] + 1); packed_code_sizes[num_packed_code_sizes++] = 18; packed_code_sizes[num_packed_code_sizes++] = (uint8_t)(rle_z_count - 11); \
} rle_z_count = 0; } }

	static uint8_t g_defl_packed_code_size_syms_swizzle[] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };

#define DEFL_DYN_PUT_BITS(bb, ll) \
do { \
	uint32_t b = (bb), l = (ll); \
	assert((l) >= 1 && (l) <= 16); assert((b) < (1ULL << (l))); \
	bit_buf |= (((uint64_t)(b)) << bit_buf_size); bit_buf_size += (l); assert(bit_buf_size <= 64); \
	while (bit_buf_size >= 8) \
	{ \
		if ((dst_ofs + 1) > dst_buf_size) \
			return false; \
		*(uint8_t*)(pDst + dst_ofs) = (uint8_t)bit_buf; \
		dst_ofs++; \
		bit_buf >>= 8; \
		bit_buf_size -= 8; \
	} \
} while(0)

	static bool defl_start_dynamic_block(defl_huff* d, uint8_t* pDst, uint32_t& dst_ofs, uint32_t dst_buf_size, uint64_t& bit_buf, int& bit_buf_size)
	{
		int num_lit_codes, num_dist_codes, num_bit_lengths; uint32_t i, total_code_sizes_to_pack, num_packed_code_sizes, rle_z_count, rle_repeat_count, packed_code_sizes_index;
		uint8_t code_sizes_to_pack[DEFL_MAX_HUFF_SYMBOLS_0 + DEFL_MAX_HUFF_SYMBOLS_1], packed_code_sizes[DEFL_MAX_HUFF_SYMBOLS_0 + DEFL_MAX_HUFF_SYMBOLS_1], prev_code_size = 0xFF;

		d->m_huff_count[0][256] = 1;

		defl_optimize_huffman_table(d, 0, DEFL_MAX_HUFF_SYMBOLS_0, 12, FPNG_FALSE);
		defl_optimize_huffman_table(d, 1, DEFL_MAX_HUFF_SYMBOLS_1, 12, FPNG_FALSE);

		for (num_lit_codes = 286; num_lit_codes > 257; num_lit_codes--) if (d->m_huff_code_sizes[0][num_lit_codes - 1]) break;
		for (num_dist_codes = 30; num_dist_codes > 1; num_dist_codes--) if (d->m_huff_code_sizes[1][num_dist_codes - 1]) break;

		memcpy(code_sizes_to_pack, &d->m_huff_code_sizes[0][0], num_lit_codes);
		memcpy(code_sizes_to_pack + num_lit_codes, &d->m_huff_code_sizes[1][0], num_dist_codes);
		total_code_sizes_to_pack = num_lit_codes + num_dist_codes; num_packed_code_sizes = 0; rle_z_count = 0; rle_repeat_count = 0;

		memset(&d->m_huff_count[2][0], 0, sizeof(d->m_huff_count[2][0]) * DEFL_MAX_HUFF


/*/
 * See the dyninst/COPYRIGHT file for copyright information.
 *
 * We provide the Paradyn Tools (below described as "Paradyn")
 * on an AS IS basis, and do not warrant its validity or performance.
 * We reserve the right to update, modify, or discontinue this
 * software at any time.  We shall have no obligation to supply such
 * updates or modifications or any other form of support to you.
 *
 * By your use of Paradyn, you understand and agree that we (or any
 * other person or entity with proprietary rights in Paradyn) are
 * under no obligation to provide either maintenance services,
 * update services, notices of latent defects, or correction of
 * defects for Paradyn.
 *
 * This 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.
 *
 * This 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 this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
#include <dataflowAPI/rose/SgAsmInstruction.h>
#include "../rose/semantics/SymEvalSemantics.h"
#include <string>

#if !defined(_SYMBOLIC_EXPANSION_H_)
#define _SYMBOLIC_EXPANSION_H_

class SgAsmInstruction;

using namespace rose::BinaryAnalysis::InstructionSemantics2;

namespace Dyninst {
    namespace DataflowAPI {

        class SymEvalPolicy;

        class SymEvalPolicy_64;

        class SymbolicExpansion {
        public:
            static bool expandX86(SgAsmInstruction *rose_insn,
                                  SymEvalPolicy &policy);

            static bool expandX86_64(SgAsmInstruction *rose_insn,
                                     SymEvalPolicy_64 &policy);

            static bool expandPPC32(SgAsmInstruction *rose_insn,
                                      BaseSemantics::RiscOperatorsPtr ops,
                                      const std::string &insn_dump);

            static bool expandPPC64(SgAsmInstruction *rose_insn,
                                      BaseSemantics::RiscOperatorsPtr ops,
                                      const std::string &insn_dump);

            static bool expandAarch64(SgAsmInstruction *rose_insn,
                                      BaseSemantics::RiscOperatorsPtr ops,
                                      const std::string &insn_dump);

            static bool expandAMDGPU(SgAsmInstruction *rose_insn,
                                      BaseSemantics::RiscOperatorsPtr ops,
                                      const std::string &insn_dump);

        };

    }
}
#endif


,"Phase 3":459839,"Phase 4":448177},"c5":"553421682"},"\u2605 StatTrak\u2122 Shadow Daggers | Doppler (Minimal Wear)":{"buff":43867,"uu":103443,"buff_phase":{"Ruby":null,"Sapphire":3917766,"Black Pearl":6836120,"Phase 1":17746109,"Phase 2":7889300,"Phase 3":14993544,"Phase 4":4575106},"c5":"553484070"},"\u2605 StatTrak\u2122 Shadow Daggers | Fade (Factory New)":{"buff":43868,"uu":56216,"c5":"25971"},"\u2605 StatTrak\u2122 Shadow Daggers | Forest DDPAT (Battle-Scarred)":{"buff":43869,"uu":60740,"c5":"27100"},"\u2605 StatTrak\u2122 Shadow Daggers | Forest DDPAT (Field-Tested)":{"buff":43870,"uu":60738,"c5":"27732"},"\u2605 StatTrak\u2122 Shadow Daggers | Forest DDPAT (Minimal Wear)":{"buff":43871,"uu":60737,"c5":"27363"},"\u2605 StatTrak\u2122 Shadow Daggers | Forest DDPAT (Well-Worn)":{"buff":43872,"uu":103438,"c5":"65018520"},"\u2605 StatTrak\u2122 Shadow Daggers | Marble Fade (Factory New)":{"buff":43873,"uu":60705,"c5":"553436480"},"\u2605 StatTrak\u2122 Shadow Daggers | Marble Fade (Minimal Wear)":{"buff":43874,"uu":103442,"c5":"553462765"},"\u2605 StatTrak\u2122 Shadow Daggers | Night (Field-Tested)":{"buff":43875,"uu":58450,"c5":"3860459"},"\u2605 StatTrak\u2122 Shadow Daggers | Night (Minimal Wear)":{"buff":43876,"uu":60765,"c5":"54456440"},"\u2605 StatTrak\u2122 Shadow Daggers | Rust Coat (Battle-Scarred)":{"buff":43877,"uu":57407,"c5":"553435110"},"\u2605 StatTrak\u2122 Shadow Daggers | Safari Mesh (Battle-Scarred)":{"buff":43878,"uu":57763,"c5":"10454686"},"\u2605 StatTrak\u2122 Shadow Daggers | Safari Mesh (Field-Tested)":{"buff":43879,"uu":60712,"c5":"27736"},"\u2605 StatTrak\u2122 Shadow Daggers | Safari Mesh (Minimal Wear)":{"buff":43880,"uu":60711,"c5":"156293470"},"\u2605 StatTrak\u2122 Shadow Daggers | Scorched (Battle-Scarred)":{"buff":43881,"uu":60749,"c5":"171644170"},"\u2605 StatTrak\u2122 Shadow Daggers | Scorched (Field-Tested)":{"buff":43882,"uu":60747,"c5":"26630"},"\u2605 StatTrak\u2122 Shadow Daggers | Scorched (Minimal Wear)":{"buff":43883,"uu":103474,"c5":"17500554"},"\u2605 StatTrak\u2122 Shadow Daggers | Scorched (Well-Worn)":{"buff":43884,"uu":60748,"c5":"171644169"},"\u2605 StatTrak\u2122 Shadow Daggers | Slaughter (Factory New)":{"buff":43885,"uu":60718,"c5":"10454736"},"\u2605 StatTrak\u2122 Shadow Daggers | Slaughter (Field-Tested)":{"buff":43886,"uu":109456,"c5":"47445740"},"\u2605 StatTrak\u2122 Shadow Daggers | Slaughter (Minimal Wear)":{"buff":43887,"uu":60719,"c5":"3792643"},"\u2605 StatTrak\u2122 Shad


cortex_m_rt::entry,
    hal::{
        pac::{interrupt, Interrupt, RADIO},
        ppi,
        prelude::*,
        timer::Timer,
        Clocks,
    },
    rtt_target::{rprintln, rtt_init_print},
};

static RADIO_REGS: Mutex<RefCell<Option<RADIO>>> = Mutex::new(RefCell::new(None));

#[entry]
fn main() -> ! {
    let p = hal::pac::Peripherals::take().unwrap();

    let _clocks = Clocks::new(p.CLOCK).enable_ext_hfosc();
    rtt_init_print!();

    let ppi_channels = ppi::Parts::new(p.PPI);
    let mut channel0 = ppi_channels.ppi0;

    channel0.set_task_endpoint(&p.RADIO.tasks_disable);
    channel0.set_event_endpoint(&p.TIMER0.events_compare[0]);
    channel0.enable();

    let radio = p.RADIO;
    radio.intenset.write(|w| w.disabled().set());
    cortex_m::interrupt::free(|cs| RADIO_REGS.borrow(cs).replace(Some(radio)));
    // NOTE(unsafe) There isn't any abstraction depending on this interrupt being masked
    unsafe {
        cortex_m::peripheral::NVIC::unmask(Interrupt::RADIO);
    }

    let mut timer = Timer::one_shot(p.TIMER0);
    timer.start(0xFFFFu32);

    loop {
        // Prevent empty loop optimizations
        compiler_fence(Ordering::SeqCst);
    }
}

#[interrupt]
fn RADIO() {
    cortex_m::interrupt::free(|cs| {
        if let Some(regs) = RADIO_REGS.borrow(cs).borrow_mut().as_mut() {
            if regs.events_disabled.read().bits() == 1 {
                rprintln!("We hit the RADIO disabled interrupt");

                // Clear the disabled flag
                // NOTE(unsafe) 0 is a valid value to write to this register
                regs.events_disabled.write(|w| unsafe { w.bits(0) });
            }
        }
    });
}

#[inline(never)]
#[panic_handler]
fn panic(info: &PanicInfo) -> ! {
    cortex_m::interrupt::disable();
    rprintln!("{}", info);
    loop {
        compiler_fence(Ordering::SeqCst);
    }
}
use structopt::StructOpt;

/// The ls replacement you never knew you needed
///
/// Written by: <NAME>
#[derive(StructOpt)]
pub struct Cli {
  /// Give me a directory
  #[structopt(parse(from_os_str), default_value = ".")]
  pub dir: std::path::PathBuf,

  /// Sorts files by name
  #[structopt(short = "n", long = "name")]
  pub name: bool,

  /// Sorts files by the date created
  #[structopt(short = "c", long = "created")]
  pub created: bool,

  /// Sorts files by the date modified
  #[structopt(short = "m", long = "modified")]
  pub modified: bool,

  /// Sorts files by file size
  #[structopt(short = "s", long = "size")]
  pub size: bool,

  /// Groups directorys before files
  #[structopt(short = "g", long = "gdf")]
  pub gdf: bool,

  /// Enables long mode (permissions, size, user, group)
  #[structopt(short = "l", long = "long")]
  pub long: bool,

  /// Formats the time output
  #[structopt(long = "time-format", default_value = "%e %b %H.%M")]
  pub time_format: String,

  /// Shows the file created time instead of the file modified time
  #[structopt(short = "i", long = "ct")]
  pub created_time: bool,
}
<filename


 : null;
    var colors = hasColors ? attributes["color"].array : null;
    var uvs = hasUVs ? attributes["uv"].array : null;
    var uv2s = hasUV2s ? attributes["uv2"].array : null;

    var positions2 = positions;
    var normals2 = normals;
    var colors2 = colors;
    var uvs2 = uvs;
    var uv2s2 = uv2s;

    var iteration = 0;
    var tessellating = true;

    Function addTriangle = (a, b, c) {
      var v1 = vs[a];
      var v2 = vs[b];
      var v3 = vs[c];

      positions2.push(v1.x, v1.y, v1.z);
      positions2.push(v2.x, v2.y, v2.z);
      positions2.push(v3.x, v3.y, v3.z);

      if (hasNormals) {
        var n1 = ns[a];
        var n2 = ns[b];
        var n3 = ns[c];

        normals2.push(n1.x, n1.y, n1.z);
        normals2.push(n2.x, n2.y, n2.z);
        normals2.push(n3.x, n3.y, n3.z);
      }

      if (hasColors) {
        var c1 = cs[a];
        var c2 = cs[b];
        var c3 = cs[c];

        colors2.push(c1.r, c1.g, c1.b);
        colors2.push(c2.r, c2.g, c2.b);
        colors2.push(c3.r, c3.g, c3.b);
      }

      if (hasUVs) {
        var u1 = us[a];
        var u2 = us[b];
        var u3 = us[c];

        uvs2.push(u1.x, u1.y);
        uvs2.push(u2.x, u2.y);
        uvs2.push(u3.x, u3.y);
      }

      if (hasUV2s) {
        var u21 = u2s[a];
        var u22 = u2s[b];
        var u23 = u2s[c];

        uv2s2.push(u21.x, u21.y);
        uv2s2.push(u22.x, u22.y);
        uv2s2.push(u23.x, u23.y);
      }
    };

    while (tessellating && iteration < maxIterations) {
      iteration++;
      tessellating = false;

      positions = positions2;
      positions2 = [];

      if (hasNormals) {
        normals = normals2;
        normals2 = [];
      }

      if (hasColors) {
        colors = colors2;
        colors2 = [];
      }

      if (hasUVs) {
        uvs = uvs2;
        uvs2 = [];
      }

      if (hasUV2s) {
        uv2s = uv2s2;
        uv2s2 = [];
      }

      for (var i = 0, i2 = 0, il = positions.length; i < il; i += 9, i2 += 6) {
        va.fromArray(positions, i + 0);
        vb.fromArray(positions, i + 3);
        vc.fromArray(positions, i + 6);

        if (hasNormals) {
          na.fromArray(normals, i + 0);
          nb.fromArray(normals, i + 3);
          nc.fromArray(normals, i + 6);
        }

        if (hasColors) {
          ca.fromArray(colors, i + 0);
          cb.fromArray(colors, i + 3);
          cc.fromArray(colors, i + 6);
        }

        if (hasUVs) {
          ua.fromArray(uvs, i2 + 0);
          ub.fromArray(uvs, i2 + 2);
          uc.fromArray(uvs, i2 + 4);
        }


ospina",
    ["Ahab Wheathoof"] = "Ahab Pezuña de Trigo",
    ["Kyle the Frenzied"] = "Kyle el Demenciado",
    ["Supervisor Fizsprocket"] = "Supervisor Saltatuercas",
    ["Dire Mottled Boar"] = "Jabalí jaspeado temible",
    ["Surf Crawler"] = "Reptador de espuma adulto",
    ["Armored Scorpid"] = "Escórpido acorazado",
    ["Shara Sunwing"] = "Shara Alasol",
    ["Julia Sunstriker"] = "Julia Golpesol",
    ["Summoner Teli'Larien"] = "Invocador Teli'Larien",
    ["Matron Arena"] = "Matrona Arena",
    ["Ranger Sallina"] = "Forestal Sallina",
    ["Jesthenis Sunstriker"] = "Jesthenis Golpesol",
    ["Well Watcher Solanian"] = "Vigía del pozo Solanian",
    ["Arcanist Ithanas"] = "Arcanista Ithanas",
    ["Arcanist Helion"] = "Arcanista Helion",
    ["Outrunner Alarion"] = "Avanzada Alarion",
    ["Slain Outrunner"] = "Avanzada asesinada",
    ["Innkeeper Delaniel"] = "Tabernera Delaniel",
    ["Aeldon Sunbrand"] = "Aeldon Marcasol",
    ["Duelist Larenis"] = "Duelista Larenis",
    ["Sergeant Kan'ren"] = "Sargento Kan'ren",
    ["Ley-Keeper Caidanis"] = "Vigilante-Ley Caidanis",
    ["Apprentice Ralen"] = "Aprendiz Ralen",
    ["Apprentice Meledor"] = "Aprendiz Meledor",
    ["Eversong Ranger"] = "Forestal Canción Eterna",
    ["Ranger Jaela"] = "Forestal Jaela",
    ["Ley-Keeper Velania"] = "Vigilante-Ley Velania",
    ["Hathvelion Sungaze"] = "Hathvelion Mirasol",
    ["Prospector Anvilward"] = "Prospector Guardayunque",
    ["Halis Dawnstrider"] = "Halis Caminalba",
    ["Velan Brightoak"] = "Velan Roblebrillante",
    ["Magistrix Landra Dawnstrider"] = "Magistrix Landra Caminalba",
    ["Ranger Degolien"] = "Forestal Degolien",
    ["Marniel Amberlight"] = "Marniel Luzámbar",
    ["Ardeyn Riverwind"] = "Ardeyn Ríobrisa",
    ["Captain Kelisendra"] = "Capitana Kelisendra",
    ["Velendris Whitemorn"] = "Velendris Albodía",
    ["Springpaw Stalker"] = "Acechador garragil",
    ["Larianna Riverwind"] = "Larianna Ríobrisa",
    ["Whitebark's Spirit"] = "Espíritu de Cortezablanca",
    ["Ranger Sareyn"] = "Forestal Sareyn",
    ["Apprentice Mirveda"] = "Aprendiza Mirveda",
    ["Vinemaster Suntouched"] = "Maestro vinícola Toquesol",
    ["Skymistress Gloaming"] = "Maestra del cielo Anochecer",
    ["Zalene Firstlight"] = "Zalene Albatemprana",
    ["Lieutenant Dawnrunner"] = "Teniente Correalba",
    ["Arathel Sunforge"] = "Arathel Forjasol",
    ["Magister Duskwither"] = "Magister Ocaso Marchito",
    ["Apprentice Loralthalis"] = "Aprendiza Loralthalis",
    ["Groundskeeper Wyllithen"] = "Guardés Wyllithen",
    ["Lotheolan"] = "Luanga",
    ["Knight-L


- (1) :
    - C++17 : `double`に対するオーバーロード
    - C++23 : 浮動小数点数型に対するオーバーロード
- (2) : 算術型に対するオーバーロード (対応する精度の浮動小数点数型にキャストして計算される)
- (3) : `float`型規定
- (4) : `long double`型規定

## 戻り値
引数 `l`, `m`, `theta` について $Y_l^m(\theta, 0)$ (ただし $0 \le m \le l$) を返す。
$Y_l^m(\theta, \phi)$ は球面調和関数
$$
Y_l^m(\theta, \phi) = (-1)^m \sqrt{\frac{2l + 1}{4\pi} \frac{(l - m)!}{(l + m)!}} P_l^m(\cos \theta) \exp(i m \phi)
\quad \text{for } |m| \le l
$$
である。
$P_l^m$ はルジャンドル陪関数 ([`assoc_legendre`](assoc_legendre.md)) である。

## 備考
- `l >= 128` の場合、この関数の呼び出しの効果は実装定義である
- (1) : C++23では、拡張浮動小数点数型を含む浮動小数点数型へのオーバーロードとして定義された

### 球面調和関数
球面調和関数として使う場合には $\phi$ 依存性は自分で与える必要がある。
また、この標準関数は $m\ge0$ にしか対応していないので、$m < 0$ の時の球面調和関数を計算したければ自分で $Y_l^{|m|}(\theta,0)$ の値を調節して使う必要がある。
ルジャンドル陪関数の性質 $P_l^{-m}(x) = (-1)^m [(l - m)!/(l + m)!] P_l^m(x)$ より、一般の $m$ の球面調和関数は
$$
\begin{align*}
Y_l^m(\theta, \phi)
  &= (-1)^{(m+|m|)/2} \sqrt{\frac{2l + 1}{4\pi} \frac{(l - |m|)!}{(l + |m|)!}} P_l^{|m|}(\cos \theta) e^{i m \phi} \\
  &= \begin{cases}
    Y_l^{m}(\theta, 0) e^{im\phi}, & (0 \le m \le l), \\
    (-1)^{|m|} Y_l^{|m|}(\theta, 0) e^{im\phi}, & (-l \le m < 0).
  \end{cases}
\end{align*}
$$
で与えられる。

```cpp
#include <cmath>
#include <complex>
#include <numbers>

// 球面調和関数の実装例
std::complex<double> sph_harmonics(unsigned l, int m, double theta, double phi) {
  if (m >= 0)
    return std::sph_legendre(l, (unsigned) m, theta) * std::polar(1.0, m * phi);
  else
    return std::sph_legendre(l, (unsigned) -m, theta) * std::polar(1.0, m * (phi - std::numbers::pi));
}
```
* std::sph_legendre[color ff0000]
* std::polar[link /reference/complex/complex/polar.md]
* std::numbers::pi[link /reference/numbers/pi.md]

また線形結合を取り直して実数にした、実数球面調和関数 $Y_{lm}(\theta,\phi)$ を計算することもできる。

$$
Y_{lm}(\theta,\phi)
= \begin{cases}
  \frac{(-1)^m Y_l^{|m|}(\theta,\phi) - Y_l^{-|m|}(\theta,\phi)}{\sqrt{2} i} = \sqrt{2} (-1)^{|m|} Y_l^{|m|}(\theta, 0) \sin(|m|\phi), & (-l \le m < 0), \\
  Y_l^0 = Y_l^0(\theta, 0), & (m = 0), \\
  \frac{(-1)^m Y_l^{|m|}(\theta,\phi) + Y_l^{-|m|}(\theta,\phi)}{\sqrt{2}} = \sqrt{2} (-1)^{|m|} Y_l^{|m|}(\theta, 0) \cos(|m|\phi), & (0 < m \le l).
\end{cases}
$$

```cpp
#include <cmath>
#include <numbers>

// 実数球面調和関数の実�


dirname(path)).create(recursive: true);
          } catch (_) {}
        }
      }
      final mode = readOnly
          ? ffi.OpenMode.readOnly
          : ffi.OpenMode.readWriteCreate;
      ffiDb = ffi.sqlite3.open(path, mode: mode, uri: isUri);

      // Handle hot-restart for single instance
      // The dart code is killed but the native code remains
      if (singleInstance) {
        if (ffiDb is ffi.Database) tracker.markOpened(ffiDb);
      }
    }

    return ffiDb;
  }

  /// Delete the database file including its journal file and other auxiliary files
  @override
  Future<void> deleteDatabasePlatform(String path) async {
    await platform.databaseFileSystem.deleteDatabase(path);
  }

  @override
  Future<Uint8List> readDatabaseBytesPlatform(String path) async {
    return platform.databaseFileSystem.readDatabaseBytes(path);
  }

  @override
  Future<void> writeDatabaseBytesPlatform(String path, Uint8List bytes) async {
    await platform.databaseFileSystem.writeDatabaseBytes(path, bytes);
  }

  /// Check if database file exists
  @override
  Future<bool> handleDatabaseExistsPlatform(String path) async {
    // Ignore failure
    try {
      return (File(path)).existsSync();
    } catch (_) {
      return false;
    }
  }

  /// Default database path.
  @override
  String getDatabasesPathPlatform() {
    return absolute(join('.dart_tool', 'sqflite_common_ffi', 'databases'));
  }

  @override
  Future<void> handleOptionsPlatform(Map argumentMap) async {
    // None yet, needed for the web
  }
}

/// Io handler
SqfliteFfiHandler sqfliteFfiHandlerIo = _SqfliteFfiHandlerIo();
import 'package:sqflite_common/sqlite_api.dart';
import 'package:test/test.dart';

import 'src/core_import.dart';

/// Statement test.
void run(SqfliteTestContext context) {
  var factory = context.databaseFactory;

  group('statement', () {
    test(
      'with_sudoku_solver',
      () async {
        //await Sqflite.setDebugModeOn(true);
        var path = await context.initDeleteDb('with_sudoku_solver.db');
        var db = await factory.openDatabase(path);
        try {
          var result = await db.rawQuery('''
WITH RECURSIVE
  input(sud) AS (
    VALUES('53..7....6..195....98....6.8...6...34..8.3..17...2...6.6....28....419..5....8..79')
  ),
  digits(z, lp) AS (
    VALUES('1', 1)
    UNION ALL SELECT
    CAST(lp+1 AS TEXT), lp+1 FROM digits WHERE lp<9
  ),
  x(s, ind) AS (
    SELECT sud, instr(sud, '.') FROM input
    UNION ALL
    SELECT
      substr(s, 1, ind-1) || z || substr(s, ind+1),
      instr( substr(s, 1, ind-1) || z || substr(s, ind+1), '.' )
     FROM x, digits AS z
    WHERE ind>0
      AND NOT EXISTS (
            SELECT 1
              FROM digits AS lp
             WHERE z.z = substr(s, ((ind-1)/9)*9 + lp, 1)
                OR z.z = substr(s, ((ind-1)%9) + (lp-1)*9 + 1, 1)
                OR z.z = substr(s, (((ind-1)/3) % 3) * 3
                        + ((ind-1)/27) * 27 + lp
                        + ((lp-1) / 3) * 6, 1)
         )
  )
SELECT s FROM x WHERE ind=0;
            ''');
          //print(result);
          expect(result, [
            {


stargate_group_system"):GetBool()) then return false; end
	return self.GateGalaxy;
end

function ENT:SetGalaxy(b)
	if (self.Entity:GetClass()=="stargate_supergate" or self.Entity:GetClass()=="stargate_orlin") then return end
	if (GetConVar("stargate_group_system"):GetBool()) then
		self.GateGalaxy = false;
		self:SetEntityModifier("Galaxy",false); -- Entity Modifiers for Duplicator
		self.Entity:SetNWBool("Galaxy",false);
		self:RefreshGateList("galaxy",self.GateGalaxy,"bool");
		return;
	end
	b = util.tobool(b);
	local override = hook.Call("StarGate.SetGalaxy",GAMEMODE,self.Entity,self.GateGalaxy or false,b);
	if(type(override) == "boolean") then b = override end;
	self.GateGalaxy = b;
	self:SetEntityModifier("Galaxy",b); -- Entity Modifiers for Duplicator
	self.Entity:SetNWBool("Galaxy",b);
	self:RefreshGateList("galaxy",self.GateGalaxy,"bool");
end

--################# Is this gate blocked? by AlexALX
function ENT:GetBlocked()
	if (self:GetNetworkedInt("SG_BLOCK_ADDRESS")<=0 or self:GetNetworkedInt("SG_BLOCK_ADDRESS")==1 and self:GetClass()!="stargate_universe") then return false; end
	return self.GateBlocked;
end

--################# Set it blocked by AlexALX
function ENT:SetBlocked(b)
	if (self.Entity:GetClass()=="stargate_supergate" or self.Entity:GetClass()=="stargate_orlin") then return end
	b = util.tobool(b);
	local override = hook.Call("StarGate.SetBlocked",GAMEMODE,self.Entity,self.GateBlocked or false,b);
	if(type(override) == "boolean") then b = override end;
	self.GateBlocked = b;
	self:SetEntityModifier("Blocked",b); -- Entity Modifiers for Duplicator
	self.Entity:SetNWBool("Blocked",b);
	self:RefreshGateList("blocked",self.GateBlocked,"bool");
end

--################# Client->Server communication @aVoN
concommand.Remove("_StarGate.SetValue"); -- In case of a sent_reload (or lua_reload? How is that new command named?)
concommand.Add("_StarGate.SetValue",
	function(p,_,arg)
		local e = ents.GetByIndex(tonumber(arg[1])); -- Entity
		local c = arg[2]; -- Command
		local d = arg[3]; -- Data
		local d2 = arg[4]; -- Data2 (e.g. for dial!)
		if(IsValid(e) and c and d) then
			--##### Allowed? (Prevents clients using the clientside functions to cheat on my system)
			if(c == "Address" or c == "Name" or c == "Private" or c == "Group" or c == "Locale") then
				-- Is he allowed to change an address/name/private state?
				if(hook.Call("StarGate.Player.CanModifyGate",GAMEMODE,p,e) == false) then return end; -- On any gate?
				if(e.GateSpawnerProtected) then -- On a protected gate?
					local allowed = hook.Call("StarGate.Player.CanModifyProtectedGate",GAMEMODE,p,e);
					if(allowed == nil) then allowed = (p:IsAdmin() or game.SinglePlayer()) end;
					if(not allowed) then return end;
				end
			elseif(c == "Dial" or c == "AbortDialling") th


class Solution:
    def largestPathValue(self, colors: str, edges: List[List[int]]) -> int:
        if not edges and colors:
            return 1
        val_map = {}
        for i in range(len(colors)):
            val_map[i] = colors[i]
        adj_list = {}
        for start, end in edges:
            adj_list.setdefault(start, []).append(end)

        res = -1
        visited = [0] * len(colors)
        curr_vals = defaultdict(int)
        has_cycle = False

        memo = {}

        def dfs(curr):
            nonlocal has_cycle
            # cycle
            if visited[curr] == 1:
                has_cycle = True
                return [0] * 26

            # cached
            if visited[curr] == 2:
                return memo[curr]

            visited[curr] = 1
            color_counts = [0] * 26

            if curr not in adj_list:
                visited[curr] = 2
                i = ord(val_map[curr]) - ord('a')
                color_counts[i] += 1
                memo[curr] = color_counts
                return color_counts
            for neighbor in adj_list[curr]:
                child_counts = dfs(neighbor)
                for c in range(26):
                    color_counts[c] = max(color_counts[c], child_counts[c])
            visited[curr] = 2
            memo[curr] = color_counts
            i = ord(val_map[curr]) - ord('a')
            color_counts[i] += 1
            return color_counts

        res = 0
        for node in adj_list:
            counts = dfs(node)
            res = max(res, max(counts))
        if has_cycle:
            return -1
        return res


 compare integers with "_" when finding the goal position of each tile, thus ignore the "_" tile
           if state[i][j] != '_':
               # Get goal position of each tile
               goal_row, goal_col = [(x, y) for x in range(len(goal)) for y in range(len(goal[x])) if goal[x][y] == state[i][j]][0]
               # Add the the Manhattan distance of the current and goal coordinates of the tile to the estimate
               h += abs(i - goal_row) + abs(j - goal_col)
   return h

print(a_star())


>Exceptions

asio::system_error

                  Thrown on failure.

Copyright © 2003-2023 Christopher M. Kohlhoff

        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>windows::basic_random_access_handle::basic_random_access_handle (4 of 6 overloads)</title>
<link rel="stylesheet" href="../../../../boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Asio">
<link rel="up" href="../basic_random_access_handle.html" title="windows::basic_random_access_handle::basic_random_access_handle">
<link rel="prev" href="overload3.html" title="windows::basic_random_access_handle::basic_random_access_handle (3 of 6 overloads)">
<link rel="next" href="overload5.html" title="windows::basic_random_access_handle::basic_random_access_handle (5 of 6 overloads)">
<meta name="viewport" content="width=device-width, initial-scale=1">

windows::basic_random_access_handle::basic_random_access_handle
          (4 of 6 overloads)

            Construct a random-access handle on an existing native handle.

template<


m.IntRange( top + 1, bottom - 2 )));
			} while (pos == level.entrance() || level.findMob(level.entrance()) != null || level.solid[pos]);
			GuidePage p = new GuidePage();
			p.page(Document.GUIDE_SEARCHING);
			level.drop( p, pos );
		}

		Random.popGenerator();

	}

	private static ArrayList<Class<?extends StandardRoom>> rooms = new ArrayList<>();
	static {
		rooms.add(EntranceRoom.class);

		rooms.add(WaterBridgeEntranceRoom.class);
		rooms.add(CircleBasinEntranceRoom.class);

		rooms.add(ChasmBridgeEntranceRoom.class);
		rooms.add(PillarsEntranceRoom.class);

		rooms.add(CaveEntranceRoom.class);
		rooms.add(CavesFissureEntranceRoom.class);

		rooms.add(HallwayEntranceRoom.class);
		rooms.add(StatuesEntranceRoom.class);

		rooms.add(ChasmEntranceRoom.class);
		rooms.add(RitualEntranceRoom.class);
	}

	private static float[][] chances = new float[43][];
	static {
		chances[1] =  new float[]{1,  0,0, 0,0, 0,0, 0,0, 0,0};
		chances[2] =  chances[1];
		chances[3] =  new float[]{3,  6,1, 0,0, 0,0, 0,0, 0,0};
		chances[5] =  chances[4] = chances[3];

		chances[6] =  new float[]{2,  0,0, 4,4, 0,0, 0,0, 0,0};
		chances[10] = chances[9] = chances[8] = chances[7] = chances[6];

		chances[11] = new float[]{2,  0,0, 0,0, 4,4, 0,0, 0,0};
		chances[15] = chances[14] = chances[13] = chances[12] = chances[11];

		chances[16] = new float[]{2,  0,0, 0,0, 0,0, 4,4, 0,0};
		chances[20] = chances[19] = chances[18] = chances[17] = chances[16];

		chances[21] = new float[]{3,  0,0, 0,0, 0,0, 0,0, 6,1};
		chances[30] = chances[29] = chances[28] = chances[27] = chances[26] =
		chances[25] = chances[24] = chances[23] = chances[22] = chances[21];

		chances[31] = new float[]{3,  1,2, 3,4, 5,5, 4,3, 6,1};
		chances[42] = chances[41] = chances[40] = chances[39]
		= chances[38] = chances[37] = chances[36] = chances[35]
		= chances[34] = chances[33] = chances[32] = chances[31];
	}

	public static StandardRoom createEntrance(){
		return Reflection.newInstance(rooms.get(Random.chances(chances[Dungeon.depth])));
	}

}/*
 * Pixel Dungeon
 * Copyright (C) 2012-2015 Oleg Dolya
 *
 * Shattered Pixel Dungeon
 * Copyright (C) 2014-2024 Evan Debenham
 *
 * 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 com.shatteredpixel.shatteredpixeld


 'coverLeftText1'},
    {'1': 'cover_left_text2', '3': 5, '4': 1, '5': 9, '10': 'coverLeftText2'},
    {'1': 'cover_left_text3', '3': 6, '4': 1, '5': 9, '10': 'coverLeftText3'},
    {'1': 'avid', '3': 7, '4': 1, '5': 3, '10': 'avid'},
    {'1': 'cid', '3': 8, '4': 1, '5': 3, '10': 'cid'},
    {
      '1': 'media_type',
      '3': 9,
      '4': 1,
      '5': 14,
      '6': '.bilibili.app.dynamic.v2.MediaType',
      '10': 'mediaType'
    },
    {
      '1': 'dimension',
      '3': 10,
      '4': 1,
      '5': 11,
      '6': '.bilibili.app.dynamic.v2.Dimension',
      '10': 'dimension'
    },
    {
      '1': 'badge',
      '3': 11,
      '4': 3,
      '5': 11,
      '6': '.bilibili.app.dynamic.v2.VideoBadge',
      '10': 'badge'
    },
    {'1': 'can_play', '3': 12, '4': 1, '5': 8, '10': 'canPlay'},
    {
      '1': 'stype',
      '3': 13,
      '4': 1,
      '5': 14,
      '6': '.bilibili.app.dynamic.v2.VideoType',
      '10': 'stype'
    },
    {'1': 'is_p_g_c', '3': 14, '4': 1, '5': 8, '10': 'isPGC'},
    {'1': 'inline_u_r_l', '3': 15, '4': 1, '5': 9, '10': 'inlineURL'},
    {'1': 'episode_id', '3': 16, '4': 1, '5': 3, '10': 'episodeId'},
    {'1': 'sub_type', '3': 17, '4': 1, '5': 5, '10': 'subType'},
    {'1': 'pgc_season_id', '3': 18, '4': 1, '5': 3, '10': 'pgcSeasonId'},
    {'1': 'play_icon', '3': 19, '4': 1, '5': 9, '10': 'playIcon'},
    {'1': 'duration', '3': 20, '4': 1, '5': 3, '10': 'duration'},
    {'1': 'jump_url', '3': 21, '4': 1, '5': 9, '10': 'jumpUrl'},
    {'1': 'is_preview', '3': 22, '4': 1, '5': 8, '10': 'isPreview'},
    {
      '1': 'badge_category',
      '3': 23,
      '4': 3,
      '5': 11,
      '6': '.bilibili.app.dynamic.v2.VideoBadge',
      '10': 'badgeCategory'
    },
    {'1': 'is_feature', '3': 24, '4': 1, '5': 8, '10': 'isFeature'},
    {
      '1': 'reserve_type',
      '3': 25,
      '4': 1,
      '5': 14,
      '6': '.bili


$__default[\"default\"](config.target).attr('id', id);\n        }\n\n        config.target = \"#\" + id;\n      }\n\n      Util.typeCheckConfig(NAME$2, config, DefaultType$1);\n      return config;\n    };\n\n    _proto._getScrollTop = function _getScrollTop() {\n      return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop;\n    };\n\n    _proto._getScrollHeight = function _getScrollHeight() {\n      return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);\n    };\n\n    _proto._getOffsetHeight = function _getOffsetHeight() {\n      return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height;\n    };\n\n    _proto._process = function _process() {\n      var scrollTop = this._getScrollTop() + this._config.offset;\n\n      var scrollHeight = this._getScrollHeight();\n\n      var maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight();\n\n      if (this._scrollHeight !== scrollHeight) {\n        this.refresh();\n      }\n\n      if (scrollTop >= maxScroll) {\n        var target = this._targets[this._targets.length - 1];\n\n        if (this._activeTarget !== target) {\n          this._activate(target);\n        }\n\n        return;\n      }\n\n      if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {\n        this._activeTarget = null;\n\n        this._clear();\n\n        return;\n      }\n\n      for (var i = this._offsets.length; i--;) {\n        var isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]);\n\n        if (isActiveTarget) {\n          this._activate(this._targets[i]);\n        }\n      }\n    };\n\n    _proto._activate = function _activate(target) {\n      this._activeTarget = target;\n\n      this._clear();\n\n      var queries = this._selector.split(',').map(function (selector) {\n        return selector + \"[data-target=\\\"\" + target + \"\\\"],\" + selector + \"[href=\\\"\" + target + \"\\\"]\";\n      });\n\n      var $link = $__default[\"default\"]([].slice.call(document.querySelectorAll(queries.join(','))));\n\n      if ($link.hasClass(CLASS_NAME_DROPDOWN_ITEM)) {\n        $link.closest(SELECTOR_DROPDOWN$1).find(SELECTOR_DROPDOWN_TOGGLE$1).addClass(CLASS_NAME_ACTIVE$1);\n        $link.addClass(CLASS_NAME_ACTIVE$1);\n      } else {\n        // Set triggered link as active\n        $link.addClass(CLASS_NAME_ACTIVE$1); // Set triggered links parents as active\n        // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor\n\n        $link.parents(SELECTOR_NAV_LIST_GROUP$1).prev(SELECTOR_NAV_LINKS + \", \" + SELECTOR_LIST_ITEMS).addClass(CLASS_NAME_ACTIVE$1); // Handle special case when .nav-link is inside .nav-item\n\n        $link.parents(SELECTOR_NAV_LIST_GROUP$1).


, [sp, #104]
	LDRD	r10, r11, [sp, #144]
	LDR	r12, [sp, #184]
	LDR	lr, [sp, #188]
	EOR	r4, r4, r6
	EOR	r5, r5, r7
	EOR	r4, r4, r8
	EOR	r5, r5, r9
	EOR	r4, r4, r10
	EOR	r5, r5, r11
	EOR	r4, r4, r12
	EOR	r5, r5, lr
	STRD	r4, r5, [r0, #24]
	/* Calc t[2] */
	LDRD	r2, r3, [r0, #8]
	EOR	r2, r2, r5, LSR #31
	EOR	r3, r3, r4, LSR #31
	EOR	r2, r2, r4, LSL #1
	EOR	r3, r3, r5, LSL #1
	/* Calc b[2] and XOR t[2] into s[x*5+2] */
	LDRD	r4, r5, [sp, #16]
	LDRD	r6, r7, [sp, #56]
	LDRD	r8, r9, [sp, #96]
	LDRD	r10, r11, [sp, #136]
	EOR	r12, r4, r6
	EOR	lr, r5, r7
	EOR	r12, r12, r8
	EOR	lr, lr, r9
	EOR	r12, r12, r10
	EOR	lr, lr, r11
	EOR	r4, r4, r2
	EOR	r5, r5, r3
	EOR	r6, r6, r2
	EOR	r7, r7, r3
	EOR	r8, r8, r2
	EOR	r9, r9, r3
	EOR	r10, r10, r2
	EOR	r11, r11, r3
	STRD	r4, r5, [sp, #16]
	STRD	r6, r7, [sp, #56]
	STRD	r8, r9, [sp, #96]
	STRD	r10, r11, [sp, #136]
	LDRD	r10, r11, [sp, #176]
	EOR	r12, r12, r10
	EOR	lr, lr, r11
	EOR	r10, r10, r2
	EOR	r11, r11, r3
	STRD	r10, r11, [sp, #176]
	STR	r12, [r0, #16]
	STR	lr, [r0, #20]
	/* Calc t[1] */
	LDRD	r2, r3, [r0]
	EOR	r2, r2, lr, LSR #31
	EOR	r3, r3, r12, LSR #31
	EOR	r2, r2, r12, LSL #1
	EOR	r3, r3, lr, LSL #1
	/* XOR t[1] into s[x*5+1] */
	LDRD	r4, r5, [sp, #8]
	LDRD	r6, r7, [sp, #48]
	LDRD	r8, r9, [sp, #88]
	LDRD	r10, r11, [sp, #128]
	LDR	r12, [sp, #168]
	LDR	lr, [sp, #172]
	EOR	r4, r4, r2
	EOR	r5, r5, r3
	EOR	r6, r6, r2
	EOR	r7, r7, r


ClientToken': clientToken,
        'GrantArn': grantArn,
        if (allowedOperations != null)
          'AllowedOperations': allowedOperations.map((e) => e.value).toList(),
        if (grantName != null) 'GrantName': grantName,
        if (options != null) 'Options': options,
        if (sourceVersion != null) 'SourceVersion': sourceVersion,
        if (status != null) 'Status': status.value,
        if (statusReason != null) 'StatusReason': statusReason,
      },
    );

    return CreateGrantVersionResponse.fromJson(jsonResponse.body);
  }

  /// Creates a license.
  ///
  /// May throw [ValidationException].
  /// May throw [InvalidParameterValueException].
  /// May throw [RedirectException].
  /// May throw [AuthorizationException].
  /// May throw [AccessDeniedException].
  /// May throw [RateLimitExceededException].
  /// May throw [ServerInternalException].
  ///
  /// Parameter [beneficiary] :
  /// License beneficiary.
  ///
  /// Parameter [clientToken] :
  /// Unique, case-sensitive identifier that you provide to ensure the
  /// idempotency of the request.
  ///
  /// Parameter [consumptionConfiguration] :
  /// Configuration for consumption of the license. Choose a provisional
  /// configuration for workloads running with continuous connectivity. Choose a
  /// borrow configuration for workloads with offline usage.
  ///
  /// Parameter [entitlements] :
  /// License entitlements.
  ///
  /// Parameter [homeRegion] :
  /// Home Region for the license.
  ///
  /// Parameter [issuer] :
  /// License issuer.
  ///
  /// Parameter [licenseName] :
  /// License name.
  ///
  /// Parameter [productName] :
  /// Product name.
  ///
  /// Parameter [productSKU] :
  /// Product SKU.
  ///
  /// Parameter [validity] :
  /// Date and time range during which the license is valid, in ISO8601-UTC
  /// format.
  ///
  /// Parameter [licenseMetadata] :
  /// Information about the license.
  Future<CreateLicenseResponse> createLicense({
    required String beneficiary,
    required String clientToken,
    required ConsumptionConfiguration consumptionConfiguration,
    required List<Entitlement> entitlements,
    required String homeRegion,
    required Issuer issuer,
    required String licenseName,
    required String productName,
    required String productSKU,
    required DatetimeRange validity,
    List<Metadata>? licenseMetadata,
  }) async {
    final headers = <String, String>{
      'Content-Type': 'application/x-amz-json-1.1',
      'X-Amz-Target': 'AWSLicenseManager.CreateLicense'
    };
    final jsonResponse = await _protocol.send(
      method: 'POST',
      requestUri: '/',
      exceptionFnMap: _exceptionFns,
      // TODO queryParams
      headers: headers,
      payload: {
        'Beneficiary': beneficiary,
        'ClientToken': clientToken,
        'ConsumptionConfiguration': consumptionConfiguration,
        'Entitlements': entitlements,
        'HomeRegion': homeRegion,
        'Issuer': issuer,
        'LicenseName': licenseName,
        'ProductName': productName,
        'ProductSKU': productSKU,
        'Validity': validity,
        if (licenseMetadata != null) 'LicenseMetadata': licenseMetadata,
      },
    );

    return CreateLicenseResponse.fromJson(jsonResponse.body);
  }

  /// Creates a license configuration.
  ///
  /// A license configuration is an abstraction of a customer license agreement
  /// that can be consumed and enforced by License Manager. Components include
  /// specifications for the license type (licensing by instance, socket, CPU,
  /// or vCPU), allowed tenancy


|大廠回族自治縣|DàchǎngHuízúZìzhìxiàn",
    "大厂县|||大廠縣|Dàchǎngxiàn",
    "大厅|||大廳|dàtīng",
    "大建|||大建|dàjiàn",
    "大张挞伐|||大張撻伐|dàzhāngtàfá",
    "大张旗鼓|||大張旗鼓|dàzhāngqígǔ",
    "大张声势|||大張聲勢|dàzhāngshēngshì",
    "大后天|||大後天|dàhòutiān",
    "大后年|||大後年|dàhòunián",
    "大彻大悟|||大徹大悟|dàchèdàwù",
    "大心|||大心|dàxīn",
    "大志|||大志|dàzhì",
    "大忙人|||大忙人|dàmángrén",
    "大快人心|||大快人心|dàkuàirénxīn",
    "大快朵颐|||大快朵頤|dàkuàiduǒyí",
    "大怒|||大怒|dànù",
    "大恭|||大恭|dàgōng",
    "大悟|||大悟|Dàwù",
    "大悟县|||大悟縣|Dàwùxiàn",
    "大悲咒|||大悲咒|Dàbēizhòu",
    "大惑不解|||大惑不解|dàhuòbùjiě",
    "大意|||大意|dàyì",
    "大愚|||大愚|dàyú",
    "大慈恩寺|||大慈恩寺|Dàcí'ēnsì",
    "大庆|||大慶|Dàqìng",
    "大庆市|||大慶市|Dàqìngshì",
    "大憝|||大憝|dàduì",
    "大宪章|||大憲章|DàXiànzhāng",
    "大我|||大我|dàwǒ",
    "大戟科|||大戟科|dàjǐkē",
    "大战|||大戰|dàzhàn",
    "大户|||大戶|dàhù",
    "大手大脚|||大手大腳|dàshǒudàjiǎo",
    "大才小用|||大才小用|dàcáixiǎoyòng",
    "大批|||大批|dàpī",
    "大批特批|||大批特批|dàpītèpī",
    "大投资家|||大投資家|dàtóuzījiā",
    "大抵|||大抵|dàdǐ",
    "大拇哥|||大拇哥|dàmǔgē",
    "大拇指|||大拇指|Dàmuzhǐ",


Sphinx assumes source files to be encoded in UTF-8 by
default; you can change this with the :confval:`source_encoding` config value.

Gotchas
-------

There are some problems one commonly runs into while authoring reST documents:

* **Separation of inline markup:** As said above, inline markup spans must be
  separated from the surrounding text by non-word characters, you have to use a
  backslash-escaped space to get around that.  See `the reference
  <http://docutils.sf.net/docs/ref/rst/restructuredtext.html#inline-markup>`_
  for the details.

* **No nested inline markup:** Something like ``*see :func:`foo`*`` is not
  possible.

.. rubric:: Footnotes

.. [1] When the default domain contains a :rst:dir:`class` directive, this directive
       will be shadowed.  Therefore, Sphinx re-exports it as :rst:dir:`rst-class`.
</textarea></form>

The reStructuredText mode supports one configuration parameter:

verbatim (string)

A name or MIME type of a mode that will be used for highlighting
      verbatim blocks. By default, reStructuredText mode uses uniform color
      for whole block of verbatim text if no mode is given.

If python mode is available,
    it will be used for highlighting blocks containing Python/IPython terminal
    sessions (blocks starting with >>> (for Python) or
    In [num]: (for IPython).

MIME types defined: text/x-rst.

<!doctype html>

    <meta charset="utf-8">
    <title>CodeMirror: sTeX mode</title>
    <link rel="stylesheet" href="../../lib/codemirror.css">

    <link rel="stylesheet" href="../../doc/docs.css">

CodeMirror: sTeX mode

     <form><textarea id="code" name="code">
\begin{module}[id=bbt-size]
\importmodule[balanced-binary-trees]{balanced-binary-trees}
\importmodule[\KWARCslides{dmath/en/cardinality}]{cardinality}

\begin{frame}
  \frametitle{Size Lemma for Balanced Trees}
  \begin{itemize}
  \item
    \begin{assertion}[id=size-lemma,type=lemma]
    Let $G=\tup{V,E}$ be a \termref[cd=binary-trees]{balanced binary tree}
    of \termref[cd=graph-depth,name=vertex-depth]{depth}$n>i$, then the set
     $\defeq{\livar{V}i}{\setst{\inset{v}{V}}{\gdepth{v} = i}}$ of
    \termref[cd=graphs-intro,name=node]{nodes} at
    \termref[cd=graph-depth,name=vertex-depth]{depth} $i$ has
    \termref[cd=cardinality,name=cardinality]{cardinality} $\power2i$.
   \end{assertion}
  \item
    \begin{sproof}[id=size-lemma-pf,proofe


:CTRLC,
    _reserved_3_baud: [u8; 2usize],
    #[doc = "0x0e - USART_EXT Receive Pulse Length"]
    pub rxpl: self::usart_ext::RXPL,
    _reserved5: [u8; 5usize],
    #[doc = "0x14 - USART_EXT Interrupt Enable Clear"]
    pub intenclr: self::usart_ext::INTENCLR,
    _reserved6: [u8; 1usize],
    #[doc = "0x16 - USART_EXT Interrupt Enable Set"]
    pub intenset: self::usart_ext::INTENSET,
    _reserved7: [u8; 1usize],
    #[doc = "0x18 - USART_EXT Interrupt Flag Status and Clear"]
    pub intflag: self::usart_ext::INTFLAG,
    _reserved8: [u8; 1usize],
    #[doc = "0x1a - USART_EXT Status"]
    pub status: self::usart_ext::STATUS,
    #[doc = "0x1c - USART_EXT Synchronization Busy"]
    pub syncbusy: self::usart_ext::SYNCBUSY,
    _reserved10: [u8; 8usize],
    #[doc = "0x28 - USART_EXT Data"]
    pub data: self::usart_ext::DATA,
    _reserved11: [u8; 6usize],
    #[doc = "0x30 - USART_EXT Debug Control"]
    pub dbgctrl: self::usart_ext::DBGCTRL,
}
impl USART_EXT {
    #[doc = "0x0c - USART_EXT Baud Rate"]
    #[inline(always)]
    pub fn baud_usartfp_mode(&self) -> &self::usart_ext::BAUD_USARTFP_MODE {
        unsafe {
            &*(((self as *const Self) as *const u8).add(12usize)
                as *const self::usart_ext::BAUD_USARTFP_MODE)
        }
    }
    #[doc = "0x0c - USART_EXT Baud Rate"]
    #[inline(always)]
    pub fn baud_usartfp_mode_mut(&self) -> &mut self::usart_ext::BAUD_USARTFP_MODE {
        unsafe {
            &mut *(((self as *const Self) as *mut u8).add(12usize)
                as *mut self::usart_ext::BAUD_USARTFP_MODE)
        }
    }
    #[doc = "0x0c - USART_EXT Baud Rate"]
    #[inline(always)]
    pub fn baud_fracfp_mode(&self) -> &self::usart_ext::BAUD_FRACFP_MODE {
        unsafe {
            &*(((self as *const Self) as *const u8).add(12usize)
                as *const self::usart_ext::BAUD_FRACFP_MODE)
        }
    }
    #[doc = "0x0c - USART_EXT Baud Rate"]
    #[inline(always)]
    pub fn baud_fracfp_mode_mut(&self) -> &mut self::usart_ext::BAUD_FRACFP_MODE {
        unsafe {
            &mut *(((self as *const Self) as *mut u8).add(12usize)
                as *mut self::usart_ext::BAUD_FRACFP_MODE)
        }
    }
    #[doc = "0x0c - USART_EXT Baud Rate"]
    #[inline(always)]
    pub fn baud_frac_mode(&self) -> &self::usart_ext::BAUD_FRAC_MODE {
        unsafe {
            &*(((self as *const Self) as *const u8).add(12usize)
                as *const self::usart_ext::BAUD_FRAC_