Species

<details>
<summary> DoesPlayerPartyContainSpecies </summary>

*(Supports bpre, bpge)*

Example Usage:
```
special2 varResult DoesPlayerPartyContainSpecies
```
read species from var4, if it's in the party, return 1 (recommend returning to varResult)

</details>

## DoFallWarp

<details>
<summary> DoFallWarp </summary>

*(Supports all games.)*

Example Usage:
```
special DoFallWarp
```
</details>

## DoInGameTradeScene

<details>
<summary> DoInGameTradeScene </summary>

*(Supports all games.)*

Example Usage:
```
special DoInGameTradeScene
```
</details>

## DoLotteryCornerComputerEffect

<details>
<summary> DoLotteryCornerComputerEffect </summary>

*(Supports axve, axpe, bpee)*

Example Usage:
```
special DoLotteryCornerComputerEffect
```
</details>

## DoMirageTowerCeilingCrumble

<details>
<summary> DoMirageTowerCeilingCrumble </summary>

*(Supports bpee)*

Example Usage:
```
special DoMirageTowerCeilingCrumble
```
</details>

## DoOrbEffect

<details>
<summary> DoOrbEffect </summary>

*(Supports bpee)*

Example Usage:
```
special DoOrbEffect
```
</details>

## DoPCTurnOffEffect

<details>
<summary> DoPCTurnOffEffect </summary>

*(Supports axve, axpe, bpee)*

Example Usage:
```
special DoPCTurnOffEffect
```
</details>

## DoPCTurnOnEffect

<details>
<summary> DoPCTurnOnEffect </summary>

*(Supports axve, axpe, bpee)*

Example Usage:
```
special DoPCTurnOnEffect
```
</details>

## DoPicboxCancel

<details>
<summary> DoPicboxCancel </summary>

*(Supports bpre, bpge)*

Example Usage:
```
special DoPicboxCancel
```
</details>

## DoPokemonLeagueLightingEffect

<details>
<summary> DoPokemonLeagueLightingEffect </summary>

*(Supports bpre, bpge)*

Example Usage:
```
special DoPokemonLeagueLightingEffect
```
</details>

## DoPokeNews

<details>
<summary> DoPokeNews </summary>

*(Supports axve, axpe, bpee)*

Example Usage:
```
special DoPokeNews
```
</details>

## DoSeagallopFerryScene

<details>
<summary> DoSeagallopFerryScene </summary>

*(Supports bpre, bpge)*

Example Usage:
```
special DoSeagallopFerryScene
```
</details>

## DoSealedChamberShakingEffect1

<details>
<summary> DoSealedChamberShakingEffect1 </summary>

*(Supports axve, axpe, bpee)*

Example Usage:
```
special DoSealedChamberShakingEffect1
```
</details>

## DoSealedChamberShakingEffect2

<details>
<summary> DoSealedChamberShakingEffect2 </summary>

*(Supports axve, axpe, bpee)*

Example Usage:
```
special DoSealedChamberShakingEffect2
```
</details>

## DoSecretBasePCTurnOffEffect

<details>
<summary> DoSecretBasePCTurnOffEffect </summary>

*(Supports axve, axpe, bpee)*

Example Usage:
```
special DoSecretBasePCTurnOffEffect
```
</details>

## DoSoftReset

<details>
<summary> DoSoftReset </summary>

*(Supports all games.)*

Example Usage:
```
special DoSoftReset
```
</details>

## DoSpecialTrainerBattle

<details>
<summary> D


FF_EDATA_PADDING	\
	.pecoff_edata_padding : { BYTE(0); . = ALIGN(PECOFF_FILE_ALIGNMENT); }
#else
#define PECOFF_EDATA_PADDING
#endif

SECTIONS
{
	/*
	 * XXX: The linker does not define how output sections are
	 * assigned to input sections when there are multiple statements
	 * matching the same input section name.  There is no documented
	 * order of matching.
	 */
	DISCARDS
	/DISCARD/ : {
		*(.interp .dynamic)
		*(.dynsym .dynstr .hash .gnu.hash)
	}

	. = KIMAGE_VADDR;

	.head.text : {
		_text = .;
		HEAD_TEXT
	}
	.text : {			/* Real text segment		*/
		_stext = .;		/* Text and read-only data	*/
			IRQENTRY_TEXT
			SOFTIRQENTRY_TEXT
			ENTRY_TEXT
			TEXT_TEXT
			SCHED_TEXT
			CPUIDLE_TEXT
			LOCK_TEXT
			KPROBES_TEXT
			HYPERVISOR_TEXT
			IDMAP_TEXT
			HIBERNATE_TEXT
			TRAMP_TEXT
			*(.fixup)
			*(.gnu.warning)
		. = ALIGN(16);
		*(.got)			/* Global offset table		*/
	}

	/*
	 * Make sure that the .got.plt is either completely empty or it
	 * contains only the lazy dispatch entries.
	 */
	.got.plt : { *(.got.plt) }
	ASSERT(SIZEOF(.got.plt) == 0 || SIZEOF(.got.plt) == 0x18,
	       "Unexpected GOT/PLT entries detected!")

	. = ALIGN(SEGMENT_ALIGN);
	_etext = .;			/* End of text section */

	/* everything from this point to __init_begin will be marked RO NX */
	RO_DATA(PAGE_SIZE)

	idmap_pg_dir = .;
	. += IDMAP_DIR_SIZE;
	idmap_pg_end = .;

#ifdef CONFIG_UNMAP_KERNEL_AT_EL0
	tramp_pg_dir = .;
	. += PAGE_SIZE;
#endif

#ifdef CONFIG_ARM64_SW_TTBR0_PAN
	reserved_ttbr0 = .;
	. += RESERVED_TTBR0_SIZE;
#endif
	swapper_pg_dir = .;
	. += PAGE_SIZE;
	swapper_pg_end = .;

	. = ALIGN(SEGMENT_ALIGN);
	__init_begin = .;
	__inittext_begin = .;

	INIT_TEXT_SECTION(8)

	__exittext_begin = .;
	.exit.text : {
		EXIT_TEXT
	}
	__exittext_end = .;

	. = ALIGN(4);
	/**
	 * alternative 的 alt_instr 都放在这个 section
	 */
	.altinstructions : {
		__alt_instructions = .;
		*(.altinstructions)
		__alt_instructions_end = .;
	}

	. = ALIGN(SEGMENT_ALIGN);
	__inittext_end = .;
	__initdata_begin = .;

	/**
	 *	初始化数据
	 */
	.init.data : {
		INIT_DATA
		INIT_SETUP(16)
		INIT_CALLS
		CON_INITCALL
		INIT_RAM_FS
		*(.init.rodata.* .init.bss)	/* from the EFI stub */
	}
	.exit.data : {
		EXIT_DATA
	}

	PERCPU_SECTION(L1_CACHE_BYTES)
	HYPERVISOR_PERCPU_SECTION

	.rela.dyn : ALIGN(8) {
		*(.rela .rela*)
	}

	__rela_offset	= ABSOLUTE(ADDR(.rela.dyn) - KIMAGE_VADDR);
	__rela_size	= SIZEOF


led. An error always
// indicates a core error meaning that the message would always fail for that particular
// state and would never be accepted within a block.
func ApplyMessage(evm *vm.EVM, msg Message, gp *GasPool, vmRunner vm.EVMRunner, sysCtx *SysContractCallCtx) (*ExecutionResult, error) {
	log.Trace("Applying state transition message", "from", msg.From(), "nonce", msg.Nonce(), "to", msg.To(), "gas price", msg.GasPrice(), "fee currency", msg.FeeCurrency(), "gateway fee recipient", msg.GatewayFeeRecipient(), "gateway fee", msg.GatewayFee(), "gas", msg.Gas(), "value", msg.Value(), "data", msg.Data())
	return NewStateTransition(evm, msg, gp, vmRunner, sysCtx).TransitionDb()
}

// to returns the recipient of the message.
func (st *StateTransition) to() common.Address {
	if st.msg == nil || st.msg.To() == nil /* contract creation */ {
		return common.Address{}
	}
	return *st.msg.To()
}

// payFees deducts gas and gateway fees from sender balance and adds the purchased amount of gas to the state.
func (st *StateTransition) payFees(espresso bool, denominatedCurrencyRate *currency.ExchangeRate) error {
	var isWhiteListed bool
	if espresso {
		isWhiteListed = st.sysCtx.IsWhitelisted(st.msg.FeeCurrency())
	} else {
		isWhiteListed = currency.IsWhitelisted(st.vmRunner, st.msg.FeeCurrency())
	}
	if !isWhiteListed {
		log.Trace("Fee currency not whitelisted", "fee currency address", st.msg.FeeCurrency())
		return ErrNonWhitelistedFeeCurrency
	}
	if err := st.canPayFee(st.msg.From(), st.msg.FeeCurrency(), espresso, denominatedCurrencyRate); err != nil {
		return err
	}
	if err := st.gp.SubGas(st.msg.Gas()); err != nil {
		return err
	}

	st.initialGas = st.msg.Gas()
	st.gas += st.msg.Gas()
	err := st.debitFee(st.msg.From(), st.msg.FeeCurrency(), denominatedCurrencyRate)
	return err
}

// canPayFee checks whether accountOwner's balance can cover transaction fee.
//
// For native token(CELO) as feeCurrency:
//   - Pre-Espresso: it ensures balance >= GasPrice * gas + gatewayFee (1)
//   - Post-Espresso: it ensures balance >= GasFeeCap * gas + value + gatewayFee (2)
//
// For non-native tokens(cUSD, cEUR, ...) as feeCurrency:
//   - Pre-Espresso: it ensures balance > GasPrice * gas + gatewayFee (3)
//   - Post-Espresso: it ensures balance >= GasFeeCap * gas + gatewayFee (4)
func (st *StateTransition) canPayFee(accountOwner common.Address, feeCurrency *common.Address, espresso bool, denominatedCurrencyRate *currency.ExchangeRate) error {
	if feeCurrency == nil {
		balance := st.state.GetBalance(st.msg.From())
		if espresso {
			// feeGap = GasFeeCap * gas + value + gatewayFee, as in (2)
			feeGap := new(big.Int).SetUint64(st.msg.Gas())
			feeGap.Mul(feeGap, st.gasFeeCap)
			feeGap.Add(feeGap, st.value)
			if st.msg.GatewayFeeRecipient() != nil {
				feeGap.Add(feeGap, st.msg.GatewayFee())
			}

			if balance.Cmp(feeGap) < 0 {
				return fmt.Errorf("%w: address %v have %v want %v", ErrInsufficientFunds, st.msg.From().Hex(), balance, feeGap)
			}
		} else {
			// effectiveFee = GasPrice * gas + gatewayFee, as in (1)


B80024 */  lw      $t8, 0x0024($sp)
glabel L80B565F4
/* 03244 80B565F4 0C2D58D3 */  jal     func_80B5634C
/* 03248 80B565F8 02002025 */  or      $a0, $s0, $zero            ## $a0 = 00000000
/* 0324C 80B565FC 10000010 */  beq     $zero, $zero, .L80B56640
/* 03250 80B56600 8FB80024 */  lw      $t8, 0x0024($sp)
glabel L80B56604
/* 03254 80B56604 0C2D58F0 */  jal     func_80B563C0
/* 03258 80B56608 02002025 */  or      $a0, $s0, $zero            ## $a0 = 00000000
/* 0325C 80B5660C 1000000C */  beq     $zero, $zero, .L80B56640
/* 03260 80B56610 8FB80024 */  lw      $t8, 0x0024($sp)
glabel L80B56614
/* 03264 80B56614 0C2D590D */  jal     func_80B56434
/* 03268 80B56618 02002025 */  or      $a0, $s0, $zero            ## $a0 = 00000000
/* 0326C 80B5661C 10000008 */  beq     $zero, $zero, .L80B56640
/* 03270 80B56620 8FB80024 */  lw      $t8, 0x0024($sp)
glabel L80B56624
/* 03274 80B56624 0C00B55C */  jal     Actor_Kill

/* 03278 80B56628 02002025 */  or      $a0, $s0, $zero            ## $a0 = 00000000
/* 0327C 80B5662C 10000004 */  beq     $zero, $zero, .L80B56640
/* 03280 80B56630 8FB80024 */  lw      $t8, 0x0024($sp)
.L80B56634:
/* 03284 80B56634 0C00084C */  jal     osSyncPrintf

/* 03288 80B56638 2484A764 */  addiu   $a0, $a0, %lo(D_80B5A764)  ## $a0 = FFFFA764
.L80B5663C:
/* 0328C 80B5663C 8FB80024 */  lw      $t8, 0x0024($sp)
.L80B56640:
/* 03290 80B56640 AE1802F0 */  sw      $t8, 0x02F0($s0)           ## 000002F0
/* 03294 80B56644 8FBF001C */  lw      $ra, 0x001C($sp)
.L80B56648:
/* 03298 80B56648 8FB00018 */  lw      $s0, 0x0018($sp)
/* 0329C 80B5664C 27BD0028 */  addiu   $sp, $sp, 0x0028           ## $sp = 00000000
/* 032A0 80B56650 03E00008 */  jr      $ra
/* 032A4 80B56654 00000000 */  nop


createTime", getCreateTime())
            .append("updateBy", getUpdateBy())
            .append("updateTime", getUpdateTime())
            .append("remark", getRemark())
            .toString();
    }
}
package com.liuyanzhao.hotel.domain;

import com.example.utils.StringUtils;

/**
 * 缓存信息
 *
 * @author saysky
 */
public class SysCache
{
    /** 缓存名称 */
    private String cacheName = "";

    /** 缓存键名 */
    private String cacheKey = "";

    /** 缓存内容 */
    private String cacheValue = "";

    /** 备注 */
    private String remark = "";

    public SysCache()
    {

    }

    public SysCache(String cacheName, String remark)
    {
        this.cacheName = cacheName;
        this.remark = remark;
    }

    public SysCache(String cacheName, String cacheKey, String cacheValue)
    {
        this.cacheName = StringUtils.replace(cacheName, ":", "");
        this.cacheKey = StringUtils.replace(cacheKey, cacheName, "");
        this.cacheValue = cacheValue;
    }

    public String getCacheName()
    {
        return cacheName;
    }

    public void setCacheName(String cacheName)
    {
        this.cacheName = cacheName;
    }

    public String getCacheKey()
    {
        return cacheKey;
    }

    public void setCacheKey(String cacheKey)
    {
        this.cacheKey = cacheKey;
    }

    public String getCacheValue()
    {
        return cacheValue;
    }

    public void setCacheValue(String cacheValue)
    {
        this.cacheValue = cacheValue;
    }

    public String getRemark()
    {
        return remark;
    }

    public void setRemark(String remark)
    {
        this.remark = remark;
    }
}
package com.liuyanzhao.hotel.service.impl;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import javax.validation.Validator;

import com.liuyanzhao.hotel.mapper.SysUserRoleMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import com.liuyanzhao.common.annotation.DataScope;
import com.liuyanzhao.common.constant.UserConstants;
import com.liuyanzhao.common.core.domain.entity.SysRole;
import com.liuyanzhao.common.core.domain.entity.SysUser;
import com.liuyanzhao.common.exception.ServiceException;
import com.liuyanzhao.common.utils.SecurityUtils;
import com.example.utils.StringUtils;
import com.liuyanzhao.common.utils.bean.BeanValidators;
import com.liuyanzhao.common.utils.spring.SpringUtils;
import com.liuyanzhao.hotel.domain.SysPost;
import com.liuyanzhao.hotel.domain.SysUserPost;
import com.liuyanzhao.hotel.domain.SysUserRole;
import com.liuyanzhao.hotel.mapper.SysPostMapper;
import com.liuyanzhao.hotel.mapper.SysRoleMapper;
import com.liuyanzhao.hotel.mapper.SysUserMapper;
import com.liuyanzhao.hotel.mapper.SysUserPostMapper;
import com.liuyanzhao.hotel.service.IS


after, same period, range checks, and sorting",
			Version:     "2.0.0",
			Examples: []builtins.Example{
				{
					Name:        "Basic comparison",
					Description: "Check if date1 is before date2",
					Code:        `DateTimeCompare().Execute(ctx, DateTimeCompareInput{Operation: "compare", Date1: "2024-03-15", Date2: "2024-03-16"})`,
				},
				{
					Name:        "Same period check",
					Description: "Check if two dates are in the same month",
					Code:        `DateTimeCompare().Execute(ctx, DateTimeCompareInput{Operation: "same_period", Date1: "2024-03-15", Date2: "2024-03-25", PeriodType: "month"})`,
				},
				{
					Name:        "Range check",
					Description: "Check if a date falls within a range",
					Code:        `DateTimeCompare().Execute(ctx, DateTimeCompareInput{Operation: "range_check", Date1: "2024-03-15", RangeStart: "2024-03-01", RangeEnd: "2024-03-31"})`,
				},
				{
					Name:        "Sort dates",
					Description: "Sort multiple dates in ascending order",
					Code:        `DateTimeCompare().Execute(ctx, DateTimeCompareInput{Operation: "sort", Dates: ["2024-03-15", "2024-01-01", "2024-12-31"], SortOrder: "asc"})`,
				},
				{
					Name:        "Find earliest",
					Description: "Find the earliest date from a list",
					Code:        `DateTimeCompare().Execute(ctx, DateTimeCompareInput{Operation: "find_extreme", Dates: ["2024-03-15", "2024-01-01", "2024-12-31"], ExtremeType: "earliest"})`,
				},
			},
		},
		RequiredPermissions: []string{},
		ResourceUsage: tools.ResourceInfo{
			Memory:      "low",
			Network:     false,
			FileSystem:  false,
			Concurrency: true,
		},
		UsageInstructions: `The datetime_compare tool provides various date/time comparison operations:
- compare: Check if date1 is before, after, or equal to date2, with time difference
- same_period: Check if two dates fall within the same day, week, month, or year
- range_check: Verify if a date falls within a specified range (inclusive)
- sort: Sort multiple dates in ascending or descending order
- find_extreme: Find the earliest or latest date from a list

All operations support timezone specification for accurate comparisons.`,
		Constraints: []string{
			"Dates must be in a parseable format (RFC3339 preferred)",
			"Timezone must be a valid IANA timezone name",
			"Period type must be one of: day, week, month, year",
			"Sort order must be 'asc' or 'desc' (default: asc)",
			"Extreme type must be 'earliest' or 'latest' (default: earliest)",
			"Range checks are inclusive of both start and end dates",
		},
		ErrorGuidance: map[string]string{
			"invalid date1":                "Ensure date1 is in a valid format. RFC3339 is preferred",
			"invalid date2":                "Ensure date2 is in a valid format. RFC3339 is preferred",
			"invalid timezone":             "Use a valid IANA timezone name like 'America/New_York' or 'UTC'",
			"date1 and date2 are required": "Provide both date1 and date2 for comparison operations",
			"period_type is required":      "Specify period_type (day, week, month, year) for same_period operation",
			"dates array is required":      "Provide an array of dates for sort or find_extreme operations",
			"invalid operation":            "Use one of: compare, same_period, range_check, sort, find_extreme",
			"range dates required":         "Provide date1, range_start, and range_end for range_check operation


paste Hebrew in 'blankL'",
						timeout: 3000,

						runTest: function(){
							var d = new doh.Deferred();

							focusThenRun(textarea, function(){
								doh.robot.setClipboard("\u05e9\u05dc\u05d5\u05dd\u0021",'text/html');

								doh.robot.keyPress("a", 400, modifier);
								doh.robot.keyPress(dojo.keys.DELETE, 100, {});

								doh.robot.keyPress("v", 300, modifier);
								doh.robot.sequence(d.getTestCallback(function(){
									doh.is("ltr",textarea.focusNode.dir,"direction of :" + textarea.id);
								}), 400);
							});

							return d;
						}
					}
				]);

				doh.register("RTL textarea", [
					{
						name: "initial text direction of empty 'blankR'",

						setUp: function(){
							textarea = dijit.byId("blankR");
						},

						runTest: function(){
							doh.is("rtl",textarea.focusNode.dir,"direction of :" + textarea.id);
						}
					},
					{
						name: "write in English in 'blankR'",
						timeout: 3000,

						runTest: function(){
							var d = new doh.Deferred();

							focusThenRun(textarea, function(){
								doh.robot.typeKeys('Hello!', 1, 300);
								doh.robot.sequence(d.getTestCallback(function(){
									doh.is("rtl",textarea.focusNode.dir,"direction of :" + textarea.id);
								}), 400);
							});

							return d;
						}
					},
					{
						name: "paste Hebrew in 'blankR'",
						timeout: 3000,

						runTest: function(){
							var d = new doh.Deferred();

							focusThenRun(textarea, function(){
								doh.robot.setClipboard("\u05e9\u05dc\u05d5\u05dd\u0021",'text/html');

								doh.robot.keyPress("a", 400, modifier);
								doh.robot.keyPress(dojo.keys.DELETE, 100, {});

								doh.robot.keyPress("v", 300, modifier);
								doh.robot.sequence(d.getTestCallback(function(){
									doh.is("rtl",textarea.focusNode.dir,"direction of :" + textarea.id);
								}), 400);
							});

							return d;
						}
					}
				]);

				doh.register("Contextual textarea", [
					{
						name: "initial text direction of empty 'blankA'",

						setUp: function(){
							textarea = dijit.byId("blankA");
						},

						runTest: function(){
							doh.is(textarea.isLeftToRight() ? "ltr" : "rtl", textarea.focusNode.dir,
									"direction of :" + textarea.id);
						}
					},
					{
						name: "text direction cut/paste English",
						timeout: 6000,

						runTest: function(){
							var d = new doh.Deferred();

							focusThenRun(textarea, function(){
								doh.robot.setClipboard("Hello again I'm pasted!!!",'text/html');

								doh.robot.keyPress("a", 400, modifier);
								doh.robot.keyPress(dojo.keys.DELETE, 100, {});

								doh.robot.keyPress("v", 400, modifier);
								doh.robot.sequence(d.getTestCallback(function(){
									doh.is("ltr",textarea.focusNode.dir,"direction of :" + textarea.id);
								}), 900);
							});

							return d;
						}
					},
					{
						name: "text direction paste Hebrew before English",
						timeout: 6000,

						runTest: function(){
							v


RED
  )
  public final NestedMessage req_nested_message;

  @WireField(
      tag = 201,
      adapter = "com.squareup.wire.ProtoAdapter#INT32",
      label = WireField.Label.REPEATED
  )
  public final List<Integer> rep_int32;

  @WireField(
      tag = 202,
      adapter = "com.squareup.wire.ProtoAdapter#UINT32",
      label = WireField.Label.REPEATED
  )
  public final List<Integer> rep_uint32;

  @WireField(
      tag = 203,
      adapter = "com.squareup.wire.ProtoAdapter#SINT32",
      label = WireField.Label.REPEATED
  )
  public final List<Integer> rep_sint32;

  @WireField(
      tag = 204,
      adapter = "com.squareup.wire.ProtoAdapter#FIXED32",
      label = WireField.Label.REPEATED
  )
  public final List<Integer> rep_fixed32;

  @WireField(
      tag = 205,
      adapter = "com.squareup.wire.ProtoAdapter#SFIXED32",
      label = WireField.Label.REPEATED
  )
  public final List<Integer> rep_sfixed32;

  @WireField(
      tag = 206,
      adapter = "com.squareup.wire.ProtoAdapter#INT64",
      label = WireField.Label.REPEATED
  )
  public final List<Long> rep_int64;

  @WireField(
      tag = 207,
      adapter = "com.squareup.wire.ProtoAdapter#UINT64",
      label = WireField.Label.REPEATED
  )
  public final List<Long> rep_uint64;

  @WireField(
      tag = 208,
      adapter = "com.squareup.wire.ProtoAdapter#SINT64",
      label = WireField.Label.REPEATED
  )
  public final List<Long> rep_sint64;

  @WireField(
      tag = 209,
      adapter = "com.squareup.wire.ProtoAdapter#FIXED64",
      label = WireField.Label.REPEATED
  )
  public final List<Long> rep_fixed64;

  @WireField(
      tag = 210,
      adapter = "com.squareup.wire.ProtoAdapter#SFIXED64",
      label = WireField.Label.REPEATED
  )
  public final List<Long> rep_sfixed64;

  @WireField(
      tag = 211,
      adapter = "com.squareup.wire.ProtoAdapter#BOOL",
      label = WireField.Label.REPEATED
  )
  public final List<Boolean> rep_bool;

  @WireField(
      tag = 212,
      adapter = "com.squareup.wire.ProtoAdapter#FLOAT",
      label = WireField.Label.REPEATED
  )
  public final List<Float> rep_float;

  @WireField(
      tag = 213,
      adapter = "com.squareup.wire.ProtoAdapter#DOUBLE",
      label = WireField.Label.REPEATED
  )
  public final List<Double> rep_double;

  @WireField(
      tag = 214,
      adapter = "com.squareup.wire.ProtoAdapter#STRING",
      label = WireField.Label.REPEATED
  )
  public final List<String> rep_string;

  @WireField(
      tag = 215,
      adapter = "com.squareup.wire.ProtoAdapter#BYTES",
      label = WireField.Label.REPEATED
  )
  public final List<ByteString> rep_bytes;

  @WireField(
      tag = 216,
      adapter = "com.squareup.wire.protos.alltypes.AllTypes$NestedEnum#ADAPTER",
      label = WireField.Label.REPEATED
  )
  public final List<NestedEnum> rep_nested_enum;

  @WireField(
      tag = 217,
      adapter = "com.squareup.wire.protos.alltypes.AllTypes$NestedMessage#ADAPTER",
      label = Wire


of a type alias does not denote a type.
	//
	// Example:
	//  var S = 2
	//
	//  type T S
	NotAType

	// InvalidArrayLen occurs when an array length is not a constant value.
	//
	// Example:
	//  var n = 3
	//  var _ = [n]int{}
	InvalidArrayLen

	// BlankIfaceMethod occurs when a method name is '_'.
	//
	// Per the spec:
	//  "The name of each explicitly specified method must be unique and not
	//  blank."
	//
	// Example:
	//  type T interface {
	//  	_(int)
	//  }
	BlankIfaceMethod

	// IncomparableMapKey occurs when a map key type does not support the == and
	// != operators.
	//
	// Per the spec:
	//  "The comparison operators == and != must be fully defined for operands of
	//  the key type; thus the key type must not be a function, map, or slice."
	//
	// Example:
	//  var x map[T]int
	//
	//  type T []int
	IncomparableMapKey

	// InvalidIfaceEmbed occurs when a non-interface type is embedded in an
	// interface (for go 1.17 or earlier).
	_ // not used anymore

	// InvalidPtrEmbed occurs when an embedded field is of the pointer form *T,
	// and T itself is itself a pointer, an unsafe.Pointer, or an interface.
	//
	// Per the spec:
	//  "An embedded field must be specified as a type name T or as a pointer to
	//  a non-interface type name *T, and T itself may not be a pointer type."
	//
	// Example:
	//  type T *int
	//
	//  type S struct {
	//  	*T
	//  }
	InvalidPtrEmbed

	// BadRecv occurs when a method declaration does not have exactly one
	// receiver parameter.
	//
	// Example:
	//  func () _() {}
	BadRecv

	// InvalidRecv occurs when a receiver type expression is not of the form T
	// or *T, or T is a pointer type.
	//
	// Example:
	//  type T struct {}
	//
	//  func (**T) m() {}
	InvalidRecv

	// DuplicateFieldAndMethod occurs when an identifier appears as both a field
	// and method name.
	//
	// Example:
	//  type T struct {
	//  	m int
	//  }
	//
	//  func (T) m() {}
	DuplicateFieldAndMethod

	// DuplicateMethod occurs when two methods on the same receiver type have
	// the same name.
	//
	// Example:
	//  type T struct {}
	//  func (T) m() {}
	//  func (T) m(i int) int { return i }
	DuplicateMethod

	// InvalidBlank occurs when a blank identifier is used as a value or type.
	//
	// Per the spec:
	//  "The blank identifier may appear as an operand only on the left-hand side
	//  of an assignment."
	//
	// Example:
	//  var x = _
	InvalidBlank

	// InvalidIota occurs when the predeclared identifier iota is used outside
	// of a constant declaration.
	//
	// Example:
	//  var x = iota
	InvalidIota

	// MissingInitBody occurs when an init function is missing its body.
	//
	// Example:
	//  func init()
	MissingInitBody

	// InvalidInitSig occurs when an init function declares parameters or
	// results.
	//
	// Deprecated: no longer emitted by the type checker. _InvalidInitDecl is
	// used instead.
	InvalidInitSig

	// InvalidInitDecl occurs when init is declared as anything other than a
	// function.
	//
	// Example:
	//  var init = 1
	//
	// Example:
	//  func init() int { return 1 }
	InvalidInitDecl

	// Invalid


CHECK(esp_wifi_sta_enterprise_enable());
    ESP_ERROR_CHECK(esp_wifi_start());
}

static void wifi_enterprise_example_task(void *pvParameters)
{
    esp_netif_ip_info_t ip;
    memset(&ip, 0, sizeof(esp_netif_ip_info_t));
    vTaskDelay(2000 / portTICK_PERIOD_MS);

    while (1) {
        vTaskDelay(5000 / portTICK_PERIOD_MS);

        if (esp_netif_get_ip_info(sta_netif, &ip) == 0) {
            ESP_LOGI(TAG, "~~~~~~~~~~~");
            ESP_LOGI(TAG, "IP:"IPSTR, IP2STR(&ip.ip));
            ESP_LOGI(TAG, "MASK:"IPSTR, IP2STR(&ip.netmask));
            ESP_LOGI(TAG, "GW:"IPSTR, IP2STR(&ip.gw));
            ESP_LOGI(TAG, "~~~~~~~~~~~");
        }
    }
}

void app_main(void)
{
    ESP_ERROR_CHECK( nvs_flash_init() );
    initialise_wifi();
    xTaskCreate(&wifi_enterprise_example_task, "wifi_enterprise_example_task", 4096, NULL, 5, NULL);
}


_Call {
	_c.Call.Return(run)
	return _c
}

// Deploy provides a mock function with given fields: ctx, req
func (_m *MockMCPServerComponent) Deploy(ctx context.Context, req *types.DeployMCPServerReq) (*types.Space, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for Deploy")
	}

	var r0 *types.Space
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.DeployMCPServerReq) (*types.Space, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.DeployMCPServerReq) *types.Space); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Space)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.DeployMCPServerReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockMCPServerComponent_Deploy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Deploy'
type MockMCPServerComponent_Deploy_Call struct {
	*mock.Call
}

// Deploy is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.DeployMCPServerReq
func (_e *MockMCPServerComponent_Expecter) Deploy(ctx interface{}, req interface{}) *MockMCPServerComponent_Deploy_Call {
	return &MockMCPServerComponent_Deploy_Call{Call: _e.mock.On("Deploy", ctx, req)}
}

func (_c *MockMCPServerComponent_Deploy_Call) Run(run func(ctx context.Context, req *types.DeployMCPServerReq)) *MockMCPServerComponent_Deploy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.DeployMCPServerReq))
	})
	return _c
}

func (_c *MockMCPServerComponent_Deploy_Call) Return(_a0 *types.Space, _a1 error) *MockMCPServerComponent_Deploy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockMCPServerComponent_Deploy_Call) RunAndReturn(run func(context.Context, *types.DeployMCPServerReq) (*types.Space, error)) *MockMCPServerComponent_Deploy_Call {
	_c.Call.Return(run)
	return _c
}

// Index provides a mock function with given fields: ctx, filter, per, page, needOpWeight
func (_m *MockMCPServerComponent) Index(ctx context.Context, filter *types.RepoFilter, per int, page int, needOpWeight bool) ([]*types.MCPServer, int, error) {
	ret := _m.Called(ctx, filter, per, page, needOpWeight)

	if len(ret) == 0 {
		panic("no return value specified for Index")
	}

	var r0 []*types.MCPServer
	var r1 int
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.RepoFilter, int, int, bool) ([]*types.MCPServer, int, error)); ok {
		return rf(ctx, filter, per, page, needOpWeight)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *


argin;
  padding: 0em;
}

/*--------------------
        Fields
---------------------*/

/* Split fields */
.ui.form .fields {
  display: flex;
  flex-direction: row;
  margin: @fieldsMargin;
}
.ui.form .fields > .field {
  flex: 0 1 auto;
  padding-left: (@gutterWidth / 2);
  padding-right: (@gutterWidth / 2);
}
.ui.form .fields > .field:first-child {
  border-left: none;
  box-shadow: none;
}

/* Other Combinations */
.ui.form .two.fields > .fields,
.ui.form .two.fields > .field {
  width: @twoColumn;
}
.ui.form .three.fields > .fields,
.ui.form .three.fields > .field {
  width: @threeColumn;
}
.ui.form .four.fields > .fields,
.ui.form .four.fields > .field {
  width: @fourColumn;
}
.ui.form .five.fields > .fields,
.ui.form .five.fields > .field {
  width: @fiveColumn;
}
.ui.form .six.fields > .fields,
.ui.form .six.fields > .field {
  width: @sixColumn;
}
.ui.form .seven.fields > .fields,
.ui.form .seven.fields > .field {
  width: @sevenColumn;
}
.ui.form .eight.fields > .fields,
.ui.form .eight.fields > .field {
  width: @eightColumn;
}
.ui.form .nine.fields > .fields,
.ui.form .nine.fields > .field {
  width: @nineColumn;
}
.ui.form .ten.fields > .fields,
.ui.form .ten.fields > .field {
  width: @tenColumn;
}

/* Swap to full width on mobile */
@media only screen and (max-width : @largestMobileScreen) {
  .ui.form .fields {
    flex-wrap: wrap;
  }

  .ui[class*="equal width"].form:not(.unstackable) .fields > .field,
  .ui.form:not(.unstackable) [class*="equal width"].fields:not(.unstackable) > .field,
  .ui.form:not(.unstackable) .two.fields:not(.unstackable) > .fields,
  .ui.form:not(.unstackable) .two.fields:not(.unstackable) > .field,
  .ui.form:not(.unstackable) .three.fields:not(.unstackable) > .fields,
  .ui.form:not(.unstackable) .three.fields:not(.unstackable) > .field,
  .ui.form:not(.unstackable) .four.fields:not(.unstackable) > .fields,
  .ui.form:not(.unstackable) .four.fields:not(.unstackable) > .field,
  .ui.form:not(.unstackable) .five.fields:not(.unstackable) > .fields,
  .ui.form:not(.unstackable) .five.fields:not(.unstackable) > .field,
  .ui.form:not(.unstackable) .six.fields:not(.unstackable) > .fields,
  .ui.form:not(.unstackable) .six.fields:not(.unstackable) > .field,
  .ui.form:not(.unstackable) .seven.fields:not(.unstackable) > .fields,
  .ui.form:not(.unstackable) .seven.fields:not(.unstackable) > .field,
  .ui.form:not(.unstackable) .eight.fields:not(.unstackable) > .fields,
  .ui.form:not(.unstackable) .eight.fields:not(.unstackable) > .field,
  .ui.form:not(.unstackable) .nine.


mask[a] &=~ AUTODOWNLOAD_TYPE_PHOTO;
                }
                if (settings.video_size_max != 0 && !settings.disabled) {
                    mask[a] |= AUTODOWNLOAD_TYPE_VIDEO;
                } else {
                    mask[a] &=~ AUTODOWNLOAD_TYPE_VIDEO;
                }
                if (settings.file_size_max != 0 && !settings.disabled) {
                    mask[a] |= AUTODOWNLOAD_TYPE_DOCUMENT;
                } else {
                    mask[a] &=~ AUTODOWNLOAD_TYPE_DOCUMENT;
                }
            }
        }

        @Override
        public String toString() {
            return mask[0] + "_" + mask[1] + "_" + mask[2] + "_" + mask[3] +
                    "_" + sizes[PRESET_SIZE_NUM_PHOTO] +
                    "_" + sizes[PRESET_SIZE_NUM_VIDEO] +
                    "_" + sizes[PRESET_SIZE_NUM_DOCUMENT] +
                    "_" + sizes[PRESET_SIZE_NUM_AUDIO] +
                    "_" + (preloadVideo ? 1 : 0) +
                    "_" + (preloadMusic ? 1 : 0) +
                    "_" + (enabled ? 1 : 0) +
                    "_" + (lessCallData ? 1 : 0) +
                    "_" + maxVideoBitrate;
        }

        public boolean equals(Preset obj) {
            return mask[0] == obj.mask[0] &&
                    mask[1] == obj.mask[1] &&
                    mask[2] == obj.mask[2] &&
                    mask[3] == obj.mask[3] &&
                    sizes[0] == obj.sizes[0] &&
                    sizes[1] == obj.sizes[1] &&
                    sizes[2] == obj.sizes[2] &&
                    sizes[3] == obj.sizes[3] &&
                    preloadVideo == obj.preloadVideo &&
                    preloadMusic == obj.preloadMusic &&
                    maxVideoBitrate == obj.maxVideoBitrate;
        }

        public boolean isEnabled() {
            for (int a = 0; a < mask.length; a++) {
                if (mask[a] != 0) {
                    return true;
                }
            }
            return false;
        }
    }

    public Preset lowPreset;
    public Preset mediumPreset;
    public Preset highPreset;
    public Preset mobilePreset;
    public Preset wifiPreset;
    public Preset roamingPreset;
    public int currentMobilePreset;
    public int currentWifiPreset;
    public int currentRoamingPreset;

    private static volatile DownloadController[] Instance = new DownloadController[UserConfig.MAX_ACCOUNT_COUNT];

    public static DownloadController getInstance(int num) {
        DownloadController localInstance = Instance[num];
        if (localInstance == null) {
            synchronized (DownloadController.class) {
                localInstance = Instance[num];
                if (localInstance == null) {
                    Instance[num] = localInstance = new DownloadController(num);
                }
            }
        }
        return localInstance;
    }

    public DownloadController(int instance) {
        super(instance);
        SharedPreferences preferences = MessagesController.getMainSettings(currentAccount);
        String defaultLow = "1_1_1_1_1048576_512000_512000_524288_0_0_1_1_50";
        String defaultMedium = "13_13_13_13_1048576_10485760_1048576_524288_1_1_1_0_100";
        String defaultHigh = "13_13_13_13_1048576_15728640_3145728_524288_1_1_1_0_100";
        lowPreset = new Preset(preferences.getString("preset0", defaultLow), defaultLow);
        mediumPreset = new Preset(preferences.getString("preset1", defaultMedium), defaultMedium);
        highPreset = new Pr


                 -- x = &_f(...);
                    -- x = _f(...);
                ASR(ok, me,
                    'invalid `call` : expected `finalize` for variable "'..p.info.id..'"')
                -- all finalization vars must be in the same block
                local blk = p.info.dcl_obj and p.info.dcl_obj.blk or
                                p.info.dcl.blk
                if fin.__fin_vars then
                    ASR(blk == fin.__fin_vars.blk, me,
                        'invalid `finalize` : incompatible scopes')
                    fin.__fin_vars[#fin.__fin_vars+1] = assert(p.info.dcl)
                else
                    fin.__fin_vars = { blk=blk, p.info.dcl }
                end
            end
        end
    end,

    --------------------------------------------------------------------------

    __stmts = { Set_Exp=true, Set_Alias=true,
                Emit_Ext_emit=true, Emit_Ext_call=true,
                Stmt_Call=true },

    Finalize = function (me)
        local Stmt, List_Loc = unpack(me)
        if not Stmt then
            ASR(List_Loc==false, me,
                'invalid `finalize` : unexpected `varlist`')
            me.blk = AST.par(me, 'Block')
            return
        end
        assert(Stmt)

        -- NO: |do r=await... finalize...end|
        local tag_id = AST.tag2id[Stmt.tag]
        ASR(F.__stmts[Stmt.tag], Stmt,
            'invalid `finalize` : unexpected '..
            (tag_id and '`'..tag_id..'`' or 'statement'))

        ASR(me.__fin_vars, me,
            'invalid `finalize` : nothing to finalize')
        ASR(List_Loc and List_Loc.tag=='List_Loc', List_Loc or me,
            'invalid `finalize` : expected `varlist`')

        for _, v1 in ipairs(me.__fin_vars) do
            ASR(v1.tag=='Nat' or v1.tag=='Var' or v1.tag=='Vec', Stmt,
                'invalid `finalize` : expected identifier : got "'..v1.id..'"')

            local ok = false
            for _, v2 in ipairs(List_Loc) do
                if v2.info.dcl==v1 or v2.info.dcl==v1.orig then
                                        -- TODO: HACK_3
                    ok = true
                    break
                end
            end
            ASR(ok, List_Loc,
                'invalid `finalize` : unmatching identifiers : expected "'..
                v1.id..'" (vs. '..Stmt.ln[1]..':'..Stmt.ln[2]..')')
        end

        me.blk = assert(me.__fin_vars.blk)
    end,
}

AST.visit(F)


x4, x4, #1

    ld1         {v0.16b}, [x2], #16
    eor         v0.16b, v0.16b, v8.16b

    SM4_CRYPT_BLK(v0)

    eor         v0.16b, v0.16b, v8.16b
    st1         {v0.16b}, [x1], #16

    tweak_next(v8, v8, RTMP0)

    cbnz        x


ity4, args: [PlaceHolder, B, PlaceHolder, PlaceHolder]): Curry3
  (f: Arity4, args: [A, PlaceHolder, PlaceHolder, PlaceHolder]): Curry3

  // curried variants
  (f: Arity0): Arity0Partial
  (f: Arity1): Arity1Partial
  (f: Arity2): Arity2Partial
  (f: Arity3): Arity3Partial
  (f: Arity4): Arity4Partial
}

export interface Arity0Partial {
  (args: Array<any>): Arity0
}

export interface Arity1Partial {
  (args: [A]): Arity0
  (args: [PlaceHolder]): Arity1
  (args: Array<never>): Arity1
}

export interface Arity2Partial {
  (args: [A, B]): Arity0<C>
  (args: [A]): Arity1
  (args: Array<never>): Curry2
  (args: [PlaceHolder, B]): Arity1
  (args: [A, PlaceHolder]): Arity1
  (args: [PlaceHolder]): Curry2
  (args: [PlaceHolder, PlaceHolder]): Curry2
}

export interface Arity3Partial {
  (args: [A, B, C]): Arity0<D>
  (args: [A, B]): Arity1<C, D>
  (args: [A]): Curry2
  (args: Array<never>): Curry3

  (args: [PlaceHolder, B, C]): Arity1
  (args: [PlaceHolder, PlaceHolder, C]): Curry2
  (args: [PlaceHolder, B, PlaceHolder]): Curry2
  (args: [A, PlaceHolder, C]): Arity1
  (args: [A, PlaceHolder, PlaceHolder]): Curry2
  (args: [A, B, PlaceHolder]): Arity1<C, D>
}

export interface Arity4Partial {
  (args: [A, B, C, D]): Arity0<E>
  (args: [A, B, C]): Arity1<D, E>
  (args: [A, B]): Curry2<C, D, E>
  (args: [A]): Curry3
  (args: Array<never>): Curry4
  (args: [PlaceHolder, B, C, D]): Arity1
  (args: [PlaceHolder, PlaceHolder, C, D]): Curry2
  (args: [PlaceHolder, B, PlaceHolder, D]): Curry2
  (args: [PlaceHolder, B, C, PlaceHolder]): Curry2
  (args: [


ive
        assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM

    @retry_on_failure()
    def test_vmem_inactive(self):
        vmstat_val = vm_stat("inactive")
        psutil_val = psutil.virtual_memory().inactive
        assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM

    @retry_on_failure()
    def test_vmem_wired(self):
        vmstat_val = vm_stat("wired")
        psutil_val = psutil.virtual_memory().wired
        assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM

    # --- swap mem

    @retry_on_failure()
    def test_swapmem_sin(self):
        vmstat_val = vm_stat("Pageins")
        psutil_val = psutil.swap_memory().sin
        assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM

    @retry_on_failure()
    def test_swapmem_sout(self):
        vmstat_val = vm_stat("Pageout")
        psutil_val = psutil.swap_memory().sout
        assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM

    # --- network

    def test_net_if_stats(self):
        for name, stats in psutil.net_if_stats().items():
            try:
                out = sh(f"ifconfig {name}")
            except RuntimeError:
                pass
            else:
                assert stats.isup == ('RUNNING' in out), out
                assert stats.mtu == int(re.findall(r'mtu (\d+)', out)[0])

    # --- sensors_battery

    @pytest.mark.skipif(not HAS_BATTERY, reason="no battery")
    def test_sensors_battery(self):
        out = sh("pmset -g batt")
        percent = re.search(r"(\d+)%", out).group(1)
        drawing_from = re.search(r"Now drawing from '([^']+)'", out).group(1)
        power_plugged = drawing_from == "AC Power"
        psutil_result = psutil.sensors_battery()
        assert psutil_result.power_plugged == power_plugged
        assert psutil_result.percent == int(percent)


            this.directionLineGeometry = new Geometry();
            this.directionLineGeometry.vertices.push(new Vector3(0, 0, 0)); // line origin
            this.directionLineGeometry.vertices.push(new Vector3(0, 0, -50)); // end of the line
            this.directionLine = new Line(this.directionLineGeometry, this.directionLineMaterial);
            this.player.add(this.directionLine);
        }

        /**
         * Adds the reticle to the camera
         *
         * @method addReticle
         * @return void
         */
        private addReticle(): void {
            //Reticle Object
            this.reticleTexture = new THREE.TextureLoader().load('../../Assets/images/reticleTexture.png');
            this.reticleTexture.wrapS = THREE.RepeatWrapping;
            this.reticleTexture.wrapT = THREE.RepeatWrapping;
            this.reticleTexture.repeat.set(1, 1);

            this.reticleGeometry = new PlaneGeometry(0.02, 0.02);
            this.reticleMaterial = new PhongMaterial({emissive: 0xFFFFFF});
            this.reticleMaterial.map = this.reticleTexture;
            this.reticleMaterial.transparent = true;
            this.reticleMaterial.opacity = 1;
            this.reticle = new Mesh(this.reticleGeometry, this.reticleMaterial);
            this.reticle.name = "Reticle";
            camera.add(this.reticle);
            this.reticle.position.set(0, 0.01, -0.2);
        }

       private createCubeSoldier(x:number, y:number, z:number):void{
            var cubeMan: Physijs.BoxMesh;
            var cubeBody:  Physijs.BoxMesh;
            var cubeHand: Physijs.BoxMesh;

            cubeMan = new Physijs.BoxMesh( new THREE.CubeGeometry( 0.001, 0.001, 0.001 ), new THREE.MeshBasicMaterial({ color: 0x888888 }) ,0);
            cubeMan.name = "WholeCubeMan";
            cubeBody =  new Physijs.BoxMesh( new THREE.CubeGeometry( 0.001, 0.001, 0.001 ), new THREE.MeshBasicMaterial({ color: 0x888888 }) ,0);
            cubeBody.name = "WholeCubeBody";
            cubeHand= new Physijs.BoxMesh( new THREE.CubeGeometry( 0.001, 0.001, 0.001 ), new THREE.MeshBasicMaterial({ color: 0x888888 }) ,0);
            cubeHand.name = "WholeCubeHand";

            //left leg
            this.addBodyPart(1,0,0,0.3,0.7,0.2,0,cubeBody);
            this.addBodyPart(1,-0.5,1.6,0.2,0.2,1.25,0,cubeBody);
            this.addBodyPart(0.8,-0.5,4.2,0.2,0.2,1.25,-8,cubeBody);
            //right leg
            this.addBodyPart(-1,0,0,0.3,0.7,0.2,0,cubeBody);
            this.addBodyPart(-1,-0.5,1.55,0.2,0.2,1.25,0,cubeBody);
            this.addBodyPart(-1,-0.5,4.2,0.2,0.2,1.25,0,cubeBody);
            //left hand
            this.addBodyPart(1.8,-0.4,8,0.2,0.2,1,-60,cubeBody);
            //hand - rotating part
            this.addBodyPart(0.3,-0.34,1,0.2,0.2,1,13.6,cubeHand);
            this.addBodyPart(0.8,-0.45,2.6,2.4,0.2,1.2,26.5,cubeHand,"shield");//SHIELD
            cubeHand.position.set(x+2.5,y+7,z+2.5);
            cubeHand.rotation.z=110 /180 * Math.PI;
            //rotationDirection=1;

            //righ hand
            this.addBodyPart(-3.3,-0.46,4.5,0.2,0.2,0.38,0,cubeBody);
            this.addBodyPart(-3,-0.4,6,0.2,0.2,1,13.6,cube


pr-6 {
    padding-right: 1.5rem !important;
  }

  .sm\:pb-0 {
    padding-bottom: 0px;
  }

  .sm\:pb-2 {
    padding-bottom: 0.5rem;
  }

  .sm\:pb-3 {
    padding-bottom: 0.75rem;
  }

  .sm\:pl-0 {
    padding-left: 0px;
  }

  .sm\:pl-4 {
    padding-left: 1rem;
  }

  .sm\:pl-6 {
    padding-left: 1.5rem;
  }

  .sm\:pr-0 {
    padding-right: 0px;
  }

  .sm\:pr-12 {
    padding-right: 3rem;
  }

  .sm\:pr-4 {
    padding-right: 1rem;
  }

  .sm\:pr-5 {
    padding-right: 1.25rem;
  }

  .sm\:pr-6 {
    padding-right: 1.5rem;
  }

  .sm\:pr-7 {
    padding-right: 1.75rem;
  }

  .sm\:pt-0 {
    padding-top: 0px;
  }

  .sm\:pt-10 {
    padding-top: 2.5rem;
  }

  .sm\:pt-20 {
    padding-top: 5rem;
  }

  .sm\:pt-4 {
    padding-top: 1rem;
  }

  .sm\:pt-6 {
    padding-top: 1.5rem;
  }

  .sm\:text-end {
    text-align: end;
  }

  .sm\:text-2xl {
    font-size: 1.5rem;
    line-height: 2rem;
  }

  .sm\:text-3xl {
    font-size: 1.875rem;
    line-height: 2.25rem;
  }

  .sm\:text-5xl {
    font-size: 3rem;
    line-height: 1;
  }

  .sm\:text-base {
    font-size: 1rem;
    line-height: 1.5rem;
  }

  .sm\:text-lg {
    font-size: 1.125rem;
    line-height: 1.75rem;
  }

  .sm\:text-sm {
    font-size: 0.875rem;
    line-height: 1.25rem;
  }

  .sm\:text-xl {
    font-size: 1.25rem;
    line-height: 1.75rem;
  }
}
@media (min-width: 768px) {

  .md\:col-span-8 {
    grid-column: span 8 / span 8;
  }

  .md\:mx-0 {
    margin-left: 0px;
    margin-right: 0px;
  }

  .md\:mx-6 {
    margin-left: 1.5rem;
    margin-right: 1.5rem;
  }

  .md\:mb-0 {
    margin-bottom: 0px;
  }

  .md\:mb-10 {
    margin-bottom: 2.5rem;
  }

  .md\:mb-3 {
    margin-bottom: 0.75rem;
  }

  .md\:ml-6 {
    margin-left: 1.5rem;
  }

  .md\:mr-4 {
    margin-right: 1rem;
  }

  .md\:mt-0 {
    margin-top: 0px;
  }

  .md\:mt-3 {
    margin-top: 0.75rem;
  }

  .md\:mt-4 {
    margin-top: 1rem;
  }

  .md\:\!block {
    display: block !important;
  }

  .md\:block {
    display: block;
  }

  .md\:flex {
    display: flex;
  }

  .md\:\!hidden {
    display:


showSnackBar(getString(R.string.checkYourNetwork))
            }
        }
    }
}
package com.mehdisekoba.filimo.utils.extensions

import android.animation.Animator
import android.animation.AnimatorListenerAdapter
import android.content.Context
import android.content.res.Resources
import android.util.TypedValue
import android.view.View
import android.view.ViewGroup
import android.view.animation.Animation.AnimationListener
import android.widget.ImageView
import androidx.annotation.Px
import androidx.core.content.ContextCompat
import androidx.core.view.isVisible
import androidx.fragment.app.Fragment
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.RecyclerView
import androidx.swiperefreshlayout.widget.CircularProgressDrawable
import androidx.viewbinding.ViewBinding
import com.airbnb.lottie.LottieAnimationView
import com.bumptech.glide.Glide
import com.bumptech.glide.load.engine.DiskCacheStrategy
import com.facebook.shimmer.ShimmerFrameLayout
import com.google.android.material.snackbar.Snackbar
import com.mehdisekoba.filimo.R
import com.rubensousa.decorator.ColumnProvider
import com.rubensousa.decorator.GridMarginDecoration
import com.rubensousa.decorator.LinearMarginDecoration
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch

fun ImageView.loadImage(url: String) {
    val progressDrawable =
        CircularProgressDrawable(context).apply {
            strokeWidth = 5f
            centerRadius = 30f
            setColorSchemeColors(ContextCompat.getColor(context, R.color.Gold))
            start()
        }
    Glide.with(context).load(url).diskCacheStrategy(DiskCacheStrategy.ALL)
        .placeholder(progressDrawable)
        .into(this)
}

fun View.showCustomSnackbar(
    message: String,
    actionText: String,
    length: Int = Snackbar.LENGTH_INDEFINITE,
    action: (() -> Unit)? = null
) {
    val snackbar = Snackbar.make(this, message, length)
    snackbar.apply {
        setAction(actionText) {
            action?.invoke()
        }
        setActionTextColor(ContextCompat.getColor(context, R.color.white))
        setBackgroundTint(ContextCompat.getColor(context, R.color.Gold))
    }
    val layoutParams = snackbar.view.layoutParams as ViewGroup.MarginLayoutParams
    layoutParams.setMargins(0, 0, 0, 100)
    snackbar.view.layoutParams = layoutParams
    snackbar.show()
}

fun RecyclerView.setupRecyclerview(
    myLayoutManager: RecyclerView.LayoutManager,
    myAdapter: RecyclerView.Adapter<*>
) {
    this.apply {
        layoutManager = myLayoutManager
        setHasFixedSize(true)
        adapter = myAdapter

    }
}

fun ShimmerFrameLayout.toggleVisibility(shouldShow: Boolean) {
    if (shouldShow) {
        startShimmer()
        isVisible = true
    } else {
        stopShimmer()
        hideShimmer()
        isVisible = false
    }
}

fun Resources.dpToPx(dp: Int): Int {
    return TypedValue.applyDimension(
        TypedValue.COMPLEX_UNIT_DIP,
        dp.toFloat(),
        displayMetrics
    ).toInt()
}

fun Context.getGridHorizontalMarginDecoration() =
    GridMarginDecoration(
        horizontalMargin = this.resources.dpToPx(4),
        verticalMargin = this.resources.dpToPx(4),
        columnProvider = object : ColumnProvider {
            override fun getNumberOfColumns(): Int = 4
        },
        orientation = RecyclerView.HORIZONTAL
    )

fun Context.getListHorizontalMarginDecoration(
    @Px leftMargin: Int,
    @Px topMargin: Int,
    @Px rightMargin: Int,


но переконатися, що складений край трохи довший за 1 см, щоб його можна було зачепити під час пришивання та зшивання капюшона, але не настільки, щоб він розвівався.

</Note>

## Крок 10: Прикріпіть капюшон

- Приколіть капюшон до горловини, сумістивши бокові сторони разом, починаючи з центральної частини спинки, і накладіть кінці капюшона по центру спереду на передню частину.
- Прикладіть горловину до підкладки з виворітного боку капюшона, приколіть горловину до капюшона, сумістивши середину горловини з центром спинки.
- Якщо ви використовуєте оверлок/розпошивач, зшийте горловину і капюшон разом через усі шари.
- If using a sewing machine, use a zig-zag stitch to sew all the neck and hood layers together.
- Із зовнішнього боку перевірте навколо вирізу горловини, щоб переконатися, що всі шари зачеплені.
- Припуски швів припрасувати до тіла.
- On the good side, topstitch with a straight stitch approximately 1cm (3/8 inch) away from the neck edge towards the body to catch and secure the neckband underneath.
- Обріжте надлишки палітурки зсередини.

<Warning>

If using a overlocker/serger to attach the hood you may want to attach bulky areas down first with a straight stitch such as the front as an overlocker/serger may have trouble sewing these parts.

</Warning>

<Note>

Якщо ви боїтеся, що пришивання шийної стрічки прямим швом не дасть достатньої розтяжки, ви завжди можете пришити її вузьким зигзагом або відповідною розтяжною строчкою на ваш вибір.
Якщо ви не використовуєте шийну стрічку, вам потрібно завершити шов за допомогою **Способу завершення 2** і виконати верхню строчку на 6 мм (1/4 дюйма) замість 1 см (3/8 дюйма).

</Note>

## Крок 11: Ґудзики та петлі

- На позначках петель на передніх панелях пришийте отвори для ґудзиків 2,5 см (1 дюйм) або іншого розміру за вашим вибором.
- Для розміщення кнопок ви можете приміряти свій Yuri і подивитися, д


k(())
    }
}

fn verify_challenges<E: Engine, CS: ConstraintSystem<E>, T>(
    _cs: &mut CS,
    _challenges: Vec<E::Fr>,
    _partial_challenge: &Option<E::Fr>,
    // This is generic because it needs to work with a public input (challenge seed) on first iteration
    // then an allocated number subsequently.
    _mix: T,
    _challenge_bits: usize,
) -> bool {
    // TODO: Actually verify that challenges are correctly derived.
    // Verification algorithm is implemented and tested in vdf_post::verify_final_challenge_derivation.
    // NOTE: verification as designed here requires that all challenges (N) extractable from one partial_challenge
    // are used. If challenge_count is not a multiple of this N, the surplus challenges will still be needed for verification,
    // even if unused.
    true
}

impl<'a, E: JubjubEngine> VDFPoStCircuit<'a, E> {
    pub fn synthesize<CS: ConstraintSystem<E>>(
        cs: &mut CS,
        params: &E::Params,
        challenge_seed: Option<E::Fr>,
        vdf_key: Option<E::Fr>,
        vdf_ys: Vec<Option<E::Fr>>,
        vdf_xs: Vec<Option<E::Fr>>,
        vdf_sloth_rounds: usize,
        challenges_vec: Vec<Vec<usize>>,
        challenged_sectors_vec: Vec<Vec<usize>>,
        challenged_leafs_vec: Vec<Vec<Option<E::Fr>>>,
        root_commitment: Option<E::Fr>,
        commitments_vec: Vec<Vec<Option<E::Fr>>>,
        paths_vec: Vec<Vec<Vec<Option<(E::Fr, bool)>>>>,
    ) -> Result<(), SynthesisError> {
        VDFPoStCircuit {
            params,
            challenges_vec,
            challenged_sectors_vec,
            challenge_seed,
            vdf_key,
            vdf_ys,
            vdf_xs,
            vdf_sloth_rounds,
            challenged_leafs_vec,
            root_commitment,
            commitments_vec,
            paths_vec,
        }
        .synthesize(cs)
    }
}

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

    use pairing::Field;
    use rand::{Rng, SeedableRng, XorShiftRng};
    use sapling_crypto::jubjub::JubjubBls12;

    use crate::circuit::test::*;
    use crate::compound_proof;
    use crate::drgraph::{new_seed, BucketGraph, Graph};
    use crate::fr32::fr_into_bytes;
    use crate::hasher::pedersen::*;
    use crate::proof::ProofScheme;
    use crate::vdf_post;
    use crate::vdf_sloth;

    #[test]
    fn test_vdf_post_circuit_with_bls12_381() {
        let params = &JubjubBls12::new();
        let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);

        let lambda = 32;

        let sp = vdf_post::SetupParams::<PedersenDomain, vdf_sloth::Sloth> {
            challenge_count: 10,
            sector_size: 1024 * lambda,
            post_epochs: 3,
            setup_params_vdf: vdf_sloth::SetupParams {
                key: rng.gen(),
                rounds: 1,
            },
            sectors_count: 2,
        };

        let pub_params = vdf_post::VDFPoSt::<PedersenHasher, vdf_sloth::Sloth>::setup(&sp).unwrap();

        let data0: Vec<u8> = (0..1024)
            .flat_map(|_| fr_into_bytes::<Bls12>(&rng.gen()))
            .collect();
        let data1: Vec<u8> = (0..1024)
            .flat_map(|_| fr_into_bytes::<Bls12>(&rng.gen()))
            .collect();

        let graph0 = BucketGraph::<PedersenHasher>::new(1024, 5, 0, new_seed());
        let tree0 = graph0.merkle_tree(data0.as_slice()).unwrap();
        let graph1 = BucketGraph::<Peders


ysh$ redir >out.txt { echo hi }
    ysh$ redir <in.txt { sort }

    cb$  redir '>' out.txt { echo hi }
    cb$  redir '<' in.txt { sort }

## Compound Commands

### Sequence

    sh$ echo one; echo 2

    cb$ echo one; echo 2

### Braced Groups

    sh$ { echo one; echo 2; }  # can be redirected at once

    cb$ group { echo one; echo 2; }
    # { echo one } isn't a command; it's a block, so it's not at the top level
    # we have commands only

### Pipelines

    sh$ ls | grep foo | wc -l

    cb$ ls | grep foo | wc -l  # TODO

    cb$ pipeline { ls } { grep foo } { wc -l }

    cb$ { echo 1; echo 2 } | wc -l

Desugars to:

    cb$ pipeline { echo 1; echo 2 } { wc -l }

Shelling Out:

    # sh -c 'ls | wc -l'

    sh 'ls | wc -l'

    # Hm I wonder if we also have
    capture-stdout 'ls | wc -l'

    ysh 'ls | wc -l'

## Structured Programming (ALGOL-like)

## Loops

    while {
      w-line  # stack empty
    }

    for {
      w
    }

    for-line {
      w
    }

## If

    if empty {
      break
    }

TODO:

    if boolstatus test $x = foo {
      echo foo
    } elif boolstatus test $x = bar {
      echo bar
    } else {
      echo other
    }

Important: `boolstatus` is different than `x`  !  It does something different
with the exit code of the process.

- `boolstatus`
  - `0` is on the stack if the command exited 0
  - `1` is on the stack if the command exited 1
  - else it leaves `null` on the stack with the  status!

- `x` leaves nothing on the stack if the command succeeds (code 0)
  - if the command fails, it leaves `null` on the stack, AND the exit code

- `try x ls` leaves the exit code no matter what, so you can test it

## Case

    case %x {
      regex 'README(\.md)?' {
        echo README
      }
      regex [a b] {
      }
      glob '*.py' {
        echo python
      }
      glob '*.h' '*.cc' {
        echo 'C++'
      }
      else {
        echo 'other'
      }
    }

## Defining Fn

Not done:

    fn myfn {
      w-line foo
      w-line bar
    }

    fn myfn a b c {  # are these the things on the stack?
      w '['
      w $x
      w ']'
    }

So

    myfn foo

is short for

    const foo
    f

It's like passing args.  Hm.

## Pure Functions

TODO: leave VALUE on th estack, not just intergers

    def f {
      const 'foo'  # LEAVE It on the stack
      echo x  # FAIL: sandboxed
    }

But I guess procs can do that TOO?

PURITY though.

## try and error

Error handling:

    ysh$ try {
           sh -c false
         }
         if failed {
           echo 'failed'
         }

    cb$  try {
           x sh -c false
         }
         if failed {
           echo 'failed'
         }

Error code:

    cb$  try {
           x false
         }
         # _ is top value?
         # and maybe !_ pops it

         echo %[_ caught status]; pop  # discard t

## Hay

Declaring data:

    ysh


id angle between the input points and triangles

        Follows the method described in:

        The Solid Angle of a Plane Triangle
        A. VAN OOSTEROM AND J. STRACKEE
        IEEE TRANSACTIONS ON BIOMEDICAL ENGINEERING,
        VOL. BME-30, NO. 2, FEBRUARY 1983

        Parameters
        -----------
            points: BxQx3
                Tensor of input query points
            triangles: BxFx3x3
                Target triangles
            thresh: float
                float threshold
        Returns
        -------
            solid_angles: BxQxF
                A tensor containing the solid angle between all query points
                and input triangles
    '''
    # Center the triangles on the query points. Size should be BxQxFx3x3
    centered_tris = triangles[:, None] - points[:, :, None, None]

    # BxQxFx3
    norms = torch.norm(centered_tris, dim=-1)

    # Should be BxQxFx3
    cross_prod = torch.cross(
        centered_tris[:, :, :, 1], centered_tris[:, :, :, 2], dim=-1)
    # Should be BxQxF
    numerator = (centered_tris[:, :, :, 0] * cross_prod).sum(dim=-1)
    del cross_prod

    dot01 = (centered_tris[:, :, :, 0] * centered_tris[:, :, :, 1]).sum(dim=-1)
    dot12 = (centered_tris[:, :, :, 1] * centered_tris[:, :, :, 2]).sum(dim=-1)
    dot02 = (centered_tris[:, :, :, 0] * centered_tris[:, :, :, 2]).sum(dim=-1)
    del centered_tris

    denominator = (
        norms.prod(dim=-1) +
        dot01 * norms[:, :, :, 2] +
        dot02 * norms[:, :, :, 1] +
        dot12 * norms[:, :, :, 0]
    )
    del dot01, dot12, dot02, norms

    # Should be BxQ
    solid_angle = torch.atan2(numerator, denominator)
    del numerator, denominator

    torch.cuda.empty_cache()

    return 2 * solid_angle

def winding_numbers(
    points: Tensor,
    triangles: Tensor,
    thresh: float = 1e-8
) -> Tensor:
    ''' Uses winding_numbers to compute inside/outside

        Robust inside-outside segmentation using generalized winding numbers
        Alec Jacobson,
        Ladislav Kavan,
        Olga Sorkine-Hornung

        Fast Winding Numbers for Soups and Clouds SIGGRAPH 2018
        Gavin Barill
        NEIL G. Dickson
        Ryan Schmidt
        David I.W. Levin
        and Alec Jacobson

        Parameters
        -----------
            points: BxQx3
                Tensor of input query points
            triangles: BxFx3x3
                Target triangles
            thresh: float
                float threshold
        Returns
        -------
            winding_numbers: BxQ
                A tensor containing the Generalized winding numbers
    '''
    # The generalized winding number is the sum of solid angles of the point
    # with respect to all triangles.
    return 1 / (4 * math.pi) * solid_angles(
        points, triangles, thresh=thresh).sum(dim=-1)


// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license.

namespace Microsoft.Psi.Visualization
{
    using System;
    using System.Collections.Generic;

    /// <summary>
    /// Implements a comparer for visualizers to decide an ordering of visualizers
    /// for a given data type.
    /// </summary>
    public class VisualizerMetadataComparer : Comparer<VisualizerMetadata>
    {
        private readonly Type dataType;

        /// <summary>
        /// Initializes a new instance of the <see cref="VisualizerMetadataComparer"/> class.
        /// </summary>
        /// <param name="dataType">The data type.</param>
        public VisualizerMetadataComparer(Type dataType)
        {
            this.dataType = dataType;
        }

        /// <inheritdoc/>
        public override int Compare(VisualizerMetadata x, VisualizerMetadata y)
        {
            // Visualizers without adapters take precedence
            if (x.StreamAdapterType == null && y.StreamAdapterType != null)
            {


Code = evt.exitCode
		db.stats.resolvedOrphanExits.Add(1)
		db.logger.Debugf("resolved orphan exit for pid %d", proc.PIDs.Tgid)
		evt.startTime = proc.PIDs.StartTimeNS
		db.removalMap[proc.PIDs.Tgid] = evt
	}

	db.processes[exec.PIDs.Tgid] = proc
	entryLeaderPID := db.evaluateEntryLeader(proc)
	if entryLeaderPID != nil {
		db.entryLeaderRelationships[exec.PIDs.Tgid] = *entryLeaderPID
	}
}

func (db *DB) createEntryLeader(pid uint32, entryType EntryType) {
	db.entryLeaders[pid] = entryType
	db.logger.Debugf("created entry leader %d: %s, name: %s", pid, string(entryType), db.processes[pid].Filename)
}

// pid returned is a pointer type because it is possible no matching PID is found.
func (db *DB) evaluateEntryLeader(p Process) *uint32 {
	pid := p.PIDs.Tgid

	// init never has an entry leader or meta type
	if p.PIDs.Tgid == 1 {
		db.logger.Debugf("entry_eval %d: process is init, no entry type", p.PIDs.Tgid)
		return nil
	}

	// kernel threads also never have an entry leader or meta type kthreadd
	// (always pid 2) is the parent of all kernel threads, by filtering pid ==
	// 2 || ppid == 2, we get rid of all of them
	if p.PIDs.Tgid == 2 || p.PIDs.Ppid == 2 {
		db.logger.Debugf("entry_eval %d: kernel threads never an entry type (parent is pid 2)", p.PIDs.Tgid)
		return nil
	}

	// could be an entry leader
	if p.PIDs.Tgid == p.PIDs.Sid {
		ttyType := tty.GetTTYType(p.CTTY.Major, p.CTTY.Minor)

		procBasename := basename(p.Filename)
		switch {
		case ttyType == tty.TTY:
			db.createEntryLeader(pid, Terminal)
			db.logger.Debugf("entry_eval %d: entry type is terminal", p.PIDs.Tgid)
			return &pid
		case ttyType == tty.TTYConsole && procBasename == "login":
			db.createEntryLeader(pid, EntryConsole)
			db.logger.Debugf("entry_eval %d: entry type is console", p.PIDs.Tgid)
			return &pid
		case p.PIDs.Ppid == 1:
			db.createEntryLeader(pid, Init)
			db.logger.Debugf("entry_eval %d: entry type is init", p.PIDs.Tgid)
			return &pid
		case !isFilteredExecutable(procBasename):
			if parent, ok := db.processes[p.PIDs.Ppid]; ok {
				parentBasename := basename(parent.Filename)
				if ttyType == tty.Pts && parentBasename == "ssm-session-worker" {
					db.createEntryLeader(pid, Ssm)
					db.logger.Debugf("entry_eval %d: entry type is ssm", p.PIDs.Tgid)
					return &pid
				} else if parentBasename == "sshd" && procBasename != "sshd" {
					// TODO: get ip from env vars
					db.createEntryLeader(pid, Sshd)
					db.logger.Debugf("entry_eval %d: entry type is sshd", p.PIDs.Tgid)
					return &pid
				} else if isContainerRuntime(parentBasename) {
					db.createEntryLeader(pid, Container)
					db.logger.Debugf("entry_eval %d: entry type is container", p.PIDs.Tgid)
					return &pid
				}
			}
		default:
			db.logger.Debugf("entry_eval %d


b&&12>=b&&0<c+1&&c+1<=t1[b-1]||2==b&&29==c+1&&0==a%4&&!(0==a%100&&0!=a%400)?new Q1(a,b,c+1):12>b?new Q1(a,b+1,1):new Q1(a+1,1,1)}
function w1(a,b,c){sO();return 1<c?new Q1(a,b,c-1):1<b?3==b&&0==a%4&&!(0==a%100&&0!=a%400)?new Q1(a,2,29):new Q1(a,b-1,t1[b-2]):new Q1(a-1,12,31)}q(655,656,{123:1,124:1,134:1,232:1,239:1,242:1,245:1,252:1,268:1,328:1},W_,Q1,B1);
_.zg=function(a){var b,c,d;if(z(a,246))return d=TM(B(a,246)),a=!QJ(d,lm),d=!QJ(d,lm)?kS(d):d,b=cA(X1(Y1(d)/864E8)),d=ZJ(UJ(d,qaa),lm),c=L1(this.d,this.c,this.b),b=p1(c+(a?-b:b)),d&&a&&(b=w1(b.d,b.c,b.b)),b.k=this.k,b;if(z(a,269)){a=s1(B(a,269));a=this.c-1+a;d=this.d+~~(a/12);a%=12;0>a&&(a+=12,d-=1);++a;for(b=this.b;!(0<a&&12>=a&&0<b&&b<=t1[a-1]||2==a&&29==b&&0==d%4&&!(0==d%100&&0!=d%400));)b-=1;return new B1(d,a<<24>>24,b<<24>>24,this.k)}a=new A("Date arithmetic is not supported on xs:duration, only on its subtypes");
a.f=!0;a.c=new D(j,l,If);throw a;};_.Ag=function(a){a=u1(new EN(this.d,this.c,this.b,0,0,0,0,this.k),a);return new B1(a.j,a.f,a.b,a.k)};_.cT=function(a){try{return U1(this,B(a,245),null)}catch(b){b=v(b);if(z(b,332))throw new zK(Kc);throw b;}};
_.tg=function(a){switch(a.e){case 521:case 632:return this;case 519:return new EN(this.d,this.c,this.b,0,0,0,0,this.k);case 513:return new Cu(W1(this));case 631:return new It(W1(this));case 523:return new D1(this.d,this.k);case 522:return new E1(this.d,this.c,this.k);case 526:return new F1(this.c,this.k);case 524:return new G1(this.c,this.b,this.k);case 525:return new H1(this.b,this.k);default:return a=new S_("Cannot convert date to "+(635==a.c?dk:zx(a.c))),a.b=new D(j,l,If),a}};
_.Cg=function(){var a;a=new B1(this.d,this.c,this.b,this.k);a.n=this.n;return a};_.vg=function(){return W1(this)};_.wg=function(){return U(),Dx};_.Eg=function(a,b){var c;if(!z(a,245))throw c=new A("First operand of '-' is a date, but the second is not"),c.f=!0,c.c=new D(j,l,If),c;return Q0(this,a


 have a duplicate method name in an embedded (not explicitly declared) method.
			// Check method signatures after all types are computed (go.dev/issue/33656).
			// If we're pre-go1.14 (overlapping embeddings are not permitted), report that
			// error here as well (even though we could do it eagerly) because it's the same
			// error message.
			if check != nil {
				check.later(func() {
					if pos.IsKnown() && !check.allowVersion(go1_14) || !Identical(m.typ, other.Type()) {
						err := check.newError(DuplicateDecl)
						err.addf(atPos(pos), "duplicate method %s", m.name)
						err.addf(atPos(mpos[other.(*Func)]), "other declaration of method %s", m.name)
						err.report()
					}
				}).describef(atPos(pos), "duplicate method check for %s", m.name)
			}
		}
	}

	for _, m := range ityp.methods {
		addMethod(m.pos, m, true)
	}

	// collect embedded elements
	allTerms := allTermlist
	allComparable := false
	for i, typ := range ityp.embeddeds {
		// The embedding position is nil for imported interfaces.
		// We don't need to do version checks in those cases.
		var pos syntax.Pos // embedding position
		if ityp.embedPos != nil {
			pos = (*ityp.embedPos)[i]
		}
		var comparable bool
		var terms termlist
		switch u := under(typ).(type) {
		case *Interface:
			// For now we don't permit type parameters as constraints.
			assert(!isTypeParam(typ))
			tset := computeInterfaceTypeSet(check, pos, u)
			// If typ is local, an error was already reported where typ is specified/defined.
			if pos.IsKnown() && check != nil && check.isImportedConstraint(typ) && !check.verifyVersionf(atPos(pos), go1_18, "embedding constraint interface %s", typ) {
				continue
			}
			comparable = tset.comparable
			for _, m := range tset.methods {
				addMethod(pos, m, false) // use embedding position pos rather than m.pos
			}
			terms = tset.terms
		case *Union:
			if pos.IsKnown() && check != nil && !check.verifyVersionf(atPos(pos), go1_18, "embedding interface element %s", u) {
				continue
			}
			tset := computeUnionTypeSet(check, unionSets, pos, u)
			if tset == &invalidTypeSet {
				continue // ignore invalid unions
			}
			assert(!tset.comparable)
			assert(len(tset.methods) == 0)
			terms = tset.terms
		default:
			if !isValid(u) {
				continue
			}
			if pos.IsKnown() && check != nil && !check.verifyVersionf(atPos(pos), go1_18, "embedding non-interface type %s", typ) {
				continue
			}
			terms = termlist{{false, typ}}
		}

		// The type set of an interface is the intersection of the type sets of all its elements.
		// Due to language restrictions, only embedded interfaces can add methods, they are handled
		// separately. Here we only need to intersect the term lists and comparable bits.
		allTerms, allComparable = intersectTermLists(allTerms, allComparable, terms, comparable)
	}

	ityp.tset.comparable = allComparable
	if len(allMethods) != 0 {
		sortMethods(allMethods)
		ityp.tset.methods = allMethods
	}
	ityp.tset.terms = allTerms

	return ityp.tset
}

// TODO(gri) The intersectTermLists function belongs to the termlist implementation.
//           The comparable type set may also be best represented as a term (using
//           a special type).

// intersectTermLists computes the intersection of two term lists and respective comparable bits.
// x


 under the License.

//! Tests for pallet-example.

use crate::*;
use frame_support::{
	assert_ok, parameter_types,
	weights::{DispatchInfo, GetDispatchInfo}, traits::OnInitialize
};
use sp_core::H256;
// The testing primitives are very useful for avoiding having to work with signatures
// or public keys. `u64` is used as the `AccountId` and no `Signature`s are required.
use sp_runtime::{
	testing::Header, BuildStorage,
	traits::{BlakeTwo256, IdentityLookup},
};
// Reexport crate as its pallet name for construct_runtime.
use crate as pallet_example;

type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
type Block = frame_system::mocking::MockBlock<Test>;

// For testing the pallet, we construct a mock runtime.
frame_support::construct_runtime!(
	pub enum Test where
		Block = Block,
		NodeBlock = Block,
		UncheckedExtrinsic = UncheckedExtrinsic,
	{
		System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
		Example: pallet_example::{Pallet, Call, Storage, Config<T>, Event<T>},
	}
);

parameter_types! {
	pub const BlockHashCount: u64 = 250;
	pub BlockWeights: frame_system::limits::BlockWeights =
		frame_system::limits::BlockWeights::simple_max(1024);
}
impl frame_system::Config for Test {
	type BaseCallFilter = frame_support::traits::AllowAll;
	type BlockWeights = ();
	type BlockLength = ();
	type DbWeight = ();
	type Origin = Origin;
	type Index = u64;
	type BlockNumber = u64;
	type Hash = H256;
	type Call = Call;
	type Hashing = BlakeTwo256;
	type AccountId = u64;
	type Lookup = IdentityLookup<Self::AccountId>;
	type Header = Header;
	type Event = Event;
	type BlockHashCount = BlockHashCount;
	type Version = ();
	type PalletInfo = PalletInfo;
	type AccountData = pallet_balances::AccountData<u64>;
	type OnNewAccount = ();
	type OnKilledAccount = ();
	type SystemWeightInfo = ();
	type SS58Prefix = ();
	type OnSetCode = ();
}
parameter_types! {
	pub const ExistentialDeposit: u64 = 1;
}
impl pallet_balances::Config for Test {
	type MaxLocks = ();
	type MaxReserves = ();
	type ReserveIdentifier = [u8; 8];
	type Balance = u64;
	type DustRemoval = ();
	type Event = Event;
	type ExistentialDeposit = ExistentialDeposit;
	type AccountStore = System;
	type WeightInfo = ();
}

parameter_types! {
	pub const MagicNumber: u64 = 1_000_000_000;
}
impl Config for Test {
	type MagicNumber = MagicNumber;
	type Event = Event;
	type WeightInfo = ();
}

// This function basically just builds a genesis storage key/value store according to
// our desired mockup.
pub fn new_test_ext() -> sp_io::TestExternalities {
	let t = GenesisConfig {
		// We use default for brevity, but you can configure as desired if needed.
		system: Default::default(),
		balances: Default::default(),
		example: pallet_example::GenesisConfig {
			dummy: 42,
			// we configure the map with (key, value) pairs.
			bar: vec![(1, 2),


]
                }
            )

        # Update Faculty deans
        cursor.execute("SELECT code, dean_id FROM FACULTIES WHERE dean_id IS NOT NULL")
        for row in cursor.fetchall():
            faculty = Faculty.objects.get(code=row[0])
            try:
                dean = Employee.objects.get(id=row[1])
                faculty.dean = dean
                faculty.save()
            except Employee.DoesNotExist:
                pass

        # Import Areas
        cursor.execute("SELECT code, name, faculty_code, coordinator_id FROM AREAS")
        for row in cursor.fetchall():
            Area.objects.update_or_create(
                code=row[0],
                defaults={
                    'name': row[1],
                    'faculty_id': row[2],
                    'coordinator_id': row[3]
                }
            )

        # Import Programs
        cursor.execute("SELECT code, name, area_code FROM PROGRAMS")
        for row in cursor.fetchall():
            Program.objects.update_or_create(
                code=row[0],
                defaults={
                    'name': row[1],
                    'area_id': row[2]
                }
            )

        # Import Subjects
        cursor.execute("SELECT code, name, program_code FROM SUBJECTS")
        for row in cursor.fetchall():
            Subject.objects.update_or_create(
                code=row[0],
                defaults={
                    'name': row[1],
                    'program_id': row[2]
                }
            )

        # Import Groups
        cursor.execute("SELECT number, semester, subject_code, professor_id FROM GROUPS")
        for row in cursor.fetchall():
            Group.objects.update_or_create(
                number=row[0],
                semester=row[1],
                subject_id=row[2],
                defaults={
                    'professor_id': row[3]
                }
            )


Should be unique per language server.
--- - `cmd` command string[] or function.
--- - `root_dir` path to the project root. By default this is used to decide if an existing client
---   should be re-used. The example above uses |vim.fs.root()| to detect the root by traversing
---   the file system upwards starting from the current directory until either a `pyproject.toml`
---   or `setup.py` file is found.
--- - `workspace_folders` list of `{ uri:string, name: string }` tables specifying the project root
---   folders used by the language server. If `nil` the property is derived from `root_dir` for
---   convenience.
---
--- Language servers use this information to discover metadata like the
--- dependencies of your project and they tend to index the contents within the
--- project folder.
---
---
--- To ensure a language server is only started for languages it can handle,
--- make sure to call |vim.lsp.start()| within a |FileType| autocmd.
--- Either use |:au|, |nvim_create_autocmd()| or put the call in a
--- `ftplugin/<filetype_name>.lua` (See |ftplugin-name|)
---
--- @since 10
---
--- @param config vim.lsp.ClientConfig Configuration for the server.
--- @param opts vim.lsp.start.Opts? Optional keyword arguments.
--- @return integer? client_id
function lsp.start(config, opts)
  opts = opts or {}
  local reuse_client = opts.reuse_client or reuse_client_default
  local bufnr = vim._resolve_bufnr(opts.bufnr)

  if not config.root_dir and opts._root_markers then
    validate('root_markers', opts._root_markers, 'table')
    config = vim.deepcopy(config)

    config.root_dir = vim.fs.root(bufnr, opts._root_markers)
  end

  if
    not config.root_dir
    and (not config.workspace_folders or #config.workspace_folders == 0)
    and config.workspace_required
  then
    log.info(
      ('skipping config "%s": workspace_required=true, no workspace found'):format(config.name)
    )
    return
  end

  for _, client in pairs(lsp.client._all) do
    if reuse_client(client, config) then
      if opts.attach == false then
        return client.id
      end

      if lsp.buf_attach_client(bufnr, client.id) then
        return client.id
      end
      return
    end
  end

  local client_id, err = create_and_init_client(config)
  if err then
    if not opts.silent then
      vim.notify(err, vim.log.levels.WARN)
    end
    return
  end

  if opts.attach == false then
    return client_id
  end

  if client_id and lsp.buf_attach_client(bufnr, client_id) then
    return client_id
  end
end

--- Consumes the latest progress messages from all clients and formats them as a string.
--- Empty if there are no clients or if no new messages
---
---@return string
function lsp.status()
  local percentage = nil
  local messages = {} --- @type string[]
  for _, client in ipairs(vim.lsp.get_clients()) do
    --- @diagnostic disable-next-line:no-unknown
    for progress in client.progress do
      --- @cast progress {token: lsp.ProgressToken, value: lsp.LSPAny}
      local value = progress.value
      if type(value) == 'table' and value.kind then
        local message = value.message and (value.title .. ': ' .. value.message) or value.title
        messages[#messages + 1] = message
        if value.percentage


 value)
			default:
				field = ex.parse(field)
				fmt.Fprintf(bib, ",\n  %s = {%s}", field, value)
			}
		}
	}

	fields = make([]string, len(e.Optional))
	i = 0
	for field := range e.Optional {
		fields[i] = field
		i++
	}
	sort.Strings(fields)
	for _, field := range fields {
		if value := e.Optional[field]; value != "" && field != "abstract" {
			switch field {
			case "url":
				urltmp = fmt.Sprintf("\\textsc{url:} \\url{%s}", value) + urltmp
			case "urldate":
				urltmp += fmt.Sprintf(" (accessed %s)", value)
			default:
				field = ex.parse(field)
				fmt.Fprintf(bib, ",\n  %s = {%s}", field, value)
			}
		}
	}
	if urltmp != "" {
		fmt.Fprintf(bib, ",\n  %s = {%s}", "howpublished", urltmp)
	}
	if value, ok := e.Optional["abstract"]; ok {
		fmt.Fprintf(bib, ",\n  %s = {%s}", "abstract", value)
	}
	if file := e.File; file != "" {
		fmt.Fprintf(bib, ",\n  %s = {%s}", "file", file)
	}

	bib.WriteString("\n}")

	return bib.String()

}

var monthText = map[string]string{
	"01": "jan",
	"02": "feb",
	"03": "mar",
	"04": "apr",
	"05": "may",
	"06": "jun",
	"07": "jul",
	"08": "aug",
	"09": "sep",
	"10": "oct",
	"11": "nov",
	"12": "dec",
}

var bibtex = &exBibtex{
	dict: map[string]string{
		"report":       "techreport",
		"online":       "misc",
		"patent":       "misc",
		"langid":       "language",
		"location":     "address",
		"journaltitle": "journal",
		"institution":  "school",
		"date":         "year",
		"url":          "howpublished",
		"urldate":      "howpublished",
	},
}
package scholar

import (
	"bytes"
	"fmt"
)

type tnfError struct {
	requested string
}

func (e *tnfError) Error() string {
	return fmt.Sprintf("not found: type %s", e.requested)
}

// TypeNotFoundError is deprecated.
var TypeNotFoundError *tnfError

type errorOp string

type errorType uint8

const (
	// ErrNotDefined represents a not defined error.
	errNotDefined errorType = iota
	// ErrTypeNotFound represents an entry type not found error.
	ErrTypeNotFound
	// ErrFieldNotFound represents a field not found error.
	ErrFieldNotFound
)

// String implements the Stringer interface.
func (e errorType) String() string {
	switch e {
	case errNotDefined:
		return "undefined error"
	case ErrTypeNotFound:
		return "entry type not found error"
	case ErrFieldNotFound:
		return "field not found error"
	}

	return "unknown error"
}

// Err represents a custom error handler.
type Err struct {
	op    errorOp
	eType errorType
	extra string
	err   error
}

func errPad(b *bytes.Buffer, s string) {
	if b.Len() == 0 {
		return
	}
	b.Write


"鸟房落球",
	["CARNIVALGAME_PUCKDROP_KIT"] = "鸟房落球套装",
	["TURF_UNDERROCK"] = "洞穴岩石地皮",
	["POCKETWATCH_PORTAL_ENTRANCE"] = "时间裂缝",
	["CARNIVALGAME_SHOOTING_TARGET_OFF"] = "活板门",
	["PANFLUTE"] = "排箫",
	["TRINKET_5"] = "迷你火箭",
	["CARNIVALGAME_SHOOTING_STATION"] = "保卫鸟巢",
	["CARNIVALGAME_HERDING_CHICK"] = "追蛋",
	["CARNIVALGAME_HERDING_STATION"] = "追蛋",
	["DEER_GEMMED"] = "无眼鹿",
	["CARNIVALGAME_HERDING_KIT"] = "追蛋套装",
	["WINTERCOOKING_PAVLOVA"] = "巴甫洛娃蛋糕",
	["CHESSPIECE_MUSE"] = "女王雕塑",
	["MUTATOR_HIDER"] = "洞穴变身涂鸦",
	["DEVTOOL"] = "开发工具",
	["SLURPER_PELT"] = "啜食者皮",
	["WOBSTER_SHELLER_LAND"] = "龙虾",
	["HALLOWEENCANDY_9"] = "果冻虫",
	["CARNIVAL_VEST_B"] = "叽叽喳喳斗篷",
	["CARNIVALGAME_FEEDCHICKS_STATION"] = "鸟鸟吃虫虫",
	["BARNACLESUSHI"] = "藤壶握寿司",
	["CHARLIE_LECTURN"] = "剧本",
	["CARNIVAL_CROWKID"] = "小乌鸦",
	["WX78MODULE_MAXSANITY"] = "超级处理器电路",
	["HALLOWEEN_EXPERIMENT_BRAVERY"] = "恐惧实验",
	["MADSCIENCE_LAB"] = "疯狂科学家实验室",
	["HALLOWEENCANDY_14"] = "熔岩椒",
	["CARNIVAL_GAMETOKEN"] = "鸦年华代币",
	["STORAGE_ROBOT"] = "瓦器人",
	["HALLOWEENCANDY_5"] = "浣猫糖果",
	["HALLOWEENCANDY_4"] = "粘液蜘蛛",
	["TWIGGY_NUT_SAPLING"] = "多枝树苗",
	["BLUE_CAP_COOKED"] = "熟蓝蘑菇",
	["HALLOWEENCANDY_1"] = "糖果苹果",
	["ANCHOR_SKETCH"] = "“月亮” 草图",
	["FROGGLEBUNWICH"] = "蛙腿三明治",
	["BOAT"] = "船",
	["BATHBOMB_BLUEPRINT"] = "沐浴球图纸",
	["CHESSPIECE_MANRABBIT_SKETCH"] = "兔人雕塑草图",
	["CHESSPIECE_CRABKING_SKETCH"] = "帝王蟹雕塑草图",
	["MAXWE


t nWidthSubdivisions,
                               WalkingControllerParameters walkingControllerParameters,
                               ExplorationParameters explorationParameters,
                               YoGraphicsListRegistry yoGraphicsListRegistry,
                               YoRegistry parentRegistry)
   {
      this.footLength = walkingControllerParameters.getSteppingParameters().getFootLength();
      this.footWidth = walkingControllerParameters.getSteppingParameters().getFootWidth();
      this.soleFrame = soleFrame;
      gridOrigin.setIncludingFrame(soleFrame, -footLength, -footWidth);
      gridOrigin.scale(0.5);

      gridBoundaries.clear(soleFrame);
      gridBoundaries.addVertex(new FramePoint2D(soleFrame, -footLength / 2.0, -footWidth / 2.0));
      gridBoundaries.addVertex(new FramePoint2D(soleFrame, -footLength / 2.0, footWidth / 2.0));
      gridBoundaries.addVertex(new FramePoint2D(soleFrame, footLength / 2.0, -footWidth / 2.0));
      gridBoundaries.addVertex(new FramePoint2D(soleFrame, footLength / 2.0, footWidth / 2.0));
      gridBoundaries.update();

      registry = new YoRegistry(namePrefix + name);

      this.nLengthSubdivisions = new YoInteger(namePrefix + "NLengthSubdivisions", registry);
      this.nLengthSubdivisions.set(nLengthSubdivisions);
      this.nWidthSubdivisions = new YoInteger(namePrefix + "NWidthSubdivisions", registry);
      this.nWidthSubdivisions.set(nWidthSubdivisions);

      if (explorationParameters != null)
      {
         thresholdForCellActivation = explorationParameters.getCopGridThresholdForOccupancy();
         decayRate = explorationParameters.getCopGridDecayAlpha();
      }
      else
      {
         thresholdForCellActivation = new YoDouble(namePrefix + "ThresholdForCellActivation", registry);
         thresholdForCellActivation.set(defaultThresholdForCellActivation);
         decayRate = new YoDouble(namePrefix + "DecayRate", registry);
         decayRate.set(defaultDecayRate);
      }

      resetGridToEmpty = new YoBoolean(namePrefix + name + "Reset", registry);
      resetGridToEmpty.set(false);

      currentXIndex = new YoInteger(namePrefix + "CurrentXIndex", registry);
      currentYIndex = new YoInteger(namePrefix + "CurrentYIndex", registry);
      areCurrentCoPIndicesValid = new YoBoolean(namePrefix + "IsCurrentCoPIndicesValid", registry);

      cellSize = new YoFrameVector2D(namePrefix + "CellSize", soleFrame, registry);
      cellArea = new YoDouble(namePrefix + "CellArea", registry);

      setupChangedGridParameterListeners();

      if (VISUALIZE)
      {
         cellViz = new YoFramePoint3D[nLengthSubdivisions][nWidthSubdivisions];
         for (int i = 0; i < cellViz.length; i++)
         {
            for (int j = 0; j < cellViz[0].length; j++)
            {
               String namePrefix2 = "CellViz_X" + String.valueOf(i) + "Y" + String.valueOf(j);
               YoFramePoint3D pointForViz = new YoFramePoint3D(namePrefix + namePrefix2, ReferenceFrame.getWorldFrame(), registry);
               pointForViz.setToNaN();
               cellViz[i][j] = pointForViz;
               YoGraphicPosition yoGraphicPosition = new YoGraphicPosition(namePrefix + namePrefix2, pointForViz, 0.004, YoAppearance.Orange());
               yoGraphicsListRegistry.registerArtifact(name, yoGraphicPosition.createArtifact());
               yoGraphicsListRegistry.registerYoGraphic(name, yoGraphicPosition);
            }
         }
      }
      else


ame="V4.31_Platforms">Platforms

Fixes bugs:
	- MetroWerks CodeWarrior predefines true and false, causing
compilation errors on the Mac.  (stdpre.h)

Interpreter

Updates code for the change in the ENUM_PTR macros.  (iscan.c)

Changes the allocator to keep track of "lost" ref space separately, to allow
an independent check on its activities.  (gxalloc.h, ialloc.c, isave.c)

Changes the garbage collector API slightly to allow implementation of the
API in applications other than PostScript interpreters.  (ivmspace.h,
ireclaim.c, igc.c)

Interpreter (PDF)

Implements the PDF 1.1 BX and EX operators.  (pdf_base.ps, pdf_main.ps)

Streams

Fixes bugs:
	- Some (harmless) pointer incompatibilities upset some compilers.
(szlibd.c, szlibe.c)

Updates code for the change in the ENUM_PTR macros.  (stream.c)

Library

Fixes bugs:
	- A label in the ENUM_PTR procedure generating macros was often not
referenced, leading to compiler warnings.  (gsstruct.h, gxxfont.h,
gdevmem.c, gschar.c, gscolor2.c, gsdevice.c, gsfont0.c, gsht.c, gsstate.c,
gxcpath.c, gximage.c)
	- Using the gstate version of setflat rather than the imager version
caused compiler warnings (and, in some cases, errors).  (gstype1.c)
	- Non-standard ImageMatrix values for banded images didn't work.
(This wasn't actually used.)  (gxclread.c)
	- imagemask with a halftone and portrait orientation colored some
inappropriate pixels.  (bug introduced in 4.30) (gximage2.c)
	- When banding, if a character straddled a band boundary the first
time it occurred, all occurrences of it were clipped.  (bug introduced in
4.2x or 4.30) (gxclimag.c)
	- Degenerate clipping rectangles sometimes got turned into
non-degenerate ones by swapping the min and max coordinates.  (gxcpath.c)
	- Resizing an object either allocated a new object unnecessarily
(performance bug only), or in very rare cases could corrupt memory.
(gsalloc.c)
	- Very small objects didn't get put on a free list when freed.
(Performance bug only.) (gsalloc.c)
	- Some pointers were incorrectly declared 'const', upsetting some
compilers.  (gxclread.c)

Adds more tracing output for -ZL.  (gxclread.c)

Changes the -Za tracing output slightly to aid mechanical analysis of
allocation traces: allocation events now always include a '+', deallocation
events always include a '-', and the address is always the address of the
object data and not the header.  (gsalloc.c, gsmemory.c)

Changes the allocator to keep track of "lost" object and string space
separately, to allow an independent check on its activities.  (gxalloc.h,
gsalloc.c)

Changes the allocator to use 'memmove' in an obvious place.  (gsalloc.c)

Provides a garbage collector API at the library level to allow
implementation of the API in applications other than PostScript
interpreters.  (gsgc.h)


.Println("ok")
3}

`) {
		t.Error("failed to render HTML\n", buffer.String())
	}

	expected := strings.TrimSpace(`/* Background */ .bg { color: #f8f8f2; background-color: #272822; }
/* PreWrapper */ .chroma { color: #f8f8f2; background-color: #272822; }
/* LineNumbers targeted by URL anchor */ .chroma .ln:target { color: #f8f8f2; background-color: #3c3d38 }
/* LineNumbersTable targeted by URL anchor */ .chroma .lnt:target { color: #f8f8f2; background-color: #3c3d38 }
/* Error */ .chroma .err { color: #960050; background-color: #1e0010 }
/* LineLink */ .chroma .lnlinks { outline: none; text-decoration: none; color: inherit }
/* LineTableTD */ .chroma .lntd { vertical-align: top; padding: 0; margin: 0; border: 0; }
/* LineTable */ .chroma .lntable { border-spacing: 0; padding: 0; margin: 0; border: 0; }
/* LineHighlight */ .chroma .hl { background-color: #3c3d38 }
/* LineNumbersTable */ .chroma .lnt { white-space: pre; -webkit-user-select: none; user-select: none; margin-right: 0.4em; padding: 0 0.4em 0 0.4em;color: #7f7f7f }
/* LineNumbers */ .chroma .ln { white-space: pre; -webkit-user-select: none; user-select: none; margin-right: 0.4em; padding: 0 0.4em 0 0.4em;color: #7f7f7f }
/* Line */ .chroma .line { display: flex; }
/* Keyword */ .chroma .k { color: #66d9ef }
/* KeywordConstant */ .chroma .kc { color: #66d9ef }
/* KeywordDeclaration */ .chroma .kd { color: #66d9ef }
/* KeywordNamespace */ .chroma .kn { color: #f92672 }
/* KeywordPseudo */ .chroma .kp { color: #66d9ef }
/* KeywordReserved */ .chroma .kr { color: #66d9ef }
/* KeywordType */ .chroma .kt { color: #66d9ef }
/* NameAttribute */ .chroma .na { color: #a6e22e }
/* NameClass */ .chroma .nc { color: #a6e22e }
/* NameConstant */ .chroma .no { color: #66d9ef }
/* NameDecorator */ .chroma .nd { color: #a6e22e }
/* NameException */ .chroma .ne { color: #a6e22e }
/* NameFunction */ .chroma .nf { color: #a6e22e }
/* NameOther */ .chroma .nx { color: #a6e22e }
/* NameTag */ .chroma .nt { color: #f92672 }
/* Literal */ .chroma .l { color: #ae81ff }
/* LiteralDate */ .chroma .ld { color: #e6db74 }
/* LiteralString */ .chroma .s { color: #e6db74 }
/* LiteralStringAffix */ .chroma .sa { color: #e6db74 }
/* LiteralStringBacktick */ .chroma .sb { color: #e6db74 }
/* LiteralStringChar */ .chroma .sc { color: #e6db74 }
/* LiteralStringDelimiter */ .chroma .dl { color: #e6db74 }
/* LiteralStringDoc */ .chroma .sd { color: #e6db74 }
/* LiteralStringDouble */ .chroma .s2 { color: #e6db74 }
/* Literal


89e0  ! 1063: LDXA_R	ldxa	[%r14, %r0] 0x4f, %r27
cpu_intr_3_77:
	setx	0x240237, %g1, %o0
	ta	T_SEND_THRD_INTR
	.word 0xf2a4e13c  ! 1065: STWA_I	stwa	%r25, [%r19 + 0x013c] %asi
	.word 0xf2b56136  ! 1066: STHA_I	stha	%r25, [%r21 + 0x0136] %asi
cpu_intr_3_78:
	setx	0x270237, %g1, %o0
	ta	T_SEND_THRD_INTR
cpu_intr_3_79:
	setx	0x27012f, %g1, %o0
	ta	T_SEND_THRD_INTR
cpu_intr_3_80:
	setx	0x260138, %g1, %o0
	ta	T_SEND_THRD_INTR
	.word 0xb805c000  ! 1075: ADD_R	add 	%r23, %r0, %r28
T3_asi_reg_rd_41:
	mov	0x3c3, %r14
	.word 0xf8db8e40  ! 1076: LDXA_R	ldxa	[%r14, %r0] 0x72, %r28
cpu_intr_3_81:
	setx	0x24023d, %g1, %o0
	ta	T_SEND_THRD_INTR
	.word 0xb2b40000  ! 1078: ORNcc_R	orncc 	%r16, %r0, %r25
	.word 0xf6352014  ! 1080: STH_I	sth	%r27, [%r20 + 0x0014]
	.word 0xb6a58000  ! 1081: SUBcc_R	subcc 	%r22, %r0, %r27
T3_asi_reg_rd_42:
	mov	0x3c2, %r14
	.word 0xfcdb8e40  ! 1083: LDXA_R	ldxa	[%r14, %r0] 0x72, %r30
	setx	data_start_2, %g1, %r17
	ta	T_CHANGE_HPRIV
	mov	0x38, %g1
	stxa	%r20, [%g1] 0x58
	.word 0x81983e9a  ! 1085: WRHPR_HPSTATE_I	wrhpr	%r0, 0x1e9a, %hpstate
T3_asi_reg_rd_43:
	mov	0x36, %r14
	.word 0xfedb89e0  ! 1086: LDXA_R	ldxa	[%r14, %r0] 0x4f, %r31
	.word 0xf635603c  ! 1088: STH_I	sth	%r27, [%r21 + 0x003c]
cpu_intr_3_82:
	setx	0x26032a, %g1, %o0
	ta	T_SEND_THRD_INTR
	.word 0xf6344000  ! 1090: STH_R	sth	%r27, [%r17 + %r0]
T3_asi_reg_rd_44:
	mov	0x10, %r14
	.word 0xf2db8e40  ! 1098: LDXA_R	ldxa	[%r14, %r0] 0x72, %r25
	.word 0xb1540000  ! 1099: RDPR_GL	rdpr	%-, %r24
T3_asi_reg_rd_45:
	mov	0x2b, %r14
	.word 0xfedb8e80  ! 1100: LDXA_R	ldxa	[%r14, %r0] 0x74, %r31
	.w


 ONLY
	SWAP	D3	CORRECT POSITION
	AND.L	D2,D3	REMAINS BITS ONLY
	AND.L	D6,(A2)	CLEAR HOLE FOR REMAINS
	OR.L	D3,(A2)+	2ND TWO PLANES REMAINS DONE

	AND.L	D7,(A2)	CLEAR HOLE FOR CARRY
	AND.L	D7,4(A2)	FOR ALL PLANES
	OR.L	D4,(A2)	1ST TWO PLANES CARRY DONE

	MOVE.L	(A4)+,D6	MASK FOR 2ND HALF
	ROR.L	D0,D6	ROTATE
	MOVE.L	D6,D7	COPY FOR CARRY
	OR.L	D1,D6	SET CARRY BITS FOR REMAINS MASK
	SWAP	D6	CORRECT POSIION OF REMAINS MASK
	OR.L	D2,D7	SET REMAINS BITS FOR CARRY MASK

	MOVE.L	(A3)+,D3
	ROR.L	D0,D3
	MOVE.L	D3,D4
	AND.L	D1,D4
	SWAP	D3
	AND.L	D2,D3
	AND.L	D6,(A2)
	OR.L	D3,(A2)+

	OR.L	D5,(A2)

	MOVE.L	(A3)+,D3
	ROR.L	D0,D3
	MOVE.L	D3,D5
	AND.L	D1,D5
	SWAP	D3
	AND.L	D2,D3
	AND.L	D6,(A2)
	OR.L	D3,(A2)+

	AND.L	D7,(A2)
	OR.L	D4,(A2)+
	AND.L	D7,(A2)
	OR.L	D5,(A2)+

NEXTMIDLINE	ADDA.W	#136,A2	NEXT DEST. LINE
	SWAP	D0
	ADDQ.W	#1,D0
	ANDI.W	#15,D0
MIDROT	MOVEQ	#0,D3
	SUBQ.W	#1,LINECOUNT
	BNE	MIDLINE

	BTST	#6,FLAGHERE+2	ANY INFILL ?
	BEQ.S	NOBASE	NO
BLOCKTOP	MOVE.W	#0,D0	TOP OF BLOCK
BLOCKHGHT	ADD.W	#0,D0	HEIGHT OF BLOCK
	BGT.S	NOTATTOP
	MOVEQ	#0,D0
NOTATTOP	CMPI.W	#96,D0
	BGE.S	NOBASE

*	ROUTINE TO DRAW INFILL IN CENTRE OF SCREEN
*	NB. A2 POINTS TO START OF DESTINATION
*	    CARRY MASK IN D1, REMAINS MASK IN D2
*	    JUMP OFFSET IN D0 (0-119) FOR 120-1 LINE/S

DRAWMIDBASE	LEA	MIDFILLS,A4
	LSL.W	#3,D0	*8
	ADDA.W	D0,A4	+
	LSL.W	#1,D0	*16
	ADDA.W	D0,A4	=*24
	MOVE.L	PLANES12,D0	1ST 2 PLANES
	MOVE.L	D0,D4	COPY FOR REMAINS
	MOVE.L	D0,D6	COPY FOR CARRY
	AND.L	D2,D4	REMAINS BITS
	AND.L	D1,D6	CARRY BITS
	MOVE.L	PLANES34,D3	2ND 2 PLANES
	MOVE.L	D3,D5	COPY FOR REMAINS
	MOVE.L


        , glActiveVaryingNV, (GLuint program, const GLchar *name)) \
    X (GLint       , glGetVaryingLocationNV, (GLuint program, const GLchar *name)) \
    X (void        , glGetActiveVaryingNV, (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)) \
    X (void        , glGetTransformFeedbackVaryingNV, (GLuint program, GLuint index, GLint *location)) \
    X (void        , glTransformFeedbackStreamAttribsNV, (GLsizei count, const GLint *attribs, GLsizei nbuffers, const GLint *bufstreams, GLenum bufferMode))

#define JUCE_GL_FUNCTIONS_GL_NV_transform_feedback2 \
    X (void        , glBindTransformFeedbackNV, (GLenum target, GLuint id)) \
    X (void        , glDeleteTransformFeedbacksNV, (GLsizei n, const GLuint *ids)) \
    X (void        , glGenTransformFeedbacksNV, (GLsizei n, GLuint *ids)) \
    X (GLboolean   , glIsTransformFeedbackNV, (GLuint id)) \
    X (void        , glPauseTransformFeedbackNV, ()) \
    X (void        , glResumeTransformFeedbackNV, ()) \
    X (void        , glDrawTransformFeedbackNV, (GLenum mode, GLuint id))

#define JUCE_GL_FUNCTIONS_GL_NV_vdpau_interop \
    X (void        , glVDPAUInitNV, (const void *vdpDevice, const void *getProcAddress)) \
    X (void        , glVDPAUFiniNV, ()) \
    X (GLvdpauSurfaceNV, glVDPAURegisterVideoSurfaceNV, (const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames)) \
    X (GLvdpauSurfaceNV, glVDPAURegisterOutputSurfaceNV, (const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames)) \
    X (GLboolean   , glVDPAUIsSurfaceNV, (GLvdpauSurfaceNV surface)) \
    X (void        , glVDPAUUnregisterSurfaceNV, (GLvdpauSurfaceNV surface)) \
    X (void        , glVDPAUGetSurfaceivNV, (GLvdpauSurfaceNV surface, GLenum pname, GLsizei count, GLsizei *length, GLint *values)) \
    X (void        , glVDPAUSurfaceAccessNV, (GLvdpauSurfaceNV surface, GLenum access)) \
    X (void        , glVDPAUMapSurfacesNV, (GLsizei numSurfaces, const GLvdpauSurfaceNV *surfaces)) \
    X (void        , glVDPAUUnmapSurfacesNV, (GLsizei numSurface, const GLvdpauSurfaceNV *surfaces))

#define JUCE_GL_FUNCTIONS_GL_NV_vdpau_interop2 \
    X (GLvdpauSurfaceNV, glVDPAURegisterVideoSurfaceWithPictureStructureNV, (const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames, GLboolean isFrameStructure))

#define JUCE_GL_FUNCTIONS_GL_NV_vertex_array_range \
    X (void        , glFlushVertexArrayRangeNV, ()) \
    X (void        , glVertexArrayRangeNV, (GLsizei length, const void *pointer))

#define JUCE_GL_FUNCTIONS_GL_NV_vertex_attrib_integer_64bit \
    X (void        , glVertexAttribL1i64NV, (GLuint index, GLint64EXT x)) \
    X (void        , glVertexAttribL2i64NV, (GLuint index, GLint64EXT x, GLint64EXT y)) \
    X (void        , glVertexAttribL