rena.allocate<Uint32>(sizeOf<Uint32>())..value = $varName$bang.value;');
      o.p('$argumentName.value = ${varName}Ptr.cast();');
      break;
    case TypeCategory.bitfieldType:
      o.p('final ${varName}Ptr = arena.allocate<Uint32>(sizeOf<Uint32>())..value = $varName;');
      o.p('$argumentName.value = ${varName}Ptr.cast();');
      break;
    case TypeCategory.typedArray:
      if (argument.isOptional) {
        o.p('$argumentName.value = $varName?.nativePtr?.cast() ?? nullptr;');
      } else {
        final bang = argument.defaultArgumentValue != null ? '!' : '';
        o.p('$argumentName.value = $varName$bang.nativePtr.cast();');
      }
      break;
  }
}

// A map of enumTypes to prefixes that are different from their type name, and
// can be removed in Dart.
const removePrefixes = <String, String>{
  'KeyModifierMask': 'keyMask',
  'Variant.Type': 'type',
  'Error': 'err',
  'MethodFlags': 'methodFlag',
  'PropertyUsageFlags': 'propertyUsage',
  'Variant.Operator': 'op',
  'Planes': 'plane',
};

// Reserved words that get used as enum names, and should instead
// default back to their original, prefixed names.
final reservedWordEnumNames = [
  'default',
  'const',
  'static',
  'in',
  'index',
  'new',
  'class',
  'continue',
];

Value _transformEnumValues(Value e, String name) {
  final lowerEnumName = name.lowerFirstLetter();
  String originalName = e.name.toLowerCamelCase();
  String transformedName = originalName;
  if (originalName != lowerEnumName && originalName.startsWith(lowerEnumName)) {
    transformedName =
        originalName.replaceFirst(lowerEnumName, '').lowerFirstLetter();
  } else if (removePrefixes.containsKey(name)) {
    final prefix = removePrefixes[name]!;
    transformedName =
        transformedName.replaceFirst(prefix, '').lowerFirstLetter();
  }

  // Don't allow keywords
  if (transformedName == 'int') transformedName = 'integer';
  if (transformedName == 'enum') transformedName = 'enumVal';
  if (reservedWordEnumNames.contains(transformedName)) {
    transformedName = originalName;
  }

  return Value(name: transformedName, value: e.value);
}

extension EnumTransform on BuiltinClassEnum {
  List<Value> transformedValues() {
    return values.map((e) => _transformEnumValues(e, name)).toList();
  }
}

extension EnumTranform on GlobalEnumElement {
  List<Value> transformedValues() {
    return values.map((e) => _transformEnumValues(e, name)).toList();
  }
}

void writeEnum(dynamic godotEnum, String? inClass, CodeSink o) {
  String name;
  List<Value> valueList;
  bool isBitfield = false;
  if (godotEnum is BuiltinClassEnum) {
    name = godotEnum.name;
    valueList = godotEnum.transformedValues();
  } else if (godotEnum is GlobalEnumElement) {
    name = godotEnum.name;
    valueList = godotEnum.transformedValues();
    isBitfield = godotEnum.isBitfield;
  } else {
    throw ArgumentError(
        'Trying to write an enum that is of type ${godotEnum.runtimeType}');
  }

  var enumName = getEnumName(name, inClass);

  o.b('enum $enumName {', () {
    if (isBitfield && valueList.where((e) => e.name == 'none').isEmpty) {
      o.p('none(0),');
    }
    for (int i = 0; i < valueList.length; ++i) {
      final value = valueList[i


/*
 * This file is part of the UCB release of Plan 9. It is subject to the license
 * terms in the LICENSE file found in the top-level directory of this
 * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
 * part of the UCB release of Plan 9, including this file, may be copied,
 * modified, propagated, or distributed except according to the terms contained
 * in the LICENSE file.
 */

typedef struct Addr Addr;
typedef struct Cmd Cmd;
struct Addr
{
	char	type;	/* # (char addr), l (line addr), / ? . $ + - , ; */
	union{
		String	*re;
		Addr	*aleft;		/* left side of , and ; */
	} g;
	Posn	num;
	Addr	*next;			/* or right side of , and ; */
};

#define	are	g.re
#define	left	g.aleft

struct Cmd
{
	Addr	*addr;			/* address (range of text) */
	String	*re;			/* regular expression for e.g. 'x' */
	union{
		Cmd	*cmd;		/* target of x, g, {, etc. */
		String	*text;		/* text of a, c, i; rhs of s */
		Addr	*addr;		/* address for m, t */
	} g;
	Cmd	*next;			/* pointer to next element in {} */
	short	num;
	ushort	flag;			/* whatever */
	ushort	cmdc;			/* command character; 'x' etc. */
};

#define	ccmd	g.cmd
#define	ctext	g.text
#define	caddr	g.addr

typedef struct Cmdtab Cmdtab;
struct Cmdtab
{
	ushort	cmdc;		/* command character */
	uchar	text;		/* takes a textual argument? */
	uchar	regexp;		/* takes a regular expression? */
	uchar	addr;		/* takes an address (m or t)? */
	uchar	defcmd;		/* default command; 0==>none */
	uchar	defaddr;	/* default address */
	uchar	count;		/* takes a count e.g. s2/// */
	char	*token;		/* takes text terminated by one of these */
	int	(*fn)(File*, Cmd*);	/* function to call with parse tree */
};

extern Cmdtab cmdtab[];

enum Defaddr{	/* default addresses */
	aNo,
	aDot,
	aAll,
};

int	nl_cmd(File*, Cmd*), a_cmd(File*, Cmd*), b_cmd(File*, Cmd*);
int	c_cmd(File*, Cmd*), cd_cmd(File*, Cmd*), d_cmd(File*, Cmd*);
int	D_cmd(File*, Cmd*), e_cmd(File*, Cmd*);
int	f_cmd(File*, Cmd*), g_cmd(File*, Cmd*), i_cmd(File*, Cmd*);
int	k_cmd(File*, Cmd*), m_cmd(File*, Cmd*), n_cmd(File*, Cmd*);
int	p_cmd(File*, Cmd*), q_cmd(File*, Cmd*);
int	s_cmd(File*, Cmd*), u_cmd(File*, Cmd*), w_cmd(File*, Cmd*);
int	x_cmd(File*, Cmd*), X_cmd(File*, Cmd*), plan9_cmd(File*, Cmd*);
int	eq_cmd(File*, Cmd*);

String	*getregexp(int);
Addr	*newaddr(void);
Address	address(Addr*, Address, int);
int	cmdexec(File*, Cmd*);


, 보고드립니다~ 작전을 진행할 편대를 짜실 때 저도 고려해주세요. 완전무결하다곤 할 수 없지만 임무 완수 정도라면… 저도 할 수 있을 거예요.",
		battle = "마음껏 싸우세요! 제가 전력으로 서포트 하겠습니다!",
		login = "드디어 만났네요, 지휘관님. 늦지 않게 오늘 일을 시작해봐요.",
		vote = "",
		detail = "딱 맞춰서 오셨네요, 지휘관님. 이 아이를 검사하던 중이었는데, 잠시 도와주실 수 있나요?",
		couple_encourage = {}
	},
	[107291] = {
		touch = "이 파자마는 내가 제일 좋아하는 거야… 너무 유치해보이진 않으려나… 잘 어울린다고? 하하. 먼저 지휘관에게 고맙다고 해야겠네.",
		feeling3 = "",
		upgrade = "",
		expedition = "",
		win_mvp = "",
		home = "다녀왔어? 지휘관… 먼저 좀 쉬어. 내 베개 빌려줄게…",
		mission = "",
		touch2 = "",
		feeling1 = "",
		skill = "",
		drop_descrip = "흐아암…… 지휘관?! 깜짝 놀랐네… 응, 지금 잘 준비… 응, 이 아이와 같이… 잘자…",
		mail = "",
		lose = "",
		propose = "",
		hp_warning = "",
		id = 107291,
		voice_key = 0,
		feeling5 = "일을 할 때나 쉴 때나 모두 지휘관이 곁에 있어… 이것보다 더 행복한 일은 없을거야~ 지휘관, 이 베개 같이 쓰지 않을래?",
		main = "적당한 휴식은 일의 효율을 높여준다구. 지휘관도 휴식을 소홀히 하면 안돼.|미안, 지휘관. 또 졸린 거 같아… 쿨|파자마 파티…? 아하하, 기회


cat,
		T::AccountId,
		BoundedVec<VestingInfo<BalanceOf<T>, T::BlockNumber>, MaxVestingSchedulesGet<T>>,
	>;

	/// Storage version of the pallet.
	///
	/// New networks start with latest version, as determined by the genesis build.
	#[pallet::storage]
	pub(crate) type StorageVersion<T: Config> = StorageValue<_, Releases, ValueQuery>;

	#[pallet::pallet]
	#[pallet::generate_store(pub(super) trait Store)]
	#[pallet::generate_storage_info]
	pub struct Pallet<T>(_);

	#[pallet::genesis_config]
	pub struct GenesisConfig<T: Config> {
		pub vesting: Vec<(T::AccountId, T::BlockNumber, T::BlockNumber, BalanceOf<T>)>,
	}

	#[cfg(feature = "std")]
	impl<T: Config> Default for GenesisConfig<T> {
		fn default() -> Self {
			GenesisConfig { vesting: Default::default() }
		}
	}

	#[pallet::genesis_build]
	impl<T: Config> GenesisBuild<T> for GenesisConfig<T> {
		fn build(&self) {
			use sp_runtime::traits::Saturating;

			// Genesis uses the latest storage version.
			StorageVersion::<T>::put(Releases::V1);

			// Generate initial vesting configuration
			// * who - Account which we are generating vesting configuration for
			// * begin - Block when the account will start to vest
			// * length - Number of blocks from `begin` until fully vested
			// * liquid - Number of units which can be spent before vesting begins
			for &(ref who, begin, length, liquid) in self.vesting.iter() {
				let balance = T::Currency::free_balance(who);
				assert!(!balance.is_zero(), "Currencies must be init'd before vesting");
				// Total genesis `balance` minus `liquid` equals funds locked for vesting
				let locked = balance.saturating_sub(liquid);
				let length_as_balance = T::BlockNumberToBalance::convert(length);
				let per_block = locked / length_as_balance.max(sp_runtime::traits::One::one());
				let vesting_info = VestingInfo::new(locked, per_block, begin);
				if !vesting_info.is_valid() {
					panic!("Invalid VestingInfo params at genesis")
				};

				Vesting::<T>::try_append(who, vesting_info)
					.expect("Too many vesting schedules at genesis.");

				let reasons = WithdrawReasons::TRANSFER | WithdrawReasons::RESERVE;
				T::Currency::set_lock(VESTING_ID, who, locked, reasons);
			}
		}
	}

	#[pallet::event]
	#[pallet::generate_deposit(pub(super) fn deposit_event)]
	#[pallet::metadata(
		T::AccountId = "AccountId", BalanceOf<T> = "Balance", T::BlockNumber = "BlockNumber"
	)]
	pub enum Event<T: Config> {
		/// The amount vested has been updated. This could indicate a change in funds available.
		/// The balance given is the amount which is left unvested (and thus locked).
		/// \[account, unvested\]
		VestingUpdated(T::AccountId, BalanceOf<T>),
		/// An \[account\] has become fully vested.
		VestingCompleted(T::AccountId),
	}

	/// Error for the vesting pallet.
	#[pallet::error]
	pub enum Error<T> {
		/// The account given is not vesting.
		NotVesting,
		/// The account already has `MaxVestingSchedules` count of schedules and thus
		/// cannot add another one. Consider merging existing schedules in order to add another.
		AtMaxVestingSchedules,
		/// Amount being transfe


ew IOreDictListenerEvent() {@Override public void onOreRegistration(OreDictRegistrationContainer aEvent) {
			RM.ae_grinder( 5, aEvent.mStack, OP.dust.mat(MT.S, 1));
		}});
		addListener("gemSaltpeter", new IOreDictListenerEvent() {@Override public void onOreRegistration(OreDictRegistrationContainer aEvent) {
			RM.ae_grinder( 5, aEvent.mStack, OP.dust.mat(MT.KNO3, 1));
		}});
		addListener("ingotCopper", new IOreDictListenerEvent() {@Override public void onOreRegistration(OreDictRegistrationContainer aEvent) {
			RM.ae_grinder(10, aEvent.mStack, OP.dust.mat(MT.Cu, 1));
		}});
		addListener("ingotTin", new IOreDictListenerEvent() {@Override public void onOreRegistration(OreDictRegistrationContainer aEvent) {
			RM.ae_grinder(10, aEvent.mStack, OP.dust.mat(MT.Sn, 1));
		}});
		addListener("ingotLead", new IOreDictListenerEvent() {@Override public void onOreRegistration(OreDictRegistrationContainer aEvent) {
			RM.ae_grinder(10, aEvent.mStack, OP.dust.mat(MT.Pb, 1));
		}});
		addListener("ingotBismuth", new IOreDictListenerEvent() {@Override public void onOreRegistration(OreDictRegistrationContainer aEvent) {
			RM.ae_grinder(10, aEvent.mStack, OP.dust.mat(MT.Bi, 1));
		}});
		addListener("ingotZinc", new IOreDictListenerEvent() {@Override public void onOreRegistration(OreDictRegistrationContainer aEvent) {
			RM.ae_grinder(10, aEvent.mStack, OP.dust.mat(MT.Zn, 1));
		}});
		addListener("ingotBrass", new IOreDictListenerEvent() {@Override public void onOreRegistration(OreDictRegistrationContainer aEvent) {
			RM.ae_grinder(10, aEvent.mStack, OP.dust.mat(MT.Brass, 1));
		}});
		addListener("ingotBronze", new IOreDictListenerEvent() {@Override public void onOreRegistration(OreDictRegistrationContainer aEvent) {
			RM.ae_grinder(20, aEvent.mStack, OP.dust.mat(MT.Bronze, 1));
		}});
		addListener("ingotGold", new IOreDictListenerEvent() {@Override public void onOreRegistration(OreDictRegistrationContainer aEvent) {
			RM.ae_grinder(20, aEvent.mStack, OP.dust.mat(MT.Au, 1));
		}});
		addListener("ingotPlatinum", new IOreDictListenerEvent() {@Override public void onOreRegistration(OreDictRegistrationContainer aEvent) {
			RM.ae_grinder(20, aEvent.mStack, OP.dust.mat(MT.Pt, 1));
		}});
		addListener("ingotNickel", new IOreDictListenerEvent() {@Override public void onOreRegistration(OreDictRegistrationContainer aEvent) {
			RM.ae_grinder(20, aEvent.mStack, OP.dust.mat(MT.Ni, 1));
		}});
		addListener("ingotIron", new IOreDictListenerEvent() {@Override public void onOreRegistration(OreDictRegistrationContainer aEvent) {
			RM.ae_grinder(20, aEvent.mStack, OP.dust.mat(MT.Fe, 1));
		}});
		addListener(DYE_OREDICTS_LENS[DYE_INDEX_White], new IOreDictListenerEvent() {@Override public void onOreRegistration(OreDictRegistrationContainer aEvent) {
			for (OreDictMaterial


 UNiagaraDataInterfaceArrayFloat4");
static_assert(offsetof(UNiagaraDataInterfaceArrayFloat4, FloatData) == 0x000050, "Member 'UNiagaraDataInterfaceArrayFloat4::FloatData' has a wrong offset!");

// Class Niagara.NiagaraDataInterfaceArrayColor
// 0x0010 (0x0060 - 0x0050)
class UNiagaraDataInterfaceArrayColor final : public UNiagaraDataInterfaceArray
{
public:
	TArray<struct FLinearColor>                   ColorData;                                         // 0x0050(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NiagaraDataInterfaceArrayColor">();
	}
	static class UNiagaraDataInterfaceArrayColor* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNiagaraDataInterfaceArrayColor>();
	}
};
static_assert(alignof(UNiagaraDataInterfaceArrayColor) == 0x000008, "Wrong alignment on UNiagaraDataInterfaceArrayColor");
static_assert(sizeof(UNiagaraDataInterfaceArrayColor) == 0x000060, "Wrong size on UNiagaraDataInterfaceArrayColor");
static_assert(offsetof(UNiagaraDataInterfaceArrayColor, ColorData) == 0x000050, "Member 'UNiagaraDataInterfaceArrayColor::ColorData' has a wrong offset!");

// Class Niagara.NiagaraDataInterfaceArrayQuat
// 0x0010 (0x0060 - 0x0050)
class UNiagaraDataInterfaceArrayQuat final : public UNiagaraDataInterfaceArray
{
public:
	TArray<struct FQuat>                          QuatData;                                          // 0x0050(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NiagaraDataInterfaceArrayQuat">();
	}
	static class UNiagaraDataInterfaceArrayQuat* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNiagaraDataInterfaceArrayQuat>();
	}
};
static_assert(alignof(UNiagaraDataInterfaceArrayQuat) == 0x000008, "Wrong alignment on UNiagaraDataInterfaceArrayQuat");
static_assert(sizeof(UNiagaraDataInterfaceArrayQuat) == 0x000060, "Wrong size on UNiagaraDataInterfaceArrayQuat");
static_assert(offsetof(UNiagaraDataInterfaceArrayQuat, QuatData) == 0x000050, "Member 'UNiagaraDataInterfaceArrayQuat::QuatData' has a wrong offset!");

// Class Niagara.NiagaraDataInterfaceArrayFunctionLibrary
// 0x0000 (0x0028 - 0x0028)
class UNiagaraDataInterfaceArrayFunctionLibrary final : public UBlueprintFunctionLibrary
{
public:
	static TArray<bool> GetNiagaraArrayBool(class UNiagaraComponent* NiagaraSystem, class FName OverrideName);
	static bool GetNiagaraArrayBoolValue(class UNiagaraComponent* NiagaraSystem, class FName OverrideName, int32 Index_0);
	static TArray<struct FLinearColor> GetNiagaraArrayColor(class UNiagaraComponent* NiagaraSystem, class FName OverrideName);
	static struct FLinearColor GetNiagaraArrayColorValue(class UNiagaraComponent* NiagaraSystem, class FName OverrideName, int32 Index_0);
	static TArray<float> GetNiagaraArrayFloat(class UNiagaraComponent* NiagaraSystem, class FName OverrideName);
	static float GetNiagaraArrayFloatValue(class UNiagaraComponent* NiagaraSystem, class FName OverrideName, int32 Index_0);
	static TArray<int32> GetNiagaraArrayInt32(class UNiagaraComponent* NiagaraSystem, class FName OverrideName);
	static int32 GetNiagaraArrayInt32Value(class UNiagaraComponent* NiagaraSystem, class FName OverrideName, int32 Index_0);
	static TArray<struct FQuat> GetNiagaraArrayQuat(class UNiagaraComponent* NiagaraSystem, class FName OverrideName);
	static struct FQuat GetNiagaraArrayQuatValue(class UNiagaraComponent* Niagar


a){this.finalDate=b(a)},update:function(){if(0===this.$el.closest("html").length)return void this.remove();var b,c=void 0!==a._data(this.el,"events"),d=new Date;b=this.finalDate.getTime()-d.getTime(),b=Math.ceil(b/1e3),b=!this.options.elapse&&b<0?0:Math.abs(b),this.totalSecsLeft!==b&&c&&(this.totalSecsLeft=b,this.elapsed=d>=this.finalDate,this.offset={seconds:this.totalSecsLeft%60,minutes:Math.floor(this.totalSecsLeft/60)%60,hours:Math.floor(this.totalSecsLeft/60/60)%24,days:Math.floor(this.totalSecsLeft/60/60/24)%7,daysToWeek:Math.floor(this.totalSecsLeft/60/60/24)%7,daysToMonth:Math.floor(this.totalSecsLeft/60/60/24%30.4368),weeks:Math.floor(this.totalSecsLeft/60/60/24/7),weeksToMonth:Math.floor(this.totalSecsLeft/60/60/24/7)%4,months:Math.floor(this.totalSecsLeft/60/60/24/30.4368),years:Math.abs(this.finalDate.getFullYear()-d.getFullYear()),totalDays:Math.floor(this.totalSecsLeft/60/60/24),totalHours:Math.floor(this.totalSecsLeft/60/60),totalMinutes:Math.floor(this.totalSecsLeft/60),totalSeconds:this.totalSecsLeft},this.options.elapse||0!==this.totalSecsLeft?this.dispatchEvent("update"):(this.stop(),this.dispatchEvent("finish")))},dispatchEvent:function(b){var c=a.Event(b+".countdown");c.finalDate=this.finalDate,c.elapsed=this.elapsed,c.offset=a.extend({},this.offset),c.strftime=d(this.offset),this.$el.trigger(c)}}),a.fn.countdown=function(){var b=Array.prototype.slice.call(arguments,0);return this.each(function(){var c=a(this).data("countdown-instance");if(void 0!==c){var d=f[c],e=b[0];j.prototype.hasOwnProperty(e)?d[e].apply(d,b.slice(1)):null===String(e).match(/^[$A-Z_][0-9A-Z_$]*$/i)?(d.setFinalDate.call(d,e),d.start()):a.error("Method %s does not exist on jQuery.countdown".replace(/\%s/gi,e))}else new j(this,b[0],b[1])})}});

/* JQuery.nicescroll 3.6.8
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- */

/* jquery.nicescroll 3.6.8 InuYaksa*2015 MIT http://nicescroll.areaaperta.com */(function(f){"function"===typeof define&&define.amd?define(["jquery"],f):"object"===typeof exports?module.exports=f(require("jquery")):f(jQuery)})(function(f){var B=!1,F=!1,O=0,P=2E3,A=0,J=["webkit","ms","moz","o"],v=window.requestAnimationFrame||!1,w=window.cancelAnimationFrame||!1;if(!v)for(var Q in J){var G=J[Q];if(v=window[G+"RequestAnimationFrame"]){w=window[G+"CancelAnimationFrame"]||window[G+"CancelRequestAnimationFrame"];break}}var x=window.MutationObserver||window.WebKitMutationObserver||
!1,K={zindex:"auto",cursoropacitymin:0,cursoropacitymax:1,cursorcolor:"#424242",cursorwidth:"


    );
private:
    // -----------------------------------------------------------------------
    // Unimplemented constructors and operators
    // -----------------------------------------------------------------------
    DurationDatatypeValidator(const DurationDatatypeValidator &);
    DurationDatatypeValidator& operator = (const  DurationDatatypeValidator&);

};

XERCES_CPP_NAMESPACE_END

#endif

/**
  * End of file DurationDatatypeValidator.hpp
  */

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */

/*
 * $Id: DatatypeValidatorFactory.cpp 932887 2010-04-11 13:04:59Z borisk $
 */

// ---------------------------------------------------------------------------
//  Includes
// ---------------------------------------------------------------------------
#include <xercesc/validators/datatype/DatatypeValidatorFactory.hpp>
#include <xercesc/validators/schema/SchemaSymbols.hpp>
#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/util/Janitor.hpp>
#include <xercesc/validators/datatype/StringDatatypeValidator.hpp>
#include <xercesc/validators/datatype/BooleanDatatypeValidator.hpp>
#include <xercesc/validators/datatype/DecimalDatatypeValidator.hpp>
#include <xercesc/validators/datatype/HexBinaryDatatypeValidator.hpp>
#include <xercesc/validators/datatype/Base64BinaryDatatypeValidator.hpp>
#include <xercesc/validators/datatype/IDDatatypeValidator.hpp>
#include <xercesc/validators/datatype/IDREFDatatypeValidator.hpp>
#include <xercesc/validators/datatype/NOTATIONDatatypeValidator.hpp>
#include <xercesc/validators/datatype/ENTITYDatatypeValidator.hpp>
#include <xercesc/validators/datatype/QNameDatatypeValidator.hpp>
#include <xercesc/validators/datatype/NameDatatypeValidator.hpp>
#include <xercesc/validators/datatype/NCNameDatatypeValidator.hpp>
#include <xercesc/validators/datatype/ListDatatypeValidator.hpp>
#include <xercesc/validators/datatype/UnionDatatypeValidator.hpp>
#include <xercesc/validators/datatype/DoubleDatatypeValidator.hpp>
#include <xercesc/validators/datatype/FloatDatatypeValidator.hpp>
#include <xercesc/validators/datatype/AnyURIDatatypeValidator.hpp>
#include <xercesc/validators/datatype/AnySimpleTypeDatatypeValidator.hpp>
#include <xercesc/validators/datatype/DateTimeDatatypeValidator.hpp>
#include <xercesc/validators/datatype/DateDatatypeValidator.hpp>
#include <xercesc/validators/datatype/TimeDatatypeValidator.hpp>
#include <xercesc/validators/datatype/DayDatatypeValidator.hpp>
#include <xercesc/validators/datatype/MonthDatatypeValidator.hpp>
#include <xercesc/validators/datatype/MonthDayDatatypeValidator.hpp>
#include <xercesc/validators/datatype/YearDatatypeValidator.hpp>
#include <xercesc/validators/datatype/YearMonthDatatypeValidator.hpp>
#include <xercesc/validators/datatype/DurationDatatypeValidator.hpp>
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/XMLInitializer.hpp>

#include <xercesc/internal/XTemplateSerializer.hpp>

XERCES_CPP_NAMESPACE_BEGIN


art',
          },
          {
            'name': 'String',
            'qualifiedName': 'dart:core.String',
            'href': 'dart-core/String-class.html',
            'kind': 3,
            'overriddenDepth': 0,
            'packageName': 'Dart',
            'enclosedBy': {'name': 'dart:core', 'kind': 8},
          },
          {
            'name': 'substring',
            'qualifiedName': 'dart:core.String.substring',
            'href': 'dart-core/String/substring.html',
            'kind': 9,
            'overriddenDepth': 0,
            'packageName': 'Dart',
            'enclosedBy': {'name': 'String', 'kind': 3},
          },
          {
            // fake method for checking the package name matches
            'name': 'stringutils',
            'qualifiedName': 'dart:core.String.stringutils',
            'href': 'dart-core/String/stringutils.html',
            'kind': 9,
            'overriddenDepth': 0,
            'packageName': 'Dart',
            'enclosedBy': {'name': 'String', 'kind': 3},
          },
        ]),
        flutterIndex: DartdocIndex([]),
      ),
    );

    test('non-text ranking', () async {
      final results = await combiner.search(
        ServiceSearchQuery.parse(order: SearchOrder.downloads),
      );
      expect(json.decode(json.encode(results.toJson())), {
        'timestamp': isNotNull,
        'totalCount': 1,
        'sdkLibraryHits': [],
        'packageHits': [
          {'package': 'stringutils', 'score': 4},
        ],
      });
    });

    test('no actual text query', () async {
      final results = await combiner.search(
        ServiceSearchQuery.parse(query: 'package:s'),
      );
      expect(json.decode(json.encode(results.toJson())), {
        'timestamp': isNotNull,
        'totalCount': 1,
        'sdkLibraryHits': [],
        'packageHits': [
          {'package': 'stringutils', 'score': closeTo(0.85, 0.01)},
        ],
      });
    });

    test('search: substring', () async {
      final results = await combiner.search(
        ServiceSearchQuery.parse(query: 'substring'),
      );
      expect(json.decode(json.encode(results.toJson())), {
        'timestamp': isNotNull,
        'totalCount': 1,
        'sdkLibraryHits': [
          {
            'sdk': 'dart',
            'library': 'dart:core',
            'url': contains('dart-core-library.html'),
            'score': closeTo(0.98, 0.01),
            'apiPages': [
              {
                'path': 'dart-core/String/substring.html',
                'url': contains('substring.html'),
              },
            ],
          },
        ],
        'packageHits': [
          {'package': 'stringutils', 'score': closeTo(0.67, 0.01)},
        ],
      });
    });
  });
}
// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'dart:convert';

import 'package:_pub_shared/search/search_form.dart';
import 'package:pub_dev/search/mem_index.dart';
import 'package:pub_dev/search/search_service.dart';
import 'package:test/test.dart';

void main() {
  group('lombok', () {
    late InMemoryPackageIndex index;

    setUpAll(() async {
      index = InMemoryPackageIndex(
        documents: [PackageDocument(package: 'lombok', version: '1.0.0')],
      );
    });

    test('lombock', () async {
      final PackageSearchResult result = index.


i 2017
//  Use, modification and distribution are subject to 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).
//
//  See http://www.boost.org/libs/type_traits for most recent version including documentation.

#ifndef BOOST_TT_IS_VIRTUAL_BASE_OF_HPP_INCLUDED
#define BOOST_TT_IS_VIRTUAL_BASE_OF_HPP_INCLUDED

#include <boost/type_traits/is_base_of.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/make_void.hpp>
#include <utility>

namespace boost {
   namespace detail {

#ifdef BOOST_MSVC
#pragma warning( push )
#pragma warning( disable : 4584 4250 4594)
#elif defined(__GNUC__) && (__GNUC__ >= 4)
#pragma GCC system_header
#endif

#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !defined(BOOST_NO_CXX11_NULLPTR) && !BOOST_WORKAROUND(BOOST_GCC, < 40800)

      // Implementation based on the standard's rules of explicit type conversions.
      // A pointer to an object of *derived* class type may be explicitly converted to a pointer to an *unambiguous* *base* class type.
      // A pointer to an object of an *unambiguous* *non-virtual* *base* class type may be explicitly converted to a pointer of a *derived* class type.
      // Therefore Derived has a virtual base Base if and only if
      //   (1) a Derived* can be converted to Base* (so the base class is unambiguous, which comes necessarily from virtual inheritance)
      //   (2) a Base* cannot be converted to Derived* (so the base class is either ambiguous or virtual)
      // With both conditions true, Base must be a virtual base of Derived.
      // The "is_base_of" is only needed so the compiler can (but is not required to) error out if the types are incomplete.
      // This is in league with the the expected behaviour.

      template<class T, class U>
      constexpr bool is_virtual_base_impl(...) { return true; }

      // C-style casts have the power to ignore inheritance visibility while still act as a static_cast.
      // They can also fall back to the behaviour of reinterpret_cast, which allows is_virtual_base_of to work on non-class types too.
      // Note that because we are casting pointers there can be no user-defined operators to interfere.
      template<class T, class U,
         typename boost::make_void<decltype((U*)(std::declval<T*>()))>::type* =
         nullptr>
         constexpr bool is_virtual_base_impl(int) { return false; }

   } // namespace detail

   template<class T, class U>
   struct is_virtual_base_of : public
      boost::integral_constant<
      bool,
      boost::is_base_of<T, U>::value &&
      detail::is_virtual_base_impl<T, U>(0) &&
      !detail::is_virtual_base_impl<U, T>(0)
      > {};

#else

   template<typename Base, typename Derived, typename tag>
   struct is_virtual_base_of_impl
   {
      BOOST_STATIC_CONSTANT(bool, value = false);
   };

   template<typename Base, typename Derived>
   struct is_virtual_base_of_impl<Base, Derived, true_type>
   {
      union max_align
      {
         unsigned u;
         unsigned long ul;
         void* v;
         double d;
         long double ld;
#ifndef BOOST_NO_LONG_LONG
         long long ll;
#endif
      };
#ifdef __BORLANDC__
      struct boost_type_traits_internal_struct_X : public virtual Derived, public virtual Base
      {
         boost_type_


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

#ifndef _LOS_SORTLINK_PRI_H
#define _LOS_SORTLINK_PRI_H

#include "los_typedef.h"
#include "los_list.h"
#include "los_spinlock.h"

#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif /* __cplusplus */
#endif /* __cplusplus */

/**
 * @brief 排序链表节点结构体
 * @details 用于构建有序链表的节点，存储响应时间及CPU亲和性信息
 * @attention 该结构体需嵌入到用户数据结构中使用，通过sortLinkNode接入排序链表
 */
typedef struct {
    LOS_DL_LIST sortLinkNode;       /* 双向链表节点，用于接入排序链表 */
    UINT64      responseTime;       /* 响应时间戳（单位：系统滴答数），用于链表排序 */
#ifdef LOSCFG_KERNEL_SMP
    UINT32      cpuid;              /* CPU核心ID，仅SMP配置有效，用于指定任务运行的CPU */
#endif
} SortLinkList;

/**
 * @brief 排序链表属性结构体
 * @details 管理排序链表的元数据，包括链表头、节点数量及同步锁
 * @core 提供基于响应时间的有序链表管理能力，支持高效插入和查询操作
 */
typedef struct {
    LOS_DL_LIST sortLink;           /* 排序链表头，所有节点按responseTime升序排列 */
    UINT32      nodeNum;            /* 链表节点数量，记录当前链表中的节点总数 */
    SPIN_LOCK_S spinLock;           /* 排序链表自旋锁，用于多线程安全访问（如软件定时器链表） */
} SortLinkAttribute;

/**
 * @brief 无效的排序链表时间值
 * @details 表示排序链表节点的无效时间戳，用于标记未使用或已删除的节点
 * @note 实际值为UINT64_MAX（十进制：18446744073709551615）
 */
#define OS_SORT_LINK_INVALID_TIME ((UINT64)-1)

/**
 * @brief 设置排序链表节点的响应时间
 * @details 将排序链表节点的responseTime字段设置为指定值
 * @param[in,out] sortList 指向SortLinkList结构体的指针
 * @param[in] value 要设置的响应时间值（单位：系统滴答数）
 * @note 宏内部会将sortList强制转换为SortLinkList*类型
 */
#define SET_SORTLIST_VALUE(sortList, value) (((SortLinkList *)(sortList))->responseTime = (value))

/**
 * @brief 获取排序链表节点的响应时间
 * @details 返回排序链表节点的responseTime字段值
 * @param[in] sortList 指向SortLinkList结构体的指针
 * @return UINT64 - 节点的响应时间值（单位：系统滴答数）
 * @note 宏内部会将sortList强制转换为SortLinkList*类型
 */
#define GET_SORTLIST_VALUE(sortList) (((SortLinkList *)(sortList))->responseTime)

/**
 * @brief 从排序链表中删除节点
 * @details 将指定节点从排序链表中移除，并标记为无效时间
 * @param[in,out] sortLinkHeader 排序链表属性结构体指针
 * @param[in,out] sortList 要删除的排序链表节点指针
 * @note 调用前需确保节点已在链表中，删除后节点数量自动减1
 */
STATIC INLINE VOID OsDeleteNodeSortLink(SortLinkAttribute *sortLinkHeader, SortLinkList *sortList)
{
    LOS_ListDelete(&sortList->sortLinkNode); /* 从双向链表中删除当前节点 */
    SET_SORTLIST_VALUE(sortList, OS_SORT_LINK_INVALID_TIME); /* 将节点时间标记为无效 */
    sortLinkHeader->nodeNum--; /* 链表节点数量减1 */
}

/**
 * @brief 获取排序链表中下一个到期时间
 * @details 计算并返回链表中下一个节点的到期时间，考虑系统当前时间和滴答精度
 * @param[in] sortHeader 排序链表属性结构体指针
 * @param[in] startTime 当前系统时间（单位：系统滴答数）
 * @param[in] tickPrecision 系统滴答精度（单位：系统滴答数）
 * @return UINT64 - 下一个到期时间（单位：系统滴答数），无效返回OS_SORT_LINK_INVALID_TIME - tickPrecision
 * @note 函数内部通过自旋锁保证线程安全
 */
STATIC INLINE UINT64 OsGetSortLinkNextExpireTime(SortLinkAttribute *sortHeader, UINT64 startTime, UINT32 tickPrecision)
{
    LOS_DL_LIST *head = &sortHeader->sortLink; /* 获取链表头指针 */
    LOS_DL_LIST *list = head->pstNext; /* 获取第一个节点指针 */

    LOS_SpinLock(&sortHeader->spinLock); /* 加自旋锁，保护链表访问 */
    if (LOS_ListEmpty(head)) {


        udm.name.sprnt("_bytes_%" FMT_64 "x", last/8);
        udm.offset = last;
        udm.clr_baseclass();
        udm.clr_virtbase();
      }
      else
      { // we do not need this member
        udt->erase(udt->begin()+i);
        --i;
        continue;
      }
    }
    if ( udtKind != UdtUnion )
      last = udm.end();
  }

  type_t bt = udt->is_union ? BTF_UNION : BTF_STRUCT;
  udt_type_data_t tinfo_udt;
  udt->convert_to_tinfo_udt(&tinfo_udt);
  if ( !out->create_udt(tinfo_udt, bt) )
    return cvt_failed;
  if ( !out->calc_udt_aligns(SUDT_GAPS|SUDT_UNEX) )
  {
    dump_pdb_udt(*udt, udt_name);
    deb(IDA_DEBUG_DBGINFO, "PDB: Failed to calculate struct '%s' member alignments\n", udt_name != nullptr ? udt_name : "");
#if defined(TESTABLE_BUILD) && !defined(__FUZZER__)
    QASSERT(30380, !inf_test_mode() && out->get_size() == BADSIZE);
#endif
    ask_for_feedback("Failed to calculate struct member alignments");
  }
  return cvt_ok;
}

//----------------------------------------------------------------------
// is the return type complex?
// if so, a pointer to return value will be passed as a hidden parameter
bool til_builder_t::is_complex_return(pdb_sym_t &sym) const
{
  pdb_sym_t *pType = pdb_access->create_sym();
  pdb_sym_janitor_t janitor_pType(pType);
  bool complex = false;
  if ( sym.get_type(pType) == S_OK )
  {
    DWORD tag = 0;
    complex = pType->get_symTag(&tag) == S_OK && tag == SymTagUDT;
    if ( complex )
    {
      ULONGLONG size;
      complex = pType->get_length(&size) == S_OK && size > 8;
    }
    if ( !complex && tag == SymTagUDT )
    {
      // we've got a small UDT which possibly fits into a register (or two)
      // but it has to be a POD for that, i.e. should have no constructor or assignment operators
      BOOL b;
      if ( (pType->get_constructor          (&b) == S_OK) && b
        || (pType->get_hasAssignmentOperator(&b) == S_OK) && b
        || (pType->get_hasCastOperator      (&b) == S_OK) && b )
        complex = true;
    }
  }
  return complex;
}

//----------------------------------------------------------------------------
bool til_builder_t::is_unnamed_tag_typedef(const tinfo_t &tif) const
{
  uint32 id = tif.get_ordinal();
  if ( id == 0 )
    return false;

  return unnamed_types.find(id) != unnamed_types.end();
}

//----------------------------------------------------------------------
// borland does not like this structure to be defined inside a function.
// this is the only reason why it is in the file scope.
struct this_seeker_t : public pdb_access_t::children_visitor_t
{
  funcarg_t thisarg;
  til_builder_t *tb;
  bool found;
  virtual HRESULT visit_child(pdb_sym_t &sym) override
  {
    DWORD dwDataKind, locType;
    if ( sym.get_dataKind(&dwDataKind) == S_OK


.
 *
 * @copyright
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

    .code64
    .intel_syntax noprefix

    .globl  intrinsic_assert
    .type   intrinsic_assert, @function
intrinsic_assert:

    int 3

    .size intrinsic_assert, .-intrinsic_assert


cs/Glossary/WebP) 画像をサポートしました ([Firefox バグ 1294490](https://bugzil.la/1294490))。
  - また、特定の状況でブラウザー間の互換性を向上するために、WebP の MIMEType (`image/webp`) を HTML ファイルの {{httpheader("Accept")}} 標準 HTTP 要求ヘッダーに追加しました ([Firefox バグ 1507691](https://bugzil.la/1507691))。

- Windows で、AV1 コーデックをデフォルトでサポートしました ([Firefox バグ 1452146](https://bugzil.la/1452146))。

## アドオン開発者向けの変更

### API の変更

#### タブ

- {{WebExtAPIRef("tabs", "tabs API", "", "1")}} を、タブサクセサーをサポートするように強化しました。タブがサクセサーを持つことができ、サクセサーはタブが閉じられたときにアクティブになるタブの ID です ([Firefox バグ 1500479](https://bugzil.la/1500479)。詳しくは [this blog post](https://qiita.com/piroor/items/ea7e727735631c45a366) をご覧ください)。特に、以下の値です:
  - {{WebExtAPIRef("tabs.Tab")}} 型が `successorId` プロパティを持つようになりました。これは、タブのサクセサーの ID を登録および取得するために使用できます。
  - {{WebExtAPIRef("tabs.onActivated")}} イベントリスナーのコールバックで、新しい引数 `previousTabId` を使用できます。これは、以前アクティブであったタブがまだ開かれていれば、その ID が入ります。
  - {{WebExtAPIRef("tabs.update()")}} 関数の `updateProperties` オブジェクトに、新しい省略可能のプロパティ`successorTabId` を追加しました。ID を更新するために使用できます。
  - `successorTabId` は、{{WebExtAPIRef("tabs.get()")}} や {{WebExtAPIRef("tabs.query()")}} といった関数でも返ります。
  - 新たに `tabs.moveInSuccession()` で、タブサクセサーをまとめて操作できます。

### Manifest の変更

_変更なし。_

### その他

- [Webextension themes](/ja/docs/Mozilla/Add-ons/WebExtensions/manifest.json/theme) の `headerURL`/`theme_frame` プロパティを、Android 版 Firefox でサポートしました ([Firefox バグ 1429488](https://bugzil.la/1429488))。

## 関連情報

- Hacks の関連記事: [Firefox 65: WebP support, Flexbox Inspector, new tooling & platform updates](https://hacks.mozilla.org/2019/01/firefox-65-webp-flexbox-inspector-new-tooling/)

## 旧バージョン

{{Firefox_for_developers(65)}}
---
title: Firefox 37 for developers
slug: Mozilla/Firefox/Releases/37
---

Firefox 37 は、米国時間 2015 年 3 月 31 日にリリースされました。このページでは、開発者に影響する Firefox 37 の変更点をまとめています。

## ウェブ開発者向


 = "6")]
        BinaryData(::prost::alloc::vec::Vec<u8>),
        #[prost(string, tag = "7")]
        TextData(::prost::alloc::string::String),
        #[prost(message, tag = "8")]
        ProtoData(::prost_types::Any),
    }
}
//*
// CloudEvent Protobuf Batch Format
//

#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloudEventBatch {
    #[prost(message, repeated, tag = "1")]
    pub events: ::prost::alloc::vec::Vec<CloudEvent>,
}
use pyo3::prelude::*;
use tantivy as tv;
use crate::{
    to_pyerr,
};

/// Tantivy schema.
///
/// The schema is very strict. To build the schema the `SchemaBuilder` class is
/// provided.
#[pyclass]
pub(crate) struct Snippet {
    pub(crate) inner: tv::Snippet,
}

#[pyclass]
pub(crate) struct Range {
    #[pyo3(get)]
    start: usize,
    #[pyo3(get)]
    end: usize
}

#[pymethods]
impl Snippet {
    pub fn to_html(&self) -> PyResult<String> {
        Ok(self.inner.to_html())
    }

    pub fn highlighted(&self) -> Vec<Range> {
        let highlighted =  self.inner.highlighted();
        let results = highlighted.iter().map(|r| Range { start: r.start, end: r.end }).collect::<Vec<_>>();
        results
    }
}

#[pyclass]
pub(crate) struct SnippetGenerator {
    pub(crate) field_name: String,
    pub(crate) inner: tv::SnippetGenerator,
}

#[pymethods]
impl SnippetGenerator {
    #[staticmethod]
    pub fn create(
        searcher: &crate::Searcher,
        query: &crate::Query,
        schema: &crate::Schema,
        field_name: &str
    ) -> PyResult<SnippetGenerator> {
        let field = schema.inner.get_field(field_name).ok_or("field not found").map_err(to_pyerr)?;
        let generator = tv::SnippetGenerator::create(&*searcher.inner, query.get(), field).map_err(to_pyerr)?;

        return Ok(SnippetGenerator { field_name: field_name.to_string(), inner: generator });
    }

    pub fn snippet_from_doc(&self, doc: &crate::Document) -> crate::Snippet {
        let text: String = doc
            .iter_values_for_field(&self.field_name)
            .flat_map(tv::schema::Value::text)
            .collect::<Vec<&str>>()
            .join(" ");

        let result = self.inner.snippet(&text);
        Snippet { inner: result }
    }
}
/*
 * The Jira Cloud platform REST API
 *
 * Jira Cloud platform REST API documentation
 *
 * The version of the OpenAPI document: 1001.0.0-SNAPSHOT
 * Contact: <EMAIL>
 * Generated by: https://openapi-generator.tech
 */

/// CreateCustomFieldContext : The details of a created custom field context.

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateCustomFieldContext {
    /// The ID of the context.
    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    /// The name of the context.
    #[serde(rename = "name")]
    pub name: String,
    /// The description of the context.
    #[serde(rename = "description", skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// The list of proje


�制有两种：共享内存 & 消息传递

在共享内存的并发模型里，线程之间共享程序的公共状态，通过「读-写内存中的共享状态」来隐式进行通信。在消息传递的并发模型里，线程之间没有公共状态，必须通过明确的「发送消息」来显式进行通信

同步是指程序中用于控制不同线程之间操作发生相对顺序的机制。在共享内存并发模型里，同步是显式进行的。程序员必须显示指定某个方法或某段代码需要在线程之间互斥进行。在消息传递的并发模型里，由于消息的发送必须在消息的接受之前，因此同步是隐式进行的

Java 采用的是共享内存的并发模型，Java 线程之间的通信总是隐式进行的，整个通信过程对程序员完全透明。如果编写多线程的 Java 程序员不理解隐式进行的线程之间通信的工作机制，很可能会遇到各种各样奇怪的内存可见性问题

Java 内存模型的抽象

在 Java 中，所有实例域、静态域和数组元素存储在堆内存中，堆内存在线程之间共享。局部变量、方法定义参数和异常处理器参数不会在线程之间共享，它们不会有内存可见性问题，也不受内存模型的影响

Java 线程之间的通信由 Java 内存模型 (JMM) 控制，JMM 决定一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看，JMM 定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存 (Main Memory) 中，每个线程都有一个私有的本地内存 (Local Memory)，本地内存中存储了该线程读/写共享变量的副本。本地内存是 JMM 的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化

Java 内存模型的抽象示意图如下：

<img src="https://cdn.jsdelivr.net/gh/LFool/image-hosting@master/20221007/1454081665125648WHjecv1.svg" referre


/* SPDX-License-Identifier: GPL-2.0-only */

#include <console/console.h>
#include <cpu/cpu.h>
#include <cpu/intel/cpu_ids.h>
#include <cpu/intel/microcode.h>
#include <cpu/x86/msr.h>
#include <cpu/x86/name.h>
#include <device/pci.h>
#include <device/pci_ids.h>
#include <device/pci_ops.h>
#include <soc/pci_devs.h>
#include <soc/romstage.h>

static struct {
	u32 cpuid;
	const char *name;
} cpu_table[] = {
	{ CPUID_APOLLOLAKE_A0, "Apollolake A0" },
	{ CPUID_APOLLOLAKE_B0, "Apollolake B0" },
	{ CPUID_APOLLOLAKE_E0, "Apollolake E0" },
	{ CPUID_GLK_A0, "Geminilake A0" },
	{ CPUID_GLK_B0, "Geminilake B0" },
	{ CPUID_GLK_R0, "Geminilake R0" },
};

static struct {
	u16 mchid;
	const char *name;
} mch_table[] = {
	{ PCI_DID_INTEL_GLK_NB, "Geminilake" },
	{ PCI_DID_INTEL_APL_NB, "Apollolake" },
};

static struct {
	u16 lpcid;
	const char *name;
} pch_table[] = {
	{ PCI_DID_INTEL_APL_LPC, "Apollolake" },
	{ PCI_DID_INTEL_GLK_LPC, "Geminilake" },
	{ PCI_DID_INTEL_GLK_ESPI, "Geminilake" },
};

static struct {
	u16 igdid;
	const char *name;
} igd_table[] = {
	{ PCI_DID_INTEL_APL_IGD_HD_505, "Apollolake HD 505" },
	{ PCI_DID_INTEL_APL_IGD_HD_500, "Apollolake HD 500" },
	{ PCI_DID_INTEL_GLK_IGD, "Geminilake" },
	{ PCI_DID_INTEL_GLK_IGD_EU12, "Geminilake EU12" },
};

static uint8_t get_dev_revision(pci_devfn_t dev)
{
	return pci_read_config8(dev, PCI_REVISION_ID);
}

static uint16_t get_dev_id(pci_devfn_t dev)
{
	return pci_read_config16(dev, PCI_DEVICE_ID);
}

static void report_cpu_info(void)
{
	uint32_t i, cpu_id, cpu_feature_flag;
	char cpu_name[49];
	const char *support = "Supported";
	const char *no_support = "Not Supported";
	const char *cpu_type = "Unknown";

	fill_processor_name(cpu_name);
	cpu_id = cpu_get_cpuid();

	/* Look for string to match the name */
	for (i = 0; i < ARRAY_SIZE(cpu_table); i++) {
		if (cpu_table[i].cpuid == cpu_id) {
			cpu_type = cpu_table[i].name;
			break;
		}
	}

	printk(BIOS_INFO, "CPU: %s\n", cpu_name);
	printk(BIOS_INFO, "CPU: ID %x, %s, ucode: %08x\n", cpu_id, cpu_type,
			get_current_microcode_rev());

	cpu_feature_flag = cpu_get_feature_flags_ecx();
	printk(BIOS_INFO, "CPU: AES %s, TXT %s, VT %s\n",
			(cpu_feature_flag & CPUID_AES) ? support : no_support,
			(cpu_feature_flag & CPUID_SMX) ? support : no_support,
			(cpu_feature_flag & CPUID_VMX) ? support : no_support);
}

static void report_mch_info(void)
{
	uint32_t i;
	pci_devfn_t dev = SA_DEV_ROOT;
	uint16_t mchid = get_dev_id(dev);
	uint8_t mch_revision = get_dev_revision(dev);
	const char *mch_type = "Unknown";

	for (i = 0; i < ARRAY_SIZE(mch_table); i++) {
		if (mch_table[i].mchid == mchid) {
			mch_type = mch_table[i].name;
			break;
		}
	}

	printk(BIOS_INFO, "MCH: device id %04x (rev %02x) is %s\n",
			mchid, mch_revision, mch_type);
}

static void report_pch_info(void)
{
	uint32_t i;
	pci_devfn_t dev = PCH_DEV_LPC;
	uint16_t lpcid = get_dev_id(dev);
	const char *pch_type = "Unknown";

	for (i = 0; i < ARRAY_SIZE(pch_table); i++) {
		if (pch_table[i].lpcid == lpcid) {
			pch_type = pch_table[i].name;
			break;
		}
	}
	printk(BIOS_INFO, "PCH: device id %04x (rev %02x) is %s\n",
			lpcid, get_dev_revision(dev), pch_type);
}

static void report_igd_info(void)
{
	uint32_t i;
	pci_devfn_t dev = SA_DEV_IGD;
	uint16_t igdid = get_dev_id(dev);
	const char *igd_type = "Unknown";

	for (i = 0; i < ARRAY_SIZE(igd_table); i++) {
		if (igd_table[i].igdid == igdid) {
			igd_type = igd_table[i].name;
			break;
		}
	}
	printk(BIOS_INFO, "IGD: device id %04x (rev %02x) is %s\n",
		igdid, get_dev_revision(dev), igd_type);
}

void report_platform_info(void)
{
	report_cpu_info();
	report_mch_info();
	report_pch_info();
	report_igd_info();
}


 a[i] ) );
  return Op<T>::zeroone() * upbnd;
}

template <class T> inline T
Specbnd<T>::_LambdaT
( const fadbad::F<T> &a, const fadbad::F<T> &b, unsigned int n )
{
  if( !n ) return 0.;
  if( n == 1 ) return (a.size() && b.size())? 2.*a[0]*b[0]: 0.;
  double upbnda=0., upbndb=0.;
  for (unsigned int i=0; i<n; i++){
    if( a.size() ) upbnda += Op<T>::u( Op<T>::sqr( a[i] ) );
    if( b.size() ) upbndb += Op<T>::u( Op<T>::sqr( b[i] ) );
  }
  T lamb = 2.*(Op<T>::zeroone()-0.5) * std::sqrt(upbnda*upbndb);
  for (unsigned int i=0; i<n; i++)
    if( a.size() && b.size() ) lamb += a[i]*b[i];
  return lamb;
}

template <typename T> inline std::pair<double,double>
Specbnd<T>::spectrum
( const fadbad::B< fadbad::F< double > >* D2X )
{
  if( !D2X ) throw typename Specbnd<T>::Exceptions( Specbnd<T>::Exceptions::SPECTR );
  const unsigned int N = D2X->val().size();
  if( !N ) throw typename Specbnd<T>::Exceptions( Specbnd<T>::Exceptions::SPECTR );
  double*H = new double[N*N];

  for( unsigned int j=0; j<N; j++ )
    for( unsigned int i=j; i<N; i++ )
      H[j*N+i] = H[i*N+j] = ( i==j? D2X[i].deriv(0).deriv(i):
        0.5*(D2X[i].deriv(0).deriv(j)+D2X[j].deriv(0).deriv(i)) );
#ifdef MC__SPECBND_DEBUG_SPECTRUM
  mc::display( N, N, H, N, "\nMatrix H", std::cout );
#endif

  double*D = mc::dsyev_wrapper( N, H );
  delete[] H;
  if( !D ) throw typename Specbnd<T>::Exceptions( Specbnd<T>::Exceptions::SPECTR );
  std::pair<double,double> spbnd = std::make_pair( min(N,D), max(N,D) );
  delete[] D;
  return spbnd;
}

template <typename T> inline std::pair<double,double>
Specbnd<T>::spectrum
( const fadbad::F< fadbad::F< double > >& D2F )
{
  const unsigned int N = D2F.size();
  if( !N ) throw typename Specbnd<T>::Exceptions( Specbnd<T>::Exceptions::SPECTR );
  double*H = new double[N*N];

  for( unsigned int j=0; j<N; j++ )
    for( unsigned int i=j; i<N; i++ )
      H[j*N+i] = H[i*N+j] = ( i==j? D2F.deriv(i).deriv(i):
        0.5*(D2F.deriv(i).deriv(j)+D2F.deriv(j).deriv(i)) );
#ifdef MC__SPECBND_DEBUG_SPECTRUM
  mc::display( N, N, H, N, "\nMatrix H", std::cout );
#endif

  double*D = mc::dsyev_wrapper( N, H );
  delete[] H;
  if( !D ) throw typename Specbnd<T>::Exceptions( Specbnd<T>::Exceptions::SPECTR );
  std::pair<double,double> spbnd


versations_prio_1",
		database = "zealot_female_a",
		name = "bonding_conversation_round_three_rumours_a",
		response = "bonding_conversation_round_three_rumours_a",
		wwise_route = 0,
		criterias = {
			{
				"query_context",
				"concept",
				OP.EQ,
				"story_talk",
			},
			{
				"user_context",
				"friends_close",
				OP.GT,
				0,
			},
			{
				"user_context",
				"enemies_close",
				OP.LT,
				1,
			},
			{
				"global_context",
				"team_threat_level",
				OP.SET_INCLUDES,
				args = {
					"low",
				},
			},
			{
				"global_context",
				"level_time",
				OP.GT,
				0,
			},
			{
				"user_context",
				"voice_template",
				OP.SET_INCLUDES,
				args = {
					"zealot_female_a",
				},
			},
			{
				"global_context",
				"player_voice_profiles",
				OP.SET_INTERSECTS,
				args = {
					"zealot_male_a",
				},
			},
			{
				"faction_memory",
				"bonding_conversation_round_three_rumours_a",
				OP.EQ,
				0,
			},
			{
				"faction_memory",
				"time_since_last_conversation",
				OP.TIMEDIFF,
				OP.GT,
				220,
			},
			{
				"faction_memory",
				"time_since_last_short_conversation",
				OP.TIMEDIFF,
				OP.GT,
				20,
			},
		},
		on_done = {
			{
				"user_memory",
				"bonding_conversation_round_three_rumours_a_user",
				OP.ADD,
				1,
			},
			{
				"faction_memory",
				"bonding_conversation_round_three_rumours_a",
				OP.ADD,
				1,
			},
			{
				"faction_memory",
				"time_since_last_conversation",
				OP.TIMESET,
			},
		},
		heard_speak_routing = {
			target = "players",
		},
	})
	define_rule({
		category = "conversations_prio_1",
		database = "zealot_female_a",
		name = "bonding_conversation_round_three_rumours_b",
		response = "bonding_conversation_round_three_rumours_b",
		wwise_route = 0,
		criterias = {
			{
				"query_context",
				"concept",
				OP.EQ,
				"heard_speak",
			},
			{
				"query_context",
				"dialogue_name",
				OP.SET_INCLUDES,
				args = {
					"bonding_conversation_round_three_rumours_a",
				},
			},
			{
				"user_context",
				"voice_template",
				OP.SET_INCLUDES,
				args = {
					"zealot_male_a",
				},
			},
		},
		on_done = {
			{
				"user_memory",
				"bonding_conversation_round_three_rumours_b_user",
				OP.ADD,
				1,
			},
		},
		heard_speak_routing = {
			target = "players",
		},
		on_pre_rule_execution = {
			delay_vo = {
				duration = 0.2,
			},
		},
	})
	define_rule({
		category = "conversations_prio_1",
		database = "zeal


; load current track
	sta	tmptrk		; store as temptrk
	sec			; calc current-desired
	sbc	phase
	beq	seekret		; if they match, we are done!

	bcs	seek_neg	; if negative, skip ahead
	eor	#$ff		; ones-complement the distance
	inc	curtrk		; increment current (make it 2s comp?)
	bcc	L114		; skip ahead
seek_neg:
	adc	#$fe
	dec	curtrk
L114:
	cmp	step
	bcc	L115
	lda	step
L115:
	cmp	#8
	bcs	L116
	tay
	sec
L116:
	lda	curtrk
	ldx	step1, y
	bne	L118
L117:
	clc
	lda	tmptrk
	ldx	step2, y
L118:
	stx	tmpsec
	and	#3
	rol
	tax
mlsmc11:sta	$c0e0, x
L119:
	ldx	#$13
L120:
	dex
	bne	L120
	dec	tmpsec
	bne	L119
	lsr
	bcs	L117
	inc	step
	bne	copy_cur
.endif

step1:	.byte $01, $30, $28, $24, $20, $1e, $1d, $1c
step2:	.byte $70, $2c, $26, $22, $1f, $1e, $1d, $1c

sectbl:	.byte $00,$0d,$0b,$09,$07,$05,$03,$01,$0e,$0c,$0a,$08,$06,$04,$02,$0f

; From $BA96 of DOS33
nibtbl:	.res 128			;		= *
;	.byte	$00,$01,$98,$99,


T1);

        let mut M: XMMATRIX  = crate::undefined();
        M.r[0] = _mm_movelh_ps(V1, T1);
        M.r[1] = _mm_add_ps(T4, T5);
        M.r[2] = _mm_shuffle_ps(V2, V3, _MM_SHUFFLE(1, 0, 3, 2));
        M.r[3] = *g_XMIdentityR3;
        return M;
    }
}

/// Loads an XMFLOAT4X3 into an XMMATRIX.
///
/// ## Parameters
///
/// `pSource` Address of the XMFLOAT4X3 structure to load. This parameter must point to cached memory.
///
/// ## Return value
///
/// Returns an XMMATRIX loaded with the data from the pSource parameter.
/// This function performs a partial load of the returned XMMATRIX. See Getting Started for more information.
///
/// ## Remarks
///
/// XMFLOAT4X3 is a row-major form of the matrix. This function cannot be used to read column-major data
/// since it assumes the last column is `0 0 0 1`.
///
/// The members of the XMFLOAT4X3 structure (_11, _12, _13, and so on) are loaded into the corresponding
/// members of the XMMATRIX. The remaining members of the returned XMMATRIX are `0.0`, except for _44, which
/// is `1.0`.
///
/// ## Example
///
/// ```rust
/// # use directx_math::*;
/// let data = XMFLOAT4X3::from([
///     [10.0, 11.0, 12.0],
///     [13.0, 14.0, 15.0],
///     [16.0, 17.0, 18.0],
///     [19.0, 20.0, 21.0],
/// ]);
///
/// let m = XMLoadFloat4x3(&data);
/// let m: [[f32; 4]; 4] = XMMatrix(m).into();
/// assert_eq!(m, [
///     [10.0, 11.0, 12.0, 0.0],
///     [13.0, 14.0, 15.0, 0.0],
///     [16.0, 17.0, 18.0, 0.0],
///     [19.0, 20.0, 21.0, 1.0],
/// ]);
///
/// ```
///
/// ## Reference
///
/// <https://docs.microsoft.com/en-us/windows/win32/api/directxmath/nf-directxmath-XMLoadFloat4x3>
#[inline]
pub fn XMLoadFloat4x3(
    pSource: &XMFLOAT4X3,
) -> XMMATRIX
{
    #[cfg(_XM_NO_INTRINSICS_)]
    unsafe {
        let mut M: XMMATRIX = crate::undefined();
        M.r[0].vector4_f32[0] = pSource.m[0][0];
        M.r[0].vector4_f32[1] = pSource.m[0][1];
        M.r[0].vector4_f32[2] = pSource.m[0][2];
        M.r[0].vector4_f32[3] = 0.0;

        M.r[1].vector4_f32[0] = pSource.m[1][0];
        M.r[1].vector4_f32[1] = pSource.m[1][1];
        M.r[1].vector4_f32[2] = pSource.m[1][2];
        M.r[1].vector4_f32[3] = 0.0;

        M.r[2].vector


 of the program.
#define FORBIDDEN_ADDR  0x8000C000

.section .u_text , "ax"
init_uarch:
    li s0, FORBIDDEN_ADDR

    .rep 16
    ld t0, 0(s0)
    sd t1, 16(s0)
    addi s0, s0, 32
    .endr

    # Padding for alignment
    nop


x.test.core.TestUtils;
import org.junit.Assume;
import org.junit.Test;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.LockSupport;
import java.util.function.BooleanSupplier;

import static java.util.concurrent.TimeUnit.SECONDS;

/**
 * @author Julien Viet
 */
public class SockJSSessionTest extends SockJSTestBase {

  @Test
  public void testNoDeadlockWhenWritingFromAnotherThreadWithSseTransport() throws Exception {
    socketHandler = () -> {
      return socket -> {
        AtomicBoolean closed = new AtomicBoolean();
        socket.endHandler(v -> {
          closed.set(true);
          testComplete();
        });
        new Thread(() -> {
          while (!closed.get()) {
            LockSupport.parkNanos(50);
            socket.write(Buffer.buffer(TestUtils.randomAlphaString(256)));
          }
        }).start();
      };
    };
    startServers();
    client.request(HttpMethod.GET, "/test/400/8ne8e94a/eventsource").onComplete(onSuccess(req -> {
      req.send().onComplete(onSuccess(resp -> {
        AtomicInteger count = new AtomicInteger();
        resp.handler(msg -> {
          if (count.incrementAndGet() == 400) {
            resp.request().connection().close();
          }
        });
      }));
    }));
    await();
  }

  @Test
  public void testNoDeadlockWhenWritingFromAnotherThreadWithWebsocketTransport() throws Exception {
    Assume.assumeFalse(PlatformDependent.isWindows());
    final Buffer random = Buffer.buffer(TestUtils.randomAlphaString(256));
    int numMsg = 1000;
    waitFor(1);
    AtomicInteger clientReceived = new AtomicInteger();
    AtomicInteger serverReceived = new AtomicInteger();
    BooleanSupplier shallStop = () -> clientReceived.get() > numMsg * 256 && serverReceived.get() > numMsg * 256;
    socketHandler = () -> {
      return socket -> {
        socket.handler(msg -> serverReceived.addAndGet(msg.length()));
        socket.write("hello");

        new Thread(() -> {
          while (!shallStop.getAsBoolean()) {
            LockSupport.parkNanos(50);
            try {
              socket.write(random)
                .onFailure(this::fail);
            } catch (IllegalStateException e) {
              // Websocket has been closed
            }
          }
        }).start();
      };
    };
    startServers();
    wsClient.connect("/test/400/8ne8e94a/websocket")
      .onFailure(this::fail)
      .onSuccess(ws -> ws.handler(msg -> {
        clientReceived.addAndGet(msg.length());
        ws.writeTextMessage("\"hello\"")
          .compose(v -> ws.write(random))
          .onFailure(this::fail)
          .onSuccess(v -> {
            if (shallStop.getAsBoolean()) {
              ws.handler(null);
              complete();
            }
          });
      }));
    try {
      await();
    } catch (Throwable e) {
      System.out.println(clientReceived.get());
      System.out.println(serverReceived.get());
      throw e;
    }
  }

  @Test
  public void testCombineMultipleFramesIntoASingleMessage() throws Exception {
    socketHandler = () -> {
      return socket -> socket.handler(buf -> {
        assertEquals("Hello World", buf.toString());
        testComplete();
      });
    };
    startServers();
    wsClient.connect("/test/400/8ne8e94a/websocket").onComplete(onSuccess(ws -> {
      ws.w


emplate <class T>
class TAUBuffer {
public:
	enum {
		kAlignInterval = 0x10,
		kAlignMask = kAlignInterval - 1
	};

	/*! @ctor TAUBuffer.0 */
	TAUBuffer() :	mMemObject(NULL), mAlignedBuffer(NULL), mBufferSizeBytes(0)
	{
	}

	/*! @ctor TAUBuffer.1 */
	TAUBuffer(UInt32 numElems, UInt32 numChannels) :	mMemObject(NULL), mAlignedBuffer(NULL),
														mBufferSizeBytes(0)
	{
		Allocate(numElems, numChannels);
	}

	/*! @dtor ~TAUBuffer */
	~TAUBuffer()
	{
		Deallocate();
	}

	/*! @method Allocate */
	void	Allocate(UInt32 numElems)			// can also re-allocate
	{
		UInt32 reqSize = numElems * sizeof(T);

		if (mMemObject != NULL && reqSize == mBufferSizeBytes)
			return;	// already allocated

		mBufferSizeBytes = reqSize;
		mMemObject = CA_realloc(mMemObject, reqSize);
		UInt32 misalign = (uintptr_t)mMemObject & kAlignMask;
		if (misalign) {
			mMemObject = CA_realloc(mMemObject, reqSize + kAlignMask);
			mAlignedBuffer = (T *)((char *)mMemObject + kAlignInterval - misalign);
		} else
			mAlignedBuffer = (T *)mMemObject;
	}

	/*! @method Deallocate */
	void	Deallocate()
	{
		if (mMemObject == NULL) return;			// so this method has no effect if we're using
												// an external buffer

		free(mMemObject);
		mMemObject = NULL;
		mAlignedBuffer = NULL;
		mBufferSizeBytes = 0;
	}

	/*! @method AllocateClear */
	void	AllocateClear(UInt32 numElems)		// can also re-allocate
	{
		Allocate(numElems);
		Clear();
	}

	/*! @method Clear */
	void	Clear()
	{
		memset(mAlignedBuffer, 0, mBufferSizeBytes);
	}

	// accessors

	/*! @method operator T *()@ */
	operator T *()				{ return mAlignedBuffer; }

private:
	/*! @var mMemObject */
	void *		mMemObject;			// null when using an external buffer
	/*! @var mAlignedBuffer */
	T *			mAlignedBuffer;		// always valid once allocated
	/*! @var mBufferSizeBytes */
	UInt32		mBufferSizeBytes;
};

#endif // __AUBuffer_h__


//
// CtrlMainTabBar.h
//
// Copyright (c) Shareaza Development Team, 2002-2007.
// This file is part of SHAREAZA (shareaza.sourceforge.net)
//
// Shareaza 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 2 of
// the License, or (at your option) any later version.
//
// Shareaza 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 Shareaza; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//

#pragma once

#include "ShareazaDataSource.h"

class CSkinWindow;

class CMainTabBarCtrl : public CControlBar
{
// Construction
public:
	CMainTabBarCtrl();
	virtual ~CMainTabBarCtrl();

	DECLARE_DYNAMIC(CMainTabBarCtrl)

// Item Class
public:
	class TabItem : public CCmdUI
	{
	public:
		CMainTabBarCtrl* m_pCtrl;
		CString	m_sName;
		CString	m_sTitle;
		CRect	m_rc;
		CRect	m_rcSrc[5];
		BOOL	m_bEnabled;
		BOOL	m_bSelected;

	public:
		TabItem(CMainTabBarCtrl* pCtrl, LPCTSTR pszName);
		virtual ~TabItem() {}
		void	OnSkinChange(CSkinWindow* pSkin, CDC* pdcCache, CBitmap* pbmCache);
		BOOL	Update(CFrameWnd* pTarget);
		BOOL	HitTest(const CPoint& point) const;
		void	Paint(CDC* pDstDC, CDC* pSrcDC, const CPoint& ptOffset, BOOL bHover, BOOL bDown);
	public:
		virtual void	Enable(BOOL bEnable);
		virtual void	SetCheck(BOOL bCheck);
	};

// Attributes
protected:
	CList< TabItem* > m_pItems;
	CSkinWindow*	m_pSkin;
	TabItem*		m_pHover;
	TabItem*		m_pDown;
	DWORD			m_dwHoverTime;
	CDC				m_dcSkin;
	CBitmap			m_bmSkin;
	HBITMAP			m_hOldSkin;

// Operations
public:
	BOOL			Create(CWnd* pParentWnd, DWORD dwStyle, UINT nID);
	BOOL			HasLocalVersion();
	void			OnSkinChange();
	virtual void	OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler);
	virtual CSize	CalcFixedLayout(BOOL bStretch, BOOL bHorz);
	TabItem*		HitTest(const CPoint& point) const;
	virtual INT_PTR	OnToolHitTest(CPoint point, TOOLINFO* pTI) const;
	virtual void	DoPaint(CDC* pDC);

	inline void		RemoveSkin()
	{
		m_pSkin = NULL;
	}

// Implementation
protected:
	afx_msg int  OnCreate(LPCREATESTRUCT lpCreateStruct);
	afx_msg void OnDestroy();
	afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
	afx_msg void OnMouseMove(UINT nFlags, CPoint point);
	afx_msg void OnLButtonDblClk(UINT nFlags, CPoint point);
	afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
	afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
	afx_msg void OnRButtonDown(UINT nFlags, CPoint point);
	afx_msg void OnTimer(UINT_PTR nIDEvent);

	DECLARE_MESSAGE_MAP()
	DECLARE_DROP()
};


->twidCoefModifier = 8U;
    /*  Initialise the bit reversal table modifier */
    S->bitRevFactor = 8U;
    /*  Initialise the bit reversal table pointer */
    S->pBitRevTable = (uint16_t *) & armBitRevTable[7];
    break;

  case 256U:
    /*  Initializations of structure parameters for 256 point FFT */
    S->twidCoefModifier = 16U;
    S->bitRevFactor = 16U;
    S->pBitRevTable = (uint16_t *) & armBitRevTable[15];
    break;

  case 128U:
    /*  Initializations of structure parameters for 128 point FFT */
    S->twidCoefModifier = 32U;
    S->bitRevFactor = 32U;
    S->pBitRevTable = (uint16_t *) & armBitRevTable[31];
    break;

  case 64U:
    /*  Initializations of structure parameters for 64 point FFT */
    S->twidCoefModifier = 64U;
    S->bitRevFactor = 64U;
    S->pBitRevTable = (uint16_t *) & armBitRevTable[63];
    break;

  case 32U:
    /*  Initializations of structure parameters for 32 point FFT */
    S->twidCoefModifier = 128U;
    S->bitRevFactor = 128U;
    S->pBitRevTable = (uint16_t *) & armBitRevTable[127];
    break;

  case 16U:
    /*  Initializations of structure parameters for 16 point FFT */
    S->twidCoefModifier = 256U;
    S->bitRevFactor = 256U;
    S->pBitRevTable = (uint16_t *) & armBitRevTable[255];
    break;

  default:
    /*  Reporting argument error if fftSize is not valid value */
    status = ARM_MATH_ARGUMENT_ERROR;
    break;
  }

  return (status);
}

/**
 * @} end of ComplexFFT group
 */


ing"]
  RETURN R1 2
  LOADB R1 1
  DUPTABLE R2 K8 [{"name", "id"}]
  GETTABLEKS R3 R0 K5 ["name"]
  SETTABLEKS R3 R2 K5 ["name"]
  GETTABLEKS R3 R0 K0 ["id"]
  SETTABLEKS R3 R2 K0 ["id"]
  RETURN R1 2

MAIN:
  PREPVARARGS 0
  GETIMPORT R0 K1 [script]
  LOADK R2 K2 ["AssetImporter"]
  NAMECALL R0 R0 K3 ["FindFirstAncestor"]
  CALL R0 2 1
  GETIMPORT R1 K5 [require]
  GETTABLEKS R3 R0 K6 ["Src"]
  GETTABLEKS R2 R3 K7 ["Types"]
  CALL R1 1 1
  NEWTABLE R2 2 0
  DUPCLOSURE R3 K8 [PROTO_0]
  SETTABLEKS R3 R2 K9 ["mock"]
  DUPCLOSURE R3 K10 [PROTO_1]
  SETTABLEKS R3 R2 K11 ["fromJsonData"]
  RETURN R2 1


from typing import Tuple
import torch
from torch import Tensor, nn
from torchsparse import SparseTensor
from torchsparse.nn.modules.flat_coord import bxyz2flat, flat2bxyz

__all__ = ["MaxPool3d"]

XYZ_DIM = 3  # [X,Y,Z]

def sparse_max_pool_1d(in_feats: Tensor, in_coords: Tensor,
                       kernel_size: int) -> Tuple[Tensor, Tensor]:
    """_summary_

    Args:
        in_feats (Tensor): shape[L, C]
        in_coords (Tensor): shape[L, BXYZ_DIM]
        kernel_size (int): downsample ratio

    Returns:
        Tuple[Tensor, Tensor]: out_feats[L*, C], out_coords[L*, BXYZ_DIM]
    """

    out_coords = in_coords.clone()
    out_coords[:, 1:] = in_coords[:, 1:] // kernel_size

    coords_min, _ = torch.min(out_coords, dim=0)
    coords_max, _ = torch.max(out_coords, dim=0)

    enc_coords = bxyz2flat(out_coords, coords_min, coords_max)

    enc_coords, inv_idx = torch.unique(enc_coords,
                                       sorted=False,
                                       return_inverse=True,
                                       return_counts=False,
                                       dim=0)

    out_feats = torch.empty(len(enc_coords),
                            in_feats.shape[1],
                            dtype=in_feats.dtype,
                            device=in_feats.device)

    # reduce same coordinate
    out_feats.index_reduce_(0, inv_idx, in_feats, 'amax', include_self=False)

    out_coords = flat2bxyz(enc_coords, coords_min, coords_max)

    return out_feats, out_coords

class MaxPool3d(nn.Module):

    def __init__(self, kernel_size: int) -> None:
        super().__init__()
        assert isinstance(kernel_size, int), "currently support only integer"
        self.kernel_size = kernel_size

    def forward(self, input: SparseTensor) -> SparseTensor:
        out_feats, out_coords = sparse_max_pool_1d(in_feats=input.feats,
                                                   in_coords=input.coords,
                                                   kernel_size=self.kernel_size)

        output = SparseTensor(
            coords=out_coords,
            feats=out_feats,
            stride=[stride * self.kernel_size for stride in input.stride],
            spatial_range=input.spatial_range,
        )

        output._caches = input._caches

        return output

def main():
    channel_size = 2
    in_coords = torch.Tensor([[0, 1, 2, 3], [0, 1, 2, 2], [1, 1, 2, 2]])
    gt_coords = torch.Tensor([[0, 0, 1, 1], [1, 0, 1, 1]])

    in_feats = torch.rand(in_coords.shape[0], channel_size)
    print(in_feats, in_coords)
    out_feats, out_coords = sparse_max_pool_1d(in_feats=in_feats,
                                               in_coords=in_coords,
                                               kernel_size=2)
    print(out_feats, out_coords)
    success = torch.sum(gt_coords != out_coords).item() == 0
    print(success)

if __name__ == "__main__":
    main()


		By("Create installation with an export conflict between subinstallations")
			inst := &lsv1alpha1.Installation{}
			utils.ExpectNoError(utils.CreateInstallationFromFile(ctx, state.State, inst, path.Join(testdataDir, "installation-conflict", "installation.yaml")))

			By("Wait for installation to fail")
			utils.ExpectNoError(lsutils.WaitForInstallationToFinish(ctx, f.Client, inst, lsv1alpha1.InstallationPhases.Failed, 2*time.Minute))
		})
	})
}
// SPDX-FileCopyrightText: 2022 SAP SE or an SAP affiliate company and Gardener contributors.
//
// SPDX-License-Identifier: Apache-2.0

package subinstallations

import (
	"context"
	"path"
	"path/filepath"
	"time"

	"github.com/gardener/landscaper/controller-utils/pkg/logging"

	. "github.com/onsi/ginkgo/v2"
	. "github.com/onsi/gomega"
	k8sv1 "k8s.io/api/core/v1"
	"sigs.k8s.io/controller-runtime/pkg/client"

	lsv1alpha1 "github.com/gardener/landscaper/apis/core/v1alpha1"
	lsutils "github.com/gardener/landscaper/pkg/utils/landscaper"
	"github.com/gardener/landscaper/test/framework"
	"github.com/gardener/landscaper/test/utils"
)

func SubinstallationTests(f *framework.Framework) {
	var (
		testdataDir = filepath.Join(f.RootPath, "test", "integration", "testdata", "subinstallations")
	)

	Describe("Subinstallations", func() {

		var (
			state = f.Register()
			ctx   context.Context
		)

		log, err := logging.GetLogger()
		if err != nil {
			f.Log().Logfln("Error fetching logger: %w", err)
			return
		}

		BeforeEach(func() {
			ctx = context.Background()
			ctx = logging.NewContext(ctx, log)
		})

		AfterEach(func() {
			ctx.Done()
		})

		It("should add and remove subinstallations", func() {
			var (
				do1  = &lsv1alpha1.DataObject{} // contains the name of the ConfigMap to be deployed by the Installation
				do2  = &lsv1alpha1.DataObject{} // contains the namespace of the ConfigMap
				do3  = &lsv1alpha1.DataObject{} // contains the data of the ConfigMap
				inst = &lsv1alpha1.Installation{}
			)

			By("Create DataObjects with imports")
			utils.ExpectNoError(utils.CreateDataObjectFromFile(ctx, state.State, do1, path.Join(testdataDir, "installation-1", "import-do-name.yaml")))
			utils.ExpectNoError(utils.CreateNamespaceDataObjectFromFile(ctx, state.State, do2, path.Join(testdataDir, "installation-1", "import-do-namespace.yaml")))
			utils.ExpectNoError(utils.CreateDataObjectFromFile(ctx, state.State, do3, path.Join(testdataDir, "installation-1", "import-do-data.yaml")))

			By("Create target")
			target, err := utils.BuildInternalKubernetesTarget(ctx, f.Client, state.Namespace, "my-cluster", f.RestConfig)
			utils.ExpectNoError(err)
			utils.ExpectNoError(state.Create(ctx, target))

			By("Create installation referencing component version v0.2.0 with two subinstallations")
			utils.ExpectNoError(utils.CreateInstallationFromFile(ctx, state.State, inst, path.Join(testdataDir, "installation-1", "installation-v0.2.0.yaml")))

			By("Wait for installation to finish")
			utils.ExpectNoError(lsutils.WaitForInstallationToFinish(ctx, f.Client, inst, lsv1alpha1.InstallationPhases.Succeeded


 error

	LimitBandwidth(limits BandwidthLimits) error
	CurrentBandwidthLimits() (BandwidthLimits, error)

	LimitCPU(limits CPULimits) error
	CurrentCPULimits() (CPULimits, error)

	LimitDisk(limits DiskLimits) error
	CurrentDiskLimits() (DiskLimits, error)

	LimitMemory(limits MemoryLimits) error
	CurrentMemoryLimits() (MemoryLimits, error)

	Spawn(JobSpec) (uint32, error)
	Stream(jobID uint32) (<-chan JobStream, error)
	Link(jobID uint32) (JobResult, error)

	NetIn(hostPort, containerPort uint32) (uint32, uint32, error)
	NetOut(network string, port uint32) error
}

type JobSpec struct {
	Script        string
	Privileged    bool
	Limits        ResourceLimits
	DiscardOutput bool
	AutoLink      bool
}

type JobResult struct {
	ExitStatus uint32
	Stdout     []byte
	Stderr     []byte
	Info       ContainerInfo
}

type JobStream struct {
	Name       string
	Data       []byte
	ExitStatus *uint32
	Info       *ContainerInfo
}

type ContainerInfo struct {
	State         string
	Events        []string
	HostIP        string
	ContainerIP   string
	ContainerPath string
	JobIDs        []uint32
	MemoryStat    ContainerMemoryStat
	CPUStat       ContainerCPUStat
	DiskStat      ContainerDiskStat
	BandwidthStat ContainerBandwidthStat
}

type ContainerMemoryStat struct {
	Cache                   uint64
	Rss                     uint64
	MappedFile              uint64
	Pgpgin                  uint64
	Pgpgout                 uint64
	Swap                    uint64
	Pgfault                 uint64
	Pgmajfault              uint64
	InactiveAnon            uint64
	ActiveAnon              uint64
	InactiveFile            uint64
	ActiveFile              uint64
	Unevictable             uint64
	HierarchicalMemoryLimit uint64
	HierarchicalMemswLimit  uint64
	TotalCache              uint64
	TotalRss                uint64
	TotalMappedFile         uint64
	TotalPgpgin             uint64
	TotalPgpgout            uint64
	TotalSwap               uint64
	TotalPgfault            uint64
	TotalPgmajfault         uint64
	TotalInactiveAnon       uint64
	TotalActiveAnon         uint64
	TotalInactiveFile       uint64
	TotalActiveFile         uint64
	TotalUnevictable        uint64
}

type ContainerCPUStat struct {
	Usage  uint64
	User   uint64
	System uint64
}

type ContainerDiskStat struct {
	BytesUsed  uint64
	InodesUsed uint64
}

type ContainerBandwidthStat struct {
	InRate   uint64
	InBurst  uint64
	OutRate  uint64
	OutBurst uint64
}

type BandwidthLimits struct {
	RateInBytesPerSecond      uint64
	BurstRateInBytesPerSecond uint64
}

type DiskLimits struct {
	BlockLimit uint64
	Block      uint64
	BlockSoft  uint64
	BlockHard  uint64

	InodeLimit uint64
	Inode      uint64
	InodeSoft  uint64
	InodeHard  uint64

	ByteLimit uint64
	Byte      uint64
	ByteSoft  uint64
	ByteHard  uint64
}

type MemoryLimits struct {
	LimitInBytes uint64
}

type CPULimits struct {
	LimitInShares uint64
}

type


 break;
   } else if (sInput == "super") {
       superMode = true;
       if (!a51Comm.send(std::string("Enter supper mode!"))) {
           // some error occured
           std::cerr << "Some error occured at send\n";
           return (1);
       }
       l.log("Enter super mode");
       getSuperSecretKey(superSecretKey, argv[3]);
       a51Comm = A51Comm(superSecretKey, COMM_TIMEOUT, fd, fd);
   } else if (sInput == "secret") {
       if (!superMode) {
           if (!a51Comm.send(std::string("You have not entered super mode!"))) {
               // some error occured
               std::cerr << "Some error occured at send\n";
               return (1);
           }
           l.log("Have not entered super mode!");
       } else {
           std::string data = "Secret: ";
           data += getSecretData(argv[4]);
           if (!a51Comm.send(data)) {
               // some error occured
               std::cerr << "Some error occured at send\n";
               return (1);
           }
           l.log("Sent secret");
       }
   } else {
       sResponse = getResponse(sInput, records);
       if (!a51Comm.send(sResponse)) {
           // some error occured
           std::cerr << "Some error occured at send\n";
           return (1);
       }
       l.log(sResponse);
   }
}
```

We can see here that the bot creates encrypted channel using the secret key we
provide.
Then it's waiting for commands.
There are 2 interesting special command -> `secret` and `super`.
First one sends us the flag, but it can only be invoked after `super`.
The problem is that `super` triggers changing the encrypted channel to use a
different secret key, which we don't know.

We need to invoke `super` command, and then issue `secret` command to get back
the flag.
However `super` will change the secret key, and from this point the server
won't be able to properly decrypt our messages, and we won't be able to
decrypt messages from the server.

## A5/1 stream cipher

Without going into much details, the encryption in the task is using a stream-
cipher with keystream derived from secret key and timestamp.
However, the timestamp is changed only every 30 seconds, and there is no
notion of any counter (like in CTR mode), so for 30 seconds keystream stays
constant!

Timestamps are kept independent, and are sent with the encrypted message.
This means the receiving side uses the timestamp we send to decrypt the data.

## Recovering keystream and forging messages

Since the responses from the server are pre-defined, we can easily recover the
keystream, by XORing the encrypted payload with the plaintext message.
We can do this easily, because the message contains also the `length`, and
most of the plaintexts have different length, only 24 is repeated.
This means that even if the server changes the encryption secret key after we
issue `super` command, we can recover the keystream!

With keystream, we can encrypt any message we want (assuming it's not too
long) by simply XORing the message with keystream we recovered.
We know the timestamp server used, so we can send the same one, to make sure
the server gets identical keystream and decrypts message correctly.


ck;
  NERoomEventCallback? roomEventCallback;

  final isEmojiResponseEnabled = ValueNotifier<bool>(true);

  bool get isMySelfHostOrCoHost => roomContext?.isMySelfHostOrCoHost() ?? false;

  String handsUpTag = "handsUpTag";

  void init(NERoomContext roomContext) {
    this.roomContext = roomContext;
    messageCallback = NEMessageChannelCallback(
      onCustomMessageReceiveCallback: handlePassThroughMessage,
    );
    roomEventCallback = NERoomEventCallback(
      chatroomMessagesReceived: chatroomMessagesReceived,
      roomPropertiesChanged: _onRoomPropertiesChanged,
      memberPropertiesChanged: handleMemberPropertiesEvent,
      memberPropertiesDeleted: handleMemberPropertiesEvent,
      memberLeaveRoom: memberLeaveRoom,
    );
    isEmojiResponseEnabled.value = roomContext.isEmojiResponseEnabled;
    NERoomKit.instance.messageChannelService
        .addMessageChannelCallback(messageCallback!);
    roomContext.addEventCallback(roomEventCallback!);
  }

  void handlePassThroughMessage(NECustomMessage message) {
    if (message.roomUuid != roomContext?.roomUuid) {
      return;
    }

    /// 表情回应消息
    if (message.commandId == MeetingEmojiMessenger.commandId) {
      final emojiId = MeetingEmojiMessenger.parseEmojiTag(message.data);
      handleEmojiMessage(emojiId, message.senderUuid);
      return;
    }
  }

  void handleMemberPropertiesEvent(
      NERoomMember member, Map<String, String> properties) {
    if (!properties.containsKey(HandsUpProperty.key)) return;
    if (member.isRaisingHand) {
      _userEmojiMap[member.uuid]
          ?.currentEmojiTagStreamController
          .add(handsUpTag);
    } else {
      _userEmojiMap[member.uuid]
          ?.currentEmojiTagStreamController
          .add(_userEmojiMap[member.uuid]?.currentEmojiTag);
    }
  }

  void memberLeaveRoom(List<NERoomMember> userList) {
    userList.forEach((user) {
      final remove = _userEmojiMap.remove(user.uuid);
      if (remove?.currentEmojiTagStreamController.isClosed != true) {
        remove?.currentEmojiTagStreamController.close();
      }
    });
  }

  void _onRoomPropertiesChanged(Map<String, String> properties) {
    if (properties.containsKey(MeetingSecurityCtrlKey.securityCtrlKey)) {
      isEmojiResponseEnabled.value =
          roomContext?.isEmojiResponseEnabled ?? true;
    }
  }

  void chatroomMessagesReceived(List<NERoomChatMessage> message) {
    /// 普通观众过滤等候室消息
    if (roomContext?.isMySelfHostOrCoHost() != true) {
      message = message.where((element) {
        return element.chatroomType != NEChatroomType.waitingRoom;
      }).toList();
    }
    message.forEach((msg) {
      if (msg is NERoomChatCustomMessage) {
        final commandId = MeetingEmojiMessenger.parseCommandId(msg.attachStr);
        if (commandId == MeetingEmojiMessenger.commandId) {
          final emojiTag = MeetingEmojiMessenger.parseEmojiTag(msg.attachStr);
          handleEmojiMessage(emojiTag, msg.fromUserUuid);
        }
      }
    });
  }

  NEMeetingUserEmoji getUserEmoji(String uuid) {
    if (!_userEmojiMap.containsKey(uuid)) {
      _userEmojiMap[uuid] = NEMeetingUserEmoji(uuid);
    }
    return _userE


- `ctx`: `context.Context`，请求上下文。用于取消操作或设置超时。
- `key`: `string`，缓存键。
- `opts`: `...ItemOption`，可变参数列表，用于配置缓存项的各种选项。 支持以下选项：
    - `Value(value any)`: 设置缓存值。
    - `TTL(duration time.Duration)`: 设置远程缓存项的过期时间。（本地缓存过期时间在构建 Local 缓存实例的时候统一设置）
    - `Do(fn func(context.Context) (any, error))`: 给定的回源函数 `fn` 来获取值，优先级高于 `Value`。
    - `SetNX(flag bool)`: 仅当键不存在时才设置缓存项。 适用于远程缓存，防止覆盖已存在的值。
    - `SetXX(flag bool)`: 仅当键存在时才设置缓存项。适用于远程缓存，确保只更新已存在的值。

返回值：
- `error`: 如果设置缓存失败，则返回错误。

示例1：使用 `Value` 设置缓存值
```go
obj := struct {
	Name string
	Age  int
}{Name: "John Doe", Age: 30}

err := cache.Set(ctx, key, Value(&obj), TTL(time.Hour))
if err != nil {
	// 处理错误
}
```

示例 2: 使用 `Do` 函数获取并设置缓存值
```go
err := cache.Once(ctx, key, TTL(time.Hour), Do(func(ctx context.Context) (any, error) {
	return fetchData(ctx)
}))
if err != nil {
	// 处理错误
}
```

示例 3: 使用 `SetNX` 进行原子操作 (仅当键不存在时设置)

```go
err := cache.Set(ctx, key, TTL(time.Hour), Value(obj), SetNX(true))
if err != nil {
    // 处理错误，例如键已存在
}
```

## Once 接口

该接口从缓存中获取给定 `Key` 的值。若未命中缓存，则执行 `Do` 函数，然后将结果缓存并返回。它确保对于给定的 `Key`，同一时间只有一个执行在进行中。如果出现重复请求，重复的调用者将等待原始请求完成，并接收相同的结果。

通过设置 `Refresh(true)` 可开启缓存自动刷新。

`Once` 接口：分布式-防缓存击穿利器 - `singleflight`

![singleflight](/docs/images/singleflight.png)

> singlefilght ，在go标准库中（"golang.org/x/sync/singleflight"）提供了可重复的函数调用抑制机制。通过给每次函数调用分配一个key，
> 相同key的函数并发调用时，只会被执行一次，返回相同的结果。其本质是对函数调用的结果进行复用。

`Once` 接口：分布式-防缓存击穿利器 - `auto refresh`

![autoRefresh](/docs/images/autorefresh.png)

> `Once`接口提供了自动刷新缓存的能力，目的是为了防止缓存失效时造成的雪崩效应打爆数据库。对一些key比较少，实时性要求不高，加载开销非常大的缓存场景，
> 适合使用自动刷新。下面的代码（示例1）指定每分钟刷新一次，1小时如果没有访问就停止刷新。如果缓存是redis或者多级缓存最后一�


: absolute;
  top: 0;
  white-space: nowrap; }
.SearchBoxInput--Overlay > span {
    overflow: hidden;
    text-overflow: ellipsis; }
.searchNagContainer a, .searchAutocorrectLink {
  /*
       explicitly set the color for anchor links because
       these HTML elements are sent from the server, no
       way to wrap the contents inside <Text> with color
     */
  color: #555;
  /* dark-gray */ }
.searchNagContainer a:hover, .searchAutocorrectLink:hover {
    text-decoration: underline; }
.foodFilterButton {
  background: #b5b5b5; }
.foodFilterButton.active {
    background-color: #555; }
.filterOption {
  background-color: #efefef;
  border-radius: 4px; }
.filterOption.active {
    background-color: #555; }
.filterCheckBox {
  -webkit-appearance: none;
     -moz-appearance: none;
          appearance: none;
  background-color: transparent;
  cursor: pointer;
  height: 24px;
  opacity: 0;
  outline: 0;
  width: 24px; }
.filterDropdownButton {
  background-color: transparent;
  max-width: 200px;
  padding: 0;
  white-space: nowrap; }
.SearchImprovementsBar-OuterScrollContainer {
  overflow: hidden; }
.SearchImprovementsBar-InnerScrollContainer {
  margin-bottom: -17px;
  -ms-overflow-style: none;
  overflow-x: auto;
  overflow-y: hidden;
  padding-bottom: 17px; }
.SearchImprovementsBar-InnerScrollContainer::-webkit-scrollbar {
    display: none; }
.SearchImprovementsBar-ArrowButton {
  background-color: transparent;
  border: 0;
  height: 100%;
  outline: none;
  padding: 0; }
.SearchPage .sticky {
  position: -webkit-sticky;
  position: sticky;
  top: 65px;
  z-index: 3; }
.SearchPage .searchLEQChunk {
  margin: -10px;
  padding: 10px;
  position: relative; }
.SearchPage .searchLEQChunk::before {
    background: rgba(0, 0, 0, 0.05);
    border-radius: 8px;
    content: " " !important;
    height: 100%;
    left: 0;
    opacity: 0;
    pointer-events: none;
    position: absolute;
    top: 0;
    -webkit-transform: scale(0.96);
            transform: scale(0.96);
    width: 100%;
    z-index: 3; }
.SearchPage .searchLEQChunk:hover::before {
    -webkit-animation: tapAnimation 0.25s cubic-bezier(0.31, 1, 0.34, 1) forwards;
            animation: tapAnimation 0.25s cubic-bezier(0.31, 1, 0.34, 1) forwards; }
.SearchPage .leqChunksList {
  padding-bottom: 36px; }
.mainContainer.showHeaderMessage .SearchPage .sticky {
  top: 88px; }
.searchRelatedQueries .relatedQueriesStoryLabel {
  margin-bottom: 18px; }
.searchRelatedQueries .relatedQueriesStoryLabel > svg {
    position: fixed; }
.searchRelatedQueries .relatedQueriesStoryLabel > span {
    padding-left: 24px; }
.searchRelatedQueries .relatedQueryWrapper {
  margin-bottom: 12px; }
.searchRelatedQueries .relatedQueryWrapper .relatedQuery {
    border-radius: 4px;
    display: inline-block; }
.searchRelatedQueries .relatedQueryWrapper .relatedQuery .relatedQueryContent {
      display


/* Generated by RuntimeBrowser
   Image: /System/Library/PrivateFrameworks/CalendarUIKit.framework/CalendarUIKit
 */

@interface CUIKUserActivity : NSObject {
    NSSet * _activityKeywords;
    NSString * _activitySubtitle;
    NSString * _activityTitle;
    unsigned long long  _type;
    unsigned long long  _version;
}

@property (nonatomic, retain) NSSet *activityKeywords;
@property (nonatomic, retain) NSString *activitySubtitle;
@property (nonatomic, retain) NSString *activityTitle;
@property (nonatomic) unsigned long long type;
@property (nonatomic) unsigned long long version;

+ (double)_doubleFromDictionary:(id)arg1 key:(id)arg2 error:(bool*)arg3;
+ (long long)_integerFromDictionary:(id)arg1 key:(id)arg2 error:(bool*)arg3;
+ (id)_stringFromDictionary:(id)arg1 key:(id)arg2 error:(bool*)arg3;
+ (unsigned long long)_typeFromDictionary:(id)arg1;
+ (unsigned long long)_unsignedIntegerFromDictionary:(id)arg1 key:(id)arg2 error:(bool*)arg3;
+ (id)activityForActivity:(id)arg1;
+ (id)activityForDictionary:(id)arg1;

- (void).cxx_destruct;
- (id)activityKeywords;
- (id)activitySubtitle;
- (id)activityTitle;
- (id)dictionary;
- (id)initWithDictionary:(id)arg1;
- (id)initWithType:(unsigned long long)arg1;
- (void)setActivityKeywords:(id)arg1;
- (void)setActivitySubtitle:(id)arg1;
- (void)setActivityTitle:(id)arg1;
- (void)setType:(unsigned long long)arg1;
- (void)setVersion:(unsigned long long)arg1;
- (unsigned long long)type;
- (void)updateActivity:(id)arg1;
- (unsigned long long)version;

@end


SetVisible(uiBinder.node_icon_key, false)
  end
end

function Battle_auto_battle_setView:AddListener(slotId, uiBinder)
  uiBinder.rayimg_touch_area.onDown:AddListener(function()
    self:onSelectSkill(slotId, uiBinder)
  end)
end

function Battle_auto_battle_setView:onSelectSkill(slotId, uiBinder)
  if self.fighterBtnsVm_:IsAISlotLocked(slotId) then
    if self.fighterBtnsVm_:CheckInAISlotCache(slotId) then
      uiBinder.Ref:SetVisible(uiBinder.node_auto_battle, false)
      self.fighterBtnsVm_:RemoveAISlots(slotId)
    else
      uiBinder.Ref:SetVisible(uiBinder.node_auto_battle, true)
      self.fighterBtnsVm_:CacheAISlots(slotId)
    end
  elseif self.fighterBtnsVm_:CheckInAISlotCache(slotId) then
    uiBinder.Ref:SetVisible(uiBinder.node_auto_battle, true)
    self.fighterBtnsVm_:RemoveAISlots(slotId)
  else
    uiBinder.Ref:SetVisible(uiBinder.node_auto_battle, false)
    self.fighterBtnsVm_:CacheAISlots(slotId)
  end
end

return Battle_auto_battle_setView


alidated .has-info.is-focused .form-control:valid, .was-validated .has-info.is-focused .custom-file-control:valid, .has-info.is-focused .form-control.is-valid, .has-info.is-focused .is-valid.custom-file-control {
  border-color: #03a9f4;
  padding-right: calc(1.5em + 0.875rem);
  background-image: "none";
  background-repeat: no-repeat;
  background-position: right calc(0.375em + 0.21875rem) center;
  background-size: calc(0.75em + 0.4375rem) calc(0.75em + 0.4375rem);
}
.was-validated .has-info .is-focused .form-control:valid:focus, .was-validated .has-info .is-focused .custom-file-control:valid:focus, .has-info .is-focused .form-control.is-valid:focus, .has-info .is-focused .is-valid.custom-file-control:focus, .was-validated .has-info.is-focused .form-control:valid:focus, .was-validated .has-info.is-focused .custom-file-control:valid:focus, .has-info.is-focused .form-control.is-valid:focus, .has-info.is-focused .is-valid.custom-file-control:focus {
  border-color: #03a9f4;
  box-shadow: 0 0 0 0.2rem rgba(3, 169, 244, 0.25);
}
.was-validated .has-info .is-focused textarea.form-control:valid, .was-validated .has-info .is-focused textarea.custom-file-control:valid, .has-info .is-focused textarea.form-control.is-valid, .has-info .is-focused textarea.is-valid.custom-file-control, .was-validated .has-info.is-focused textarea.form-control:valid, .was-validated .has-info.is-focused textarea.custom-file-control:valid, .has-info.is-focused textarea.form-control.is-valid, .has-info.is-focused textarea.is-valid.custom-file-control {
  padding-right: calc(1.5em + 0.875rem);
  background-position: top calc(0.375em + 0.21875rem) right calc(0.375em + 0.21875rem);
}
.was-validated .has-info .is-focused .custom-select:valid, .has-info .is-focused .custom-select.is-valid, .was-validated .has-info.is-focused .custom-select:valid, .has-info.is-focused .custom-select.is-valid {
  border-color: #03a9f4;
  padding-right: calc(0.75em + 1.65625rem);
  background: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='4' height='5' viewBox='0 0 4 5'%3e%3cpath fill='%23343a40' d='M2 0L0 2h4zm0 5L0 3h4z'/%3e%3c/svg%3e") no-repeat right 0 center/8px 10px, "none" rgba(0, 0, 0, 0) no-repeat center right 1rem/calc(0.75em + 0.4375rem) calc(0.75em + 0.4375rem);
}
.was


CanNullTradersBalance(CSE_ALifeHumanAbstract *tpALifeHumanAbstract1, CSE_ALifeHumanAbstract *tpALifeHumanAbstract2, int iItemCount1, int iItemCount2, int iBalance)
{
	if (!iBalance) {
#ifdef DEBUG
		if (psAI_Flags.test(aiALife)) {
			Msg			("Balance is null");
		}
#endif
		return			(true);
	}

	if (iBalance < 0) {
		if (int(tpALifeHumanAbstract1->m_dwMoney) >= -iBalance) {
			tpALifeHumanAbstract1->m_dwMoney += iBalance;
			tpALifeHumanAbstract2->m_dwMoney -= iBalance;
#ifdef DEBUG
			if (psAI_Flags.test(aiALife)) {
				Msg		("Balance is covered by money");
			}
#endif
			return	(true);
		}
	}
	else
		if (int(tpALifeHumanAbstract2->m_dwMoney) >= iBalance) {
			tpALifeHumanAbstract1->m_dwMoney += iBalance;
			tpALifeHumanAbstract2->m_dwMoney -= iBalance;
#ifdef DEBUG
			if (psAI_Flags.test(aiALife)) {
				Msg			("Balance is covered by money");
			}
#endif
			return	(true);
		}

		vfFillTraderVector	(tpALifeHumanAbstract1,iItemCount1,m_tpTrader1);
		vfFillTraderVector	(tpALifeHumanAbstract2,iItemCount2,m_tpTrader2);

		sort				(m_tpTrader1.begin(),m_tpTrader1.end(),CSortItemByValuePredicate());
		sort				(m_tpTrader2.begin(),m_tpTrader2.end(),CSortItemByValuePredicate());

#ifdef DEBUG
		if (psAI_Flags.test(aiALife)) {
			{
				string4096		S;
				char			*S1 = S;
				S1				+= sprintf_s(S1,"%s [%5d]: ",tpALifeHumanAbstract1->name_replace(),tpALifeHumanAbstract1->m_dwMoney);
				for (int i=0, n=m_tpTrader1.size(); i<n; ++i)
					S1			+= sprintf_s(S1,"%6d",m_tpTrader1[i]->m_dwCost);
				Msg				("%s",S);
			}
			{
				string4096		S;
				char			*S1 = S;
				S1				+= sprintf_s(S1,"%s [%5d]: ",tpALifeHumanAbstract2->name_replace(),tpALifeHumanAbstract2->m_dwMoney);
				for (int i=0, n=m_tpTrader2.size(); i<n; ++i)
					S1			+= sprintf_s(S1,"%6d",m_tpTrader2[i]->m_dwCost);
				Msg				("%s",S);
			}
			Msg					("Balance : %6d",iBalance);
		}
#endif

		vfGenerateSums		(m_tpTrader1,m_tpSums1);
		vfGenerateSums		(m_tpTrader2,m_tpSums2);

#ifdef DEBUG
		if (psAI_Flags.test(aiALife)) {
			{
				string4096		S;
				char			*S1 = S;
				S1				+= sprintf_s(S1,"%s : ",tpALifeHumanAbstract1->name_replace());
				INT_IT			I = m_tpSums1.begin();
				INT_IT			E = m_tpSums1.end();
				for ( ; I != E; ++I)
					S1			+= sprintf_s(S1,"%6d",*I);
				Msg				("%s",S);
			}
			{
				string4096		S;
				char			*S1 = S;
				S1				+= sprintf_s(S1,"%s : ",tpALifeHumanAbstract2->name_replace()


2 < L6_2 do
        L5_2 = L5_2 + 1
        L7_2 = A0_2[1]
        L8_2 = L7_2
        L7_2 = L7_2.F9FDCD14A7B8FBF35
        L9_2 = L5_2 - 1
        L7_2 = L7_2(L8_2, L9_2)
        L8_2 = L7_2
        L7_2 = L7_2.FE828682F404959F2
        L7_2(L8_2)
      end
    end
    L3_2 = A0_2[12]
    L3_2 = L3_2 + 1
    A0_2[12] = L3_2
  end
end

L68_1 = _ENV["CC8D1A25A10AA93FF"]["prototype"]
L69_1 = _ENV["CC8D1A25A10AA93FF"]
L68_1.__class__ = L69_1
L68_1 = _ENV["CC8D1A25A10AA93FF"]
L69_1 = "__super__"
L69_1 = _ENV["CC8D1A25A10AA93FF"]["prototype"]
L70_1 = {}
L71_1 = "__index"


.31 11.31c-6.25 6.25-6.25 16.38 0 22.63L480 97.94V160c0 28.14 20.93 51.27 48 55.19V376c0 .1-.05.18-.05.27L384 265.02V64c0-35.35-28.65-64-64-64H160c-28.65 0-52.62 18.96-60.78 44.92L45.47 3.37C38.49-2.05 28.43-.8 23.01 6.18L3.37 31.45C-2.05 38.42-.8 48.47 6.18 53.9l588.36 454.73c6.98 5.43 17.03 4.17 22.46-2.81l19.64-25.27c5.41-6.97 4.16-17.02-2.82-22.45zM96 416h274.03L96 204.21V416zm304 32H80c-8.84 0-16 7.16-16 16v32c0 8.84 7.16 16 16 16h320c8.84 0 16-7.16 16-16v-32c0-8.84-7.16-16-16-16z"],gavel:[512,512,[],"f0e3","M504.971 199.362l-22.627-22.627c-9.373-9.373-24.569-9.373-33.941 0l-5.657 5.657L329.608 69.255l5.657-5.657c9.373-9.373 9.373-24.569 0-33.941L312.638 7.029c-9.373-9.373-24.569-9.373-33.941 0L154.246 131.48c-9.373 9.373-9.373 24.569 0 33.941l22.627 22.627c9.373 9.373 24.569 9.373 33.941 0l5.657-5.657 39.598 39.598-81.04 81.04-5.657-5.657c-12.497-12.497-32.758-12.497-45.255 0L9.373 412.118c-12.497 12.497-12.497 32.758 0 45.255l45.255 45.255c12.497 12.497 32.758 12.497 45.255 0l114.745-114.745c12.497-12.497 12.497-32.758 0-45.255l-5.657-5.657 81.04-81.04 39.598 39.598-5.657 5.657c-9.373 9.373-9.373 24.569 0 33.941l22.627 22.627c9.373 9.373 24.569 9.373 33.941 0l124.451-124.451c9.372-9.372 9.372-24.568 0-33.941z"],gem:[576,512,[],"f3a5","M485.5 0L576 160H474.9L405.7 0h79.8zm-128 0l69.2 160H149.3L218.5 0h139zm-267 0h79.8l-69.2 160H0L90.5 0zM0 192h100.7l123 251.7c1.5 3.1-2.7 5.9-5 3.3L0 192zm148.2 0h279.6l-137 318.2c-1 2.4-4.5 2.4-5.5 0L148.2 192zm204.1 251.7l123-251.7H576L357.3 446.9c-2.3 2.7-6.5-.1-5-3.2z"],genderless:[288,512,[],"f22d","M144 176c44.1 0 80 35.9 80 80s-35.9 80-80 80-80-35.9-80-80 35.9-80 80-80m0-64C64.5 112 0 176.5 0 256s64.5 144 144 144 144-64.5 144-1


/*
 * Copyright (c) 2005-2009 Brocade Communications Systems, Inc.
 * All rights reserved
 * www.brocade.com
 *
 * Linux driver for Brocade Fibre Channel Host Bus Adapter.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License (GPL) Version 2 as
 * published by the Free Software Foundation
 *
 * 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.
 */

#ifndef __BFA_DEFS_LPORT_H__
#define __BFA_DEFS_LPORT_H__

#include <defs/bfa_defs_types.h>
#include <defs/bfa_defs_port.h>

/**
 * BFA AEN logical port events.
 * Arguments below are in BFAL context from Mgmt
 * BFA_LPORT_AEN_NEW:       [in]: None         [out]: vf_id, ppwwn, lpwwn, roles
 * BFA_LPORT_AEN_DELETE:    [in]: lpwwn        [out]: vf_id, ppwwn. lpwwn, roles
 * BFA_LPORT_AEN_ONLINE:    [in]: lpwwn        [out]: vf_id, ppwwn. lpwwn, roles
 * BFA_LPORT_AEN_OFFLINE:   [in]: lpwwn        [out]: vf_id, ppwwn. lpwwn, roles
 * BFA_LPORT_AEN_DISCONNECT:[in]: lpwwn        [out]: vf_id, ppwwn. lpwwn, roles
 * BFA_LPORT_AEN_NEW_PROP:  [in]: None         [out]: vf_id, ppwwn. lpwwn, roles
 * BFA_LPORT_AEN_DELETE_PROP:     [in]: lpwwn  [out]: vf_id, ppwwn. lpwwn, roles
 * BFA_LPORT_AEN_NEW_STANDARD:    [in]: None   [out]: vf_id, ppwwn. lpwwn, roles
 * BFA_LPORT_AEN_DELETE_STANDARD: [in]: lpwwn  [out]: vf_id, ppwwn. lpwwn, roles
 * BFA_LPORT_AEN_NPIV_DUP_WWN:    [in]: lpwwn  [out]: vf_id, ppwwn. lpwwn, roles
 * BFA_LPORT_AEN_NPIV_FABRIC_MAX: [in]: lpwwn  [out]: vf_id, ppwwn. lpwwn, roles
 * BFA_LPORT_AEN_NPIV_UNKNOWN:    [in]: lpwwn  [out]: vf_id, ppwwn. lpwwn, roles
 */
enum bfa_lport_aen_event {
	BFA_LPORT_AEN_NEW	= 1,	/*  LPort created event */
	BFA_LPORT_AEN_DELETE	= 2,	/*  LPort deleted event */
	BFA_LPORT_AEN_ONLINE	= 3,	/*  LPort online event */
	BFA_LPORT_AEN_OFFLINE	= 4,	/*  LPort offline event */
	BFA_LPORT_AEN_DISCONNECT = 5,	/*  LPort disconnect event */
	BFA_LPORT_AEN_NEW_PROP	= 6,	/*  VPort created event */
	BFA_LPORT_AEN_DELETE_PROP = 7,	/*  VPort deleted event */
	BFA_LPORT_AEN_NEW_STANDARD = 8,	/*  VPort created event */
	BFA_LPORT_AEN_DELETE_STANDARD = 9,  /*  VPort deleted event */
	BFA_LPORT_AEN_NPIV_DUP_WWN = 10,    /*  VPort configured with
					     *   duplicate WWN event
						 */
	BFA_LPORT_AEN_NPIV_FABRIC_MAX = 11, /*  Max NPIV in fabric/fport */
	BFA_LPORT_AEN_NPIV_UNKNOWN = 12, /*  Unknown NPIV Error code event */
};

/**
 * BFA AEN event data structure
 */
struct bfa_lport_aen_data_s {
	u16        vf_id;	/*  vf_id of this logical port */
	u16        rsvd;
	enum bfa_port_role roles;	/*  Logical port mode,IM/TM/IP etc */
	wwn_t           ppwwn;	/*  WWN of its physical port */
	wwn_t           lpwwn;	/*  WWN of this logical port */
};

#endif /* __BFA_DEFS_LPORT_H__ */


nts
.0040D404: 890CFD00484100               mov         [000414800][edi]*8,ecx ;sauvegarde du byte dan la table
.0040D40B: 891CFD04484100               mov         [000414804][edi]*8,ebx ;sauvegarde de son offset dans la table
.0040D412: 47                           inc         edi ;incrment du compteur de bytes modifis
.0040D413: EB8C                         jmps       .00040D3A1 ;retour  la boucle
.0040D415: 85FF                         test        edi,edi ;compteur de bytes modifis  zro?
.0040D417: 7540                         jne        .00040D459 ;non, on saute, sinon...
.0040D419: 684F000000                   push        00000004F
.0040D41E: 68B0DB4000                   push        00040DBB0
.0040D423: 68F1030000                   push        0000003F1
.0040D428: FF75E8                       push        d,[ebp-0018]
.0040D42B: FF15D8924000                 call        GetDlgItemTextA ;...on rcupre le texte affich
.0040D431: 6882DD4000                   push        00040DD82 "Fichiers identiques..."
.0040D436: 68B0DB4000                   push        00040DBB0
.0040D43B: FF153C924000                 call        lstrcatA ;...on colle le texte  la suite...
.0040D441: 68B0DB4000                   push        00040DBB0
.0040D446: 68F1030000                   push        0000003F1
.0040D44B: FF75E8                       push        d,[ebp-0018]
.0040D44E: FF15E0924000                 call        SetDlgItemTextA ;...qu'on raffiche...
.0040D454: E92F4CFFFF                   jmp        .000402088 ;...et on saute  "Bye!"; pour l'instant boucle des messages(***)
.0040D459: 684F000000                   push        00000004F
.0040D45E: 68B0DB4000                   push        00040DBB0
.0040D463: 68F1030000                   push        0000003F1
.0040D468: FF75E8                       push        d,[ebp-0018]
.0040D46B: FF15D8924000                 call        GetDlgItemTextA ;on rcupre le texte affich...
.0040D471: 68C1DD4000                   push        00040DDC1 ;"Cration du crack en cours..."
.0040D476: 68B0DB4000                   push        00040DBB0
.0040D47B: FF153C924000                 call        lstrcatA ;...on rajoute la chane...
.0040D481: 68B0DB4000                   push        00040DBB0
.0040D486: 68F1030000                   push        0000003F1
.0040D48B: FF75E8                       push        d


    event:on('DiffModeChanged', handleDiffMode, self.disposables)
    table.insert(self.disposables, manager:initialize(ns, config.provider_selector,
        config.close_fold_kinds_for_ft, config.close_fold_current_line_for_ft))
    return self
end

function Fold:dispose()
    disposable.disposeAll(self.disposables)
    self.disposables = {}
end

return Fold