ing) {
    makeAutoObservable(this);
    this._id = id;
  }

  addContainer(id: string) {
    this.instances.push(new ContainerInstance(id));
  }
}

export class Wizard {
  states: ContainerState[] = [];

  constructor() {
    makeAutoObservable(this);
  }
}
import { observable, action, runInAction } from 'mobx'
import { store } from '../store'
import { Payload } from '../tools/payload'
import { iterRange } from '../tools/range'

export interface Event {
	type: StoreEventType.Event
	total: number
	max: number | null
	line?: ParsedLine
}

export interface Range {
	type: StoreEventType.Range
	id: string
	lines: ParsedLine[]
}

export interface ParsedLine {
	id: number
	date: Date
	body: object
	meta: {
		message?: string
		level?: string
	}
}

export enum StoreEventType {
	Event = 'event',
	Range = 'range',
}

export type StoreEvent = Event | Range

export class OutputStore {
	@observable.shallow lines: Map<number, Payload<ParsedLine>> = new Map()
	@observable total = 0
	@observable max = -1

	@observable.ref selected?: ParsedLine
	@observable.ref clearToken: Date = new Date()

	@action
	handleEvent(msg: Event) {
		if (msg.line) {
			this.pushLines(msg.line)
		}

		if (msg.total === 0) {
			this.lines.clear()
			this.clearToken = new Date()
		}

		this.total = msg.total
		this.max = msg.max == null ? -1 : msg.max
	}

	@action
	select(msg?: ParsedLine) {
		this.selected = msg
	}

	@action
	pushLines(...lines: ParsedLine[]) {
		for (const line of lines) {
			let payload = this.lines.get(line.id)
			if (payload) {
				payload.becomeValue(line)
			} else {
				this.lines.set(line.id, Payload.Value(line))
			}
		}
	}

	isRowLoaded(index: number) {
		let row = this.lines.get(this.max - index)
		if (!row || row.isNothing() || row.isError()) {
			return false
		} else {
			return true
		}
	}

	@action
	clear() {
		this.lines.clear()
		this.total = 0
		this.max = -1
	}

	@action
	async loadRange(range: { from: number; to: number }) {
		let { from, to } = range

		for (let i of iterRange(from, to)) {
			let payload = this.lines.get(i)
			if (payload) {
				payload.becomeLoading()
			} else {
				this.lines.set(i, Payload.Loading())
			}
		}

		try {
			const res = await store.socket.getLogs({
				from,
				to,
			})

			store.logs.pushLines(...res)
		} catch (e) {
			runInAction(() => {
				for (let i of iterRange(from, to)) {
					let payload = this.lines.get(i)
					if (payload) {
						payload.becomeError(e)
					} else {
						this.lines.set(i, Payload.Error(e))
					}
				}
			})
		}
	}
}
import {Injectable} from '@angular/core';
import {IProduct} from './product.model';
import {Http, Response} from '@angular/http';
import {Observable} from 'rxjs/Observable';
import 'rxjs/add/operator/map';
import 'rxjs/add/operator/catch';

@Injectable()

export class ProductService{

    private _productUrl="https://ngapi4.herokuapp.com/api/getProducts"

    constructor(private _http:Http){}

    getProducts():Observable<IProduct[]>{
        return this._http.get(this._productUrl)
            .map((response:Response


the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.dx.rop.cst;

import com.android.dx.rop.type.Type;
import com.android.dx.util.ByteArray;
import com.android.dx.util.Hex;

/**
 * Constants of type {@code CONSTANT_Utf8_info} or {@code CONSTANT_String_info}.
 */
public final class CstString extends TypedConstant {
    /**
     * {@code non-null;} instance representing {@code ""}, that is, the
     * empty string
     */
    public static final CstString EMPTY_STRING = new CstString("");

    /** {@code non-null;} the UTF-8 value as a string */
    private final String string;

    /** {@code non-null;} the UTF-8 value as bytes */
    private final ByteArray bytes;

    /**
     * Converts a string into its MUTF-8 form. MUTF-8 differs from normal UTF-8
     * in the handling of character '\0' and surrogate pairs.
     *
     * @param string {@code non-null;} the string to convert
     * @return {@code non-null;} the UTF-8 bytes for it
     */
    public static byte[] stringToUtf8Bytes(String string) {
        int len = string.length();
        byte[] bytes = new byte[len * 3]; // Avoid having to reallocate.
        int outAt = 0;

        for (int i = 0; i < len; i++) {
            char c = string.charAt(i);
            if ((c != 0) && (c < 0x80)) {
                bytes[outAt] = (byte) c;
                outAt++;
            } else if (c < 0x800) {
                bytes[outAt] = (byte) (((c >> 6) & 0x1f) | 0xc0);
                bytes[outAt + 1] = (byte) ((c & 0x3f) | 0x80);
                outAt += 2;
            } else {
                bytes[outAt] = (byte) (((c >> 12) & 0x0f) | 0xe0);
                bytes[outAt + 1] = (byte) (((c >> 6) & 0x3f) | 0x80);
                bytes[outAt + 2] = (byte) ((c & 0x3f) | 0x80);
                outAt += 3;
            }
        }

        byte[] result = new byte[outAt];
        System.arraycopy(bytes, 0, result, 0, outAt);
        return result;
    }

    /**
     * Converts an array of UTF-8 bytes into a string.
     *
     * @param bytes {@code non-null;} the bytes to convert
     * @return {@code non-null;} the converted string
     */
    public static String utf8BytesToString(ByteArray bytes) {
        int length = bytes.size();
        char[] chars = new char[length]; // This is sized to avoid a realloc.
        int outAt = 0;

        for (int at = 0; length > 0; /*at*/) {
            int v0 = bytes.getUnsignedByte(at);
            char out;
            switch (v0 >> 4) {
                case 0x00: case 0x01: case 0x02: case 0x03:
                case 0x04: case 0x05: case 0x06: case 0x07: {
                    // 0XXXXXXX -- single-byte encoding
                    length--;
                    if (v0 == 0) {
                        // A single zero byte is illegal.
                        return throwBadUtf8(v0, at);
                    }
                    out = (char) v0;
                    at++;
                    break;
                }
                case 0x0c: case 0x0d: {
                    // 110XXXXX -- two-byte encoding
                    length -= 2;
                    if (length < 0) {
                        return throwBadUtf8(v0, at);
                    }
                    int v1 = bytes.getUnsignedByte(at + 1);
                    if ((v1 & 0xc0)


SizeA, VerQueryValueA},
    },
};

#[cfg(not(target_os = "windows"))]
compile_error!("this is extremely windows dependent");

mod feature;
mod patch;
mod ptc;
mod runtime;
mod winutil;

#[allow(clippy::too_many_lines)] // TODO
fn attach() -> anyhow::Result<()> {
    unsafe {
        // this makes stdout work (eg println!)
        winapi::um::wincon::AttachConsole(winapi::um::wincon::ATTACH_PARENT_PROCESS);

        println!("attach");

        // need to get ptc version without depending on memory addresses since addresses change on different versions
        // unfortunately the code to get exe version with winapi is terrible

        let mut lptstr_filename = [0_i8; 260];
        lptstr_filename[0] = '\0' as i8;
        GetModuleFileNameA(
            std::ptr::null_mut(),
            lptstr_filename.as_mut_ptr(),
            lptstr_filename.len().try_into().unwrap(),
        );
        let mut dw_handle: DWORD = 0;
        let dw_size = GetFileVersionInfoSizeA(lptstr_filename.as_ptr(), &mut dw_handle);

        if dw_size > 0 {
            let mut buf = Vec::new();
            buf.resize(dw_size.try_into().unwrap(), 0);

            if GetFileVersionInfoA(
                lptstr_filename.as_ptr(),
                dw_handle,
                dw_size,
                buf.as_mut_ptr().cast(),
            ) > 0
            {
                let mut pu_len = 0;
                let mut lplp_buffer: *mut libc::c_void = std::ptr::null_mut();
                if VerQueryValueA(
                    buf.as_mut_ptr().cast(),
                    "\\\0".bytes().collect::<Vec<u8>>().as_ptr().cast::<i8>(),
                    &mut lplp_buffer,
                    &mut pu_len,
                ) > 0
                {
                    let v = std::slice::from_raw_parts(
                        lplp_buffer as *const u16,
                        pu_len as usize / std::mem::size_of::<u16>(),
                    );
                    let check = (u32::from(v[1]) << 16) | (u32::from(v[0]) & 0xffff);

                    // https://docs.microsoft.com/en-us/windows/win32/api/verrsrc/ns-verrsrc-vs_fixedfileinfo#members
                    if check == 0xFEEF04BD {
                        // run the mod
                        if let Some(res) = runtime::try_run_version((v[5], v[4], v[7], v[6])) {
                            return res;
                        }

                        println!(
                            "Unsupported PTC version: {}.{}.{}.{}\0",
                            v[5], v[4], v[7], v[6]
                        );
                        let l_msg: Vec<u16> = format!(
                            "Unsupported PTC version: {}.{}.{}.{}\0",
                            v[5], v[4], v[7], v[6]
                        )
                        .encode_utf16()
                        .collect();
                        let l_title: Vec<u16> = "PTC Mod\0".encode_utf16().collect();
                        winuser::MessageBoxW(
                            std::ptr::null_mut(),
                            l_msg.as_ptr(),
                            l_title.as_ptr(),
                            winuser::MB_OK | winuser::MB_ICONERROR,
                        );
                    } else {
                        println!("Failed to fetch version, unsafe to continue: check");
                        let l_msg: Vec<u16> =
                            "Failed to fetch version, unsafe to continue.\n(check)\0"
                                .encode_utf16()
                                .collect();
                        let l_title: Vec<u16> = "PTC Mod\0".encode_utf16().collect();


 = []
        visited = set()
        def add_model(model):
            if model not in processed:
                if model in visited:
                    raise ValueError('Cyclic dependency detected for %s' % model)
                visited.add(model)
                for dep in model._populate_dependencies:
                    add_model(env[dep])
                ordered_models.append(model)
                processed.add(model)
        for model in env.values():
            if model_patterns and not any(fnmatch.fnmatch(model._name, match) for match in model_patterns):
                continue
            if model._transient or model._abstract:
                continue
            ir_model = env['ir.model'].search([('model', '=', model._name)])
            if not model_patterns and all(module.startswith('test_') for module in ir_model.modules.split(',')):
                continue
            add_model(model)

        return ordered_models


 }
  }

  /* ***********************************************************
  * STEP 3
  * `renderRow` function -How each cell/row should be rendered
  * It's our best practice to place a single component here:
  *
  * e.g.
    return <MyCustomCell title={rowData.title} description={rowData.description} />
  *************************************************************/
  renderRow (rowData) {
    return (
      <View style={styles.row}>
        <Text style={styles.boldLabel}>{rowData.title}</Text>
        <Text style={styles.label}>{rowData.description}</Text>
      </View>
    )
  }

  /* ***********************************************************
  * STEP 4
  * If your datasource is driven by Redux, you'll need to
  * reset it when new data arrives.
  * DO NOT! place `cloneWithRows` inside of render, since render
  * is called very often, and should remain fast!  Just replace
  * state's datasource on newProps.
  *
  * e.g.
    componentWillReceiveProps (newProps) {
      if (newProps.someData) {
        this.setState({
          dataSource: this.state.dataSource.cloneWithRows(newProps.someData)
        })
      }
    }
  *************************************************************/

  // Used for friendly AlertMessage
  // returns true if the dataSource is empty
  noRowData () {
    return this.state.dataSource.getRowCount() === 0
  }

  render () {
    return (
      <View style={styles.container}>
        <AlertMessage title='Nothing to See Here, Move Along' show={this.noRowData()} />
        <ListView
          contentContainerStyle={styles.listContent}
          dataSource={this.state.dataSource}
          renderRow={this.renderRow}
          pageSize={15}
        />
      </View>
    )
  }
}

const mapStateToProps = (state) => {
  return {
    // ...redux state to props here
  }
}

export default connect(mapStateToProps)(ListviewExample)
import { StartupTypes } from '../Redux/StartupRedux'
import Config from '../Config/DebugConfig'
import Immutable from 'seamless-immutable'
const Reactotron = require('reactotron-react-native').default
const errorPlugin = require('reactotron-react-native').trackGlobalErrors
const apisaucePlugin = require('reactotron-apisauce')
const { reactotronRedux } = require('reactotron-redux')
const sagaPlugin = require('reactotron-redux-saga')

if (Config.useReactotron) {
  Reactotron
    .configure({
      // host: '10.0.3.2' // default is localhost (on android don't forget to `adb reverse tcp:9090 tcp:9090`)
      name: 'Ignite App' // would you like to see your app's name?
    })

    // forward all errors to Reactotron
    .use(errorPlugin({
      // ignore all error frames from react-native (for example)
      veto: (frame) =>
        frame.fileName.indexOf('/node_modules/react-native/') >= 0
    }))

    // register apisauce so we can install a monitor later
    .use(apisaucePlugin())

    // setup the redux integration with Reactotron
    .use(reactotronRedux({
      // you can flag some of your actions as important by returning true here
      isActionImportant: action => action.type === StartupTypes.STARTUP,

      // you can flag to exclude certain types too... especially the chatty ones
      // except: ['EFFECT_TRIGGERED', 'EFFECT_RESOLVED', 'EFFECT_REJECTED', 'persist/REHYDRATE'],

      // Fires when Reactotron uploads a new copy of the state tree.  Since our reducers are
      // immutable with `seamless-immutable`, we ensure we convert to that format.
      onRestore: state => Immutable(state)
    }))

    // register the redux-saga plugin so we can use the monitor in CreateStore.js
    .use


.com/reference/android/icu/lang/UScript.html#MAKASAR)
        pub const MAKASAR : i32 = 180;

        /// public static final [MALAYALAM](https://developer.android.com/reference/android/icu/lang/UScript.html#MALAYALAM)
        pub const MALAYALAM : i32 = 26;

        /// public static final [MANDAEAN](https://developer.android.com/reference/android/icu/lang/UScript.html#MANDAEAN)
        pub const MANDAEAN : i32 = 84;

        /// public static final [MANDAIC](https://developer.android.com/reference/android/icu/lang/UScript.html#MANDAIC)
        pub const MANDAIC : i32 = 84;

        /// public static final [MANICHAEAN](https://developer.android.com/reference/android/icu/lang/UScript.html#MANICHAEAN)
        pub const MANICHAEAN : i32 = 121;

        /// public static final [MARCHEN](https://developer.android.com/reference/android/icu/lang/UScript.html#MARCHEN)
        pub const MARCHEN : i32 = 169;

        /// public static final [MASARAM_GONDI](https://developer.android.com/reference/android/icu/lang/UScript.html#MASARAM_GONDI)
        pub const MASARAM_GONDI : i32 = 175;

        /// public static final [MATHEMATICAL_NOTATION](https://developer.android.com/reference/android/icu/lang/UScript.html#MATHEMATICAL_NOTATION)
        pub const MATHEMATICAL_NOTATION : i32 = 128;

        /// public static final [MAYAN_HIEROGLYPHS](https://developer.android.com/reference/android/icu/lang/UScript.html#MAYAN_HIEROGLYPHS)
        pub const MAYAN_HIEROGLYPHS : i32 = 85;

        /// public static final [MEDEFAIDRIN](https://developer.android.com/reference/android/icu/lang/UScript.html#MEDEFAIDRIN)
        pub const MEDEFAIDRIN : i32 = 181;

        /// public static final [MEITEI_MAYEK](https://developer.android.com/reference/android/icu/lang/UScript.html#MEITEI_MAYEK)
        pub const MEITEI_MAYEK : i32 = 115;

        /// public static final [MENDE](https://developer.android.com/reference/android/icu/lang/UScript.html#MENDE)
        pub const MENDE : i32 = 140;

        /// public static final [MEROITIC](https://developer.android.com/reference/android/icu/lang/UScript.html#MEROITIC)
        pub const MEROITIC : i32 = 86;

        /// public static final [MEROITIC_CURSIVE](https://developer.android.com/reference/android/icu/lang/UScript.html#MEROITIC_CURSIVE)
        pub const MEROITIC_CURSIVE : i32 = 141;

        /// public static final [MEROITIC_HIEROGLYPHS](https://developer.android.com/reference/android/icu/lang/UScript.html#MEROITIC_HIEROGLYPHS)
        pub const MEROITIC_HIEROGLYPHS : i32 = 86;

        /// public static final [MIAO](https://developer.android.com/reference/android/icu/lang/UScript.html#MIAO)
        pub const MIAO : i32 = 92;

        /// public static final [MODI](https://developer.android.com/reference/android/icu/lang/UScript.html#MODI)
        pub const MODI : i32 = 163;

        /// public static final [MONGOLIAN](https://developer.android.com/reference/android/icu/lang/UScript.html#MONGOLIAN)
        pub const MONGOLIAN


{{ end -}}

      {{ end }}

    {{ humanize ( T "ui_all" ) }} {{ with .Data.Plural }}{{ . | humanize }}{{ end }}

{{- end }}
{{/* Store ordinal, to be retrieved by parent element */}}
{{ if ge hugo.Version "0.93.0" }}
  {{ .Page.Store.Add "Ordinal" 1 }}
{{ end }}

{{/* Handle the "file" named parameter or a single unnamed parameter as the file
path */}}
{{ if .IsNamedParams }}
	{{ $.Scratch.Set "fparameter" ( .Get "file" ) }}
{{ else }}
	{{ $.Scratch.Set "fparameter" ( .Get 0 ) }}
{{ end }}

{{/* If the first character is "/", the path is absolute from the site's
`baseURL`. Otherwise, construct an absolute path using the current directory */}}

{{ if eq (.Scratch.Get "fparameter" | printf "%.1s") "/" }}
  {{ $.Scratch.Set "filepath" ($.Scratch.Get "fparameter") }}
{{ else }}
  {{ $.Scratch.Set "filepath" "/" }}
  {{ $.Scratch.Add "filepath" $.Page.File.Dir }}
  {{ $.Scratch.Add "filepath" ($.Scratch.Get "fparameter") }}
{{ end }}

{{/* If the file exists, read it and highlight it if it's code.
Throw a compile error or print an error on the page if the file is not found */}}

{{ if fileExists ($.Scratch.Get "filepath") }}
  {{ if eq (.Get "code") "true" }}
    {{- highlight ($.Scratch.Get "filepath" | readFile | htmlUnescape |
    safeHTML ) (.Get "lang") "" -}}
  {{ else }}
    {{- $.Scratch.Get "filepath" | os.ReadFile | .Page.RenderString | safeHTML -}}
  {{ end }}
{{ else if eq (.Get "draft") "true" }}

The file {{ $.Scratch.Get "filepath" }} was not found.

{{ else }}{{- errorf "Shortcode %q: file %q not found at %s" .Name ($.Scratch.Get "filepath") .Position -}}{{ end }}

{{- $condition := lower $.Site.Params.buildCondition -}}

{{- if ne $condition "" -}}

    {{- $include_if := lower (.Get "include-if") -}}
    {{- $exclude_if := lower (.Get "exclude-if") -}}

    {{- if and (in $include_if $condition) (in $exclude_if $condition) -}}

        {{- errorf "Build condition %q appears in both include-if and exclude-if parameters of conditional-txt shortcode on page %s" $condition .Position -}}
    {{- end -}}

    {{- if isset $.Params "include-if" -}}

        {{- if in $include_if $condition -}}

{{- .Inner -}}
        {{- else -}}
        {{- end -}}
    {{- else -}}

        {{- if isset $.Params "exclude-if" -}}

            {{- if in $exclude


"`
}

/*
[rateLimit]
enabled = false
ratePerMinute = 100
burst = 10

	[rateLimit.bandwidthLimit]
	enabled = false
	totalLimit = "100mbps"
	totalBurst = "100mbps"
	singleLimit = "10mbps"
	singleBurst = "10mbps"
*/

// RateLimitConfig 定义限速相关的配置
type RateLimitConfig struct {
	Enabled        bool                 `toml:"enabled" wanf:"enabled"`
	RatePerMinute  int                  `toml:"ratePerMinute" wanf:"ratePerMinute"`
	Burst          int                  `toml:"burst" wanf:"burst"`
	BandwidthLimit BandwidthLimitConfig `toml:"bandwidthLimit" wanf:"bandwidthLimit"`
}

// BandwidthLimitConfig 定义带宽限制相关的配置
type BandwidthLimitConfig struct {
	Enabled     bool   `toml:"enabled" wanf:"enabled"`
	TotalLimit  string `toml:"totalLimit" wanf:"totalLimit"`
	TotalBurst  string `toml:"totalBurst" wanf:"totalBurst"`
	SingleLimit string `toml:"singleLimit" wanf:"singleLimit"`
	SingleBurst string `toml:"singleBurst" wanf:"singleBurst"`
}

/*
[outbound]
enabled = false
url = "socks5://127.0.0.1:1080" # "http://127.0.0.1:7890"
*/
// OutboundConfig 定义出站代理相关的配置
type OutboundConfig struct {
	Enabled bool   `toml:"enabled" wanf:"enabled"`
	Url     string `toml:"url" wanf:"url"`
}

/*
[docker]
enabled = false
target = "ghcr" # ghcr/dockerhub
auth = false
[docker.credentials]
user1 = "testpass"
test = "test123"
*/
// DockerConfig 定义 Docker 相关的配置
type DockerConfig struct {
	Enabled         bool              `toml:"enabled" wanf:"enabled"`
	Target          string            `toml:"target" wanf:"target"`
	Auth            bool              `toml:"auth" wanf:"auth"`
	Credentials     map[string]string `toml:"credentials" wanf:"credentials"`
	AuthPassThrough bool              `toml:"authPassThrough" wanf:"authPassThrough"`
}

// LoadConfig 从配置文件加载配置
func LoadConfig(filePath string) (*Config, error) {
	exist, filePath2read := FileExists(filePath)
	if !exist {
		// 楔入配置文件
		err := DefaultConfig().WriteConfig(filePath)
		if err != nil {
			return nil, err
		}
		return DefaultConfig(), nil
	}
	var config Config
	ext := filepath.Ext(filePath2read)
	if ext == ".wanf" {
		if err := wanf.DecodeFile(filePath2read, &config); err != nil {
			return nil, err
		}
		return &config, nil
	}

	if _, err := toml.DecodeFile(filePath2read, &config); err != nil {
		return nil, err
	}
	return &config, nil
}

// WriteConfig 写入配置文件
func (c *Config) WriteConfig(filePath string) error {
	file, err := os.Create(filePath)
	if err != nil {
		return err
	}
	defer file.Close()

	ext := filepath.Ext(filePath)
	if ext == ".wanf" {
		err := wanf.NewStreamEncoder(file).Encode(c)
		if err != nil {
			return err
		}
		return nil
	}

	encoder := toml.NewEncoder(file)
	return encoder.Encode(c)
}

//


1,%mm0
	pxor	%mm7,%mm6
	movq	192(%esp),%mm7
	paddq	%mm6,%mm0
	addl	$8,%ebp
	decl	%edx
	jnz	L00616_79_sse2
	paddq	%mm3,%mm0
	movq	8(%esp),%mm1
	movq	24(%esp),%mm3
	movq	40(%esp),%mm5
	movq	48(%esp),%mm6
	movq	56(%esp),%mm7
	pxor	%mm1,%mm2
	paddq	(%esi),%mm0
	paddq	8(%esi),%mm1
	paddq	16(%esi),%mm2
	paddq	24(%esi),%mm3
	paddq	32(%esi),%mm4
	paddq	40(%esi),%mm5
	paddq	48(%esi),%mm6
	paddq	56(%esi),%mm7
	movl	$640,%eax
	movq	%mm0,(%esi)
	movq	%mm1,8(%esi)
	movq	%mm2,16(%esi)
	movq	%mm3,24(%esi)
	movq	%mm4,32(%esi)
	movq	%mm5,40(%esi)
	movq	%mm6,48(%esi)
	movq	%mm7,56(%esi)
	leal	(%esp,%eax,1),%esp
	subl	%eax,%ebp
	cmpl	88(%esp),%edi
	jb	L004loop_sse2
	movl	92(%esp),%esp
	emms
	popl	%edi
	popl	%esi
	popl	%ebx
	popl	%ebp
	ret
.align	5,0x90
L003SSSE3:
	leal	-64(%esp),%edx
	subl	$256,%esp
	movdqa	640(%ebp),%xmm1
	movdqu	(%edi),%xmm0
.byte	102,15,56,0,193
	movdqa	(%ebp),%xmm3
	movdqa	%xmm1,%xmm2
	movdqu	16(%edi),%xmm1
	paddq	%xmm0,%xmm3
.byte	102,15,56,0,202
	movdqa	%xmm3,-128(%edx)
	movdqa	16(%ebp),%xmm4
	movdqa	%xmm2,%xmm3
	movdqu	32(%edi),%xmm2
	paddq	%xmm1,%xmm4
.byte	102,15,56,0,211
	movdqa	%xmm4,-112(%edx)
	movdqa	32(%ebp),%xmm5
	movdqa	%xmm3,%xmm4
	movdqu	48(%edi),%xmm3
	paddq	%xmm2,%xmm5
.byte	102,15,56,0,220
	movdqa	%xmm5,-96(%edx)
	movdqa	48(%ebp),%xmm6
	movdqa	%xmm4,%xmm5
	movdqu	64(%edi),%xmm4
	paddq	%xmm3,%xmm6
.byte	102,15,56,0,229
	movdqa	%xmm6,-80(%edx)
	movdqa	64(%ebp),%xmm7
	movdqa	%xmm5,%xmm6
	movdqu	80(%edi),%xmm5
	paddq	%xmm4,%xmm7
.byte	102,15,56,0,238
	movdqa	%xmm7,-64(%edx)
	movdqa	%xmm0,(%edx)
	movdqa	80(%ebp),%xmm0
	movdqa	%xmm6,%xmm7
	movdqu	96(%edi),%x


,
    {
      "Name": "LaRC B-200 Super King Air Research Aircraft",
      "Address": "300 E St, SW",
      "City": "Washington",
      "State": "DC",
      "ZIP": "20546",
      "Country": "US"
    },
    {
      "Name": "LaRC Cessna 206 Stationair Research Aircraft",
      "Address": "300 E St, SW",
      "City": "Washington",
      "State": "DC",
      "ZIP": "20546",
      "Country": "US"
    },
    {
      "Name": "LaRC Cirrus SR-22 Research Aircraft",
      "Address": "300 E St, SW",
      "City": "Washington",
      "State": "DC",
      "ZIP": "20546",
      "Country": "US"
    },
    {
      "Name": "LaRC HU-25C Falcon Research Aircraft",
      "Address": "Washington",
      "City": "DC",
      "State": "20546",
      "ZIP": "US",
      "Country": "Hsien (Shen) Yen"
    },
    {
      "Name": "LaRC Lancair Columbia 300 Research Aircraft",
      "Address": "300 E St, SW",
      "City": "Washington",
      "State": "DC",
      "ZIP": "20546",
      "Country": "US"
    },
    {
      "Name": "LaRC OV-10G Research Aircraft",
      "Address": "300 E St, SW",
      "City": "Washington",
      "State": "DC",
      "ZIP": "20546",
      "Country": "US"
    },
    {
      "Name": "WFF C-23 Sherpa Airborne Research Aircraft",
      "Address": "Washington",
      "City": "DC",
      "State": "20546",
      "ZIP": "US",
      "Country": "Hsien (Shen) Yen"
    },
    {
      "Name": "WFF P-3B Research Aircraft",
      "Address": "300 E St, SW",
      "City": "Washington",
      "State": "DC",
      "ZIP": "20546",
      "Country": "US"
    },
    {
      "Name": "A Complex Test Control Center (TCC) #4110",
      "Address": "PA10-Planning, Development, & Analysis Office",
      "City": "Stennis Space Center",
      "State": "MS",
      "ZIP": "39529-6000",
      "Country": "US"
    },
    {
      "Name": "B Complex Test Control Center (TCC) #4210",
      "Address": "PA10-Planning, Development, & Analysis Office",
      "City": "Stennis Space Center",
      "State": "MS",
      "ZIP": "39529-6000",
      "Country": "US"
    },
    {
      "Name": "Barge, Liquid Hydrogen (3 each)",
      "Address": "PA10-Planning, Development, & Analysis Office",
      "City": "Stennis Space Center",
      "State": "MS",
      "ZIP": "39529-6000",
      "Country": "US"
    },
    {
      "Name": "Barge, Liquid Oxygen (6 each)",
      "Address": "PA10-Planning, Development, & Analysis Office",
      "City": "Stennis Space Center",
      "State": "MS",
      "ZIP": "39529-6000",
      "Country": "US"
    },
    {
      "Name": "Canals, Lock & Dock System #0036,2310,2311,2317",
      "Address": "PA10-Planning, Development, & Analysis Office",
      "City": "Stennis Space Center",
      "State": "MS",
      "ZIP": "39529-6000",
      "Country": "US"
    },
    {
      "Name": "Communications Building #1201",
      "Address":


 min( cDwordsToDisplay, cDwordsToDisplayMax );

    //  cap maximum elements to traverse to ensure
    //  we don't loop forever
    //
    cMaxElements = min( cMaxElements, cMaxElementsAbsolute );

    //  traverse linked list and dump each element
    //
    while ( NULL != pbDebuggee
        && cElements < cMaxElements )
    {
        if ( !FReadVariable( pbDebuggee, rgbBuf, cbToFetch ) )
        {
            dprintf( "Error: Could not fetch linked list element at 0x%N.\n", pbDebuggee );
            goto HandleError;
        }

        dprintf( "0x%N%s\n", pbDebuggee, ( cDwordsToDisplay > 0 ? ":" : ""  ) );
        for ( ULONG ib = 0; ib < cDwordsToDisplay * sizeof(DWORD); NULL )
        {
            dprintf( "\t" );
            for ( ULONG ibMaxThisLine = min( ib + ( sizeof(DWORD) * cDwordsPerLine ), cDwordsToDisplay * sizeof(DWORD) );
                ib < ibMaxThisLine;
                ib += sizeof(DWORD) )
            {
                dprintf( "%08x ", *(ULONG *)( rgbBuf + ib ) );
            }
            dprintf( "\n" );
        }
        cElements++;

        if ( pbDebuggee == *(BYTE **)( rgbBuf + ulOffset ) )
        {
            //  SPECIAL-CASE: next pointer points back to this element
            //  (we terminate some linked lists in this fashion)
            //
            break;
        }

        pbDebuggee = *(BYTE **)( rgbBuf + ulOffset );
    }

    dprintf( "\nElements traversed: %d\n", cElements );
    if ( NULL != pbDebuggee )
    {
        dprintf( "(End of list was not reached. Next element: 0x%N)\n", pbDebuggee );
    }

HandleError:
    dprintf( "\n" );

    LocalFree( rgbBuf );
}

//  ================================================================
DEBUG_EXT( EDBGDumpInvasiveList )
//  ================================================================
{
    ULONG           ulOffset                = 0;
    ULONG           cDwordsToDisplay        = 8;
    ULONG           cbToFetch               = 0;
    ULONG           cMaxElements            = 32;
    ULONG           cElements               = 0;
    BOOL            fFollowPrevPointer      = fFalse;
    const ULONG     cDwordsPerLine          = 4;
    const ULONG     cDwordsToDisplayMax     = 0x1000;
    const ULONG     cMaxElementsAbsolute    = 0x8000;
    BYTE *          pbDebuggee              = NULL;
    BYTE *          rgbBuf                  = NULL;
    BOOL            fValidUsage             = fTrue;

    switch ( argc )
    {
        case 4:
            fValidUsage = ( fValidUsage && FUlFromSz( argv[3], &cMaxElements ) );
            //  FALL THROUGH to validate rest of args

        case 3:
            fValidUsage = ( fValidUsage && FUlFromSz( argv[2], &cDwordsToDisplay ) );
            //  FALL THROUGH to validate rest of args

        case 2:
            fFollowPrevPointer = ( '-' == argv[1][0] );
            fValidUsage = ( fValidUsage
                            && FAddressFromSz( argv[0], &pbDebuggee )
                            && FUlFromSz( argv[1] + ( fFollowPrevPointer ? 1 : 0 ), &ulOffset ) );
            break;

        default:
            fValidUsage = fFalse;
            break;
    }

    dprintf( "\n" );

    if ( !fValidUsage )
    {
        dprintf( "Usage: DUMPINVASIVELIST <address> [<+/->]<offset> [<dwords to display> <max elements>]\n" );
        dprintf( "\n" );
        dprintf( "    <address> - address of initial invasive list element (NOT address of invasive list head)\n" );
        dprintf(


track1A1, RZ;\n",

        j7c63 => "--:-:-:Y:5  \@P0 BRA.U LOOP;\n",
            ) :
            (
        j0c1  => "--:-:-:-:1      ISETP.GE.AND P2, PT, k, $k_end, P4;\n",
        j0c3  => "--:-:-:-:1      ISETP.GE.AND P3, PT, k, $k_end, P5;\n",

        j0c10 => "--:-:2:-:1  \@P0 LDG.E.CS loadB0, [trackB + 4x<0>];\n",
        j0c12 => "--:-:2:-:1  \@P0 LDG.E.CS loadB1, [trackB + 4x<1>];\n",
        j0c14 => "--:-:2:-:1  \@P0 LDG.E.CS loadB2, [trackB + 4x<2>];\n",
        j0c16 => "--:-:2:-:1  \@P0 LDG.E.CS loadB3, [trackB + 4x<3>];\n",

        j0c18 => "--:-:-:-:1      ISETP.GE.AND P0, PT, k, $k_end, PT;\n",
        j0c20 => "--:-:-:-:1      IADD32I k, k, -8;\n",

        j0c33 => "--:-:3:-:1  \@P2 LDG.E.CI loadA0, [track0A + 4x<0>];\n",
        j0c35 => "--:-:3:-:1  \@P2 LDG.E.CI loadA1, [track0A + 4x<1>];\n",
        j0c37 => "--:-:3:-:1  \@P2 LDG.E.CI loadA2, [track0A + 4x<2>];\n",
        j0c39 => "--:-:3:-:1  \@P2 LDG.E.CI loadA3, [track0A + 4x<3>];\n",

        j1c29 => "--:-:4:-:1  \@P3 LDG.E.CI loadA4, [track1A + 4x<0>];\n",
        j1c31 => "--:-:4:-:1  \@P3 LDG.E.CI loadA5, [track1A + 4x<1>];\n",
        j1c33 => "--:-:4:-:1  \@P3 LDG.E.CI loadA6, [track1A + 4x<2>];\n",
        j1c35 => "--:-:4:-:1  \@P3 LDG.E.CI loadA7, [track1A + 4x<3>];\n",

        j5c29 => "04:-:-:-:1  \@P0 STS [writeAs + 4x<0*128 + 00>], loadA0;\n",
        j5c31 => "--:-:-:-:1  \@P0 STS [writeAs + 4x<1*128 + 00>], loadA1;\n",
        j5c33 => "--:-:-:-:1  \@P0 STS [writeAs + 4x<2*128 + 00>], loadA2;\n",
        j5c35 => "--:-:-:-:1  \@P0 STS [writeAs + 4x<3*128 + 00>], loadA3;\n",

        j5c46 => "--:-:-:-:1  \@P0 IADD   track0A0.CC, track0A0, 4x<8>;\n",
        j5c54 => "--:-:-:-:1  \@P0 IADD.X track0A1,    track0A1, RZ;\n",

        j6c29 => "08:-:-:-:1  \@P0 STS [writeAs + 4x<0*128 + 64>], loadA4;\n",
        j6c31 => "--:-:-:-:1  \@P0 STS [writeAs + 4x<1*128 + 64>], loadA5;\n",
        j6c33 => "--:-:-:-:1  \@P0 STS [writeAs + 4x<2*128 + 64>], loadA6;\n",
        j6c35 => "--:2:-:-:1  \@P0 STS [writeAs + 4x<3*128 + 64>], loadA7;\n",

        j6c46 => "--:-:-:-:1  \@P0 IADD   track1A0.CC, track1A0, 4x<8>;\n",
        j6c54 => "--:-:-:-:1  \@P0 IADD.X track1A1,    track1A1, RZ;\n",

        j7c63 => "--:-:-:Y:5  \@P0 BRA.U LOOP;\n" .
                 "--:-:-:Y:5  \@P1 BRA.U


):ceil())
--   aux_classifier:add(nn.SpatialConvolution(576,128,1,1,1,1))
--   aux_classifier:add(nn.SpatialBatchNormalization(128,1e-3))
--   aux_classifier:add(nn.ReLU(true))
--   aux_classifier:add(nn.View(128*4*4):setNumInputDims(3))
--   aux_classifier:add(nn.Linear(128*4*4,768))
--   aux_classifier:add(nn.ReLU())
--   aux_classifier:add(nn.Linear(768,opt.num_classes


idator, FormControl } from '@angular/forms';

@Directive({
  selector: '[gtrMinNumber][formControlName],[gtrMinNumber][formControl],[gtrMinNumber][ngModel]',
  providers: [{provide: NG_VALIDATORS, useExisting: MinNumberDirective, multi: true}]
})
export class MinNumberDirective implements Validator {
  @Input() gtrMinNumber: number;

  constructor() { }

  validate(c: FormControl): {[key: string]: boolean} | null {
    let v = c.value;
    return (v < this.gtrMinNumber) ? {'gtrMinNumber': true} : null;
  }

}
import 'reflect-metadata';

import { mainGsFormula } from '@src/common/model/gsFormula.model';
import { Player, SkillsSummaries } from '@src/common/model/player.model';
import { SkillsSummary } from '@src/modules/tacticSummary/model/skillsSummary.model';

import { SkillCalculatorService } from '../skillCalculator.service';

describe('SkillCalculatorService', () => {
    it('Calculate gs for skills summary', () => {
        const service = new SkillCalculatorService(mainGsFormula);

        const skillsSummary: SkillsSummary = {
            main: 36,
            secondary: 22,
            physical: 22,
            tertiary: 31,
            position: 'G',
            gs: 0,
        };
        const result = service.gs(skillsSummary);
        expect(result).toBeCloseTo(74.7844, 4);
    });

    it('Calculate skills summaries for all positions', () => {
        const service = new SkillCalculatorService(mainGsFormula);
        const player: Partial<Player> = {
            skills: {
                handling: 16,
                outOfArea: 20,
                reflexes: 9,
                agility: 13,
                tackling: 7,
                heading: 5,
                passing: 7,
                positioning: 5,
                finishing: 2,
                technique: 5,
                speed: 14,
                strength: 8,
            },
            positionZone: 'G',
        };

        const skillsSummary = service.calculateGs(player as Player);

        expect(skillsSummary).toMatchSnapshot();
    });

    it('Should chould best skills summary', () => {
        const service = new SkillCalculatorService(mainGsFormula);

        const expectedBestSummary = {
            gs: 74.78441666666667,
            main: 36,
            physical: 22,
            position: 'G',
            rank: undefined,
            secondary: 22,
            tertiary: 31,
        };

        const summaries: SkillsSummaries = {
            D: {
                gs: 33.407583333333335,
                main: 12,
                physical: 22,
                position: 'D',
                rank: undefined,
                secondary: 12,
                tertiary: 65,
            },
            F: {
                gs: 24.829,
                main: 7,
                physical: 22,
                position: 'F',
                rank: undefined,
                secondary: 10,
                tertiary: 72,
            },
            G: {
                gs: 74.78441666666667,
                main: 36,
                physical: 22,
                position: 'G',
                rank: undefined,
                secondary: 22,
                tertiary: 31,
            },
            M: {
                gs: 33.407583333333335,
                main: 12,
                physical: 22,
                position: 'M',
                rank: undefined,
                secondary: 12,
                tertiary: 65,
            },
        };

        const bestSkillsSummary = service.chooseBestSummary(summaries);

        expect(best


/// An invalid index, invalid inputs, or invalid depth can cause undefined behaviour.
    ///
    /// The `depth` argument sets the initial call depth. Should be set to `0`.
    ///
    /// # Safety
    /// This function expects a valid `func_idx`, appropriate number of `args`, and valid `depth`.
    pub unsafe fn unsafe_execute(
        &mut self,
        func_idx: u32,
        args: &[Value],
        depth: i32,
    ) -> ExecutionResult {
        ExecutionResult {
            0: sys::fizzy_execute(self.0.as_ptr(), func_idx, args.as_ptr(), depth),
        }
    }
}

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

    #[test]
    fn validate_wasm() {
        // Empty
        assert_eq!(validate(&[]), false);
        // Too short
        assert_eq!(validate(&[0x00]), false);
        // Valid
        assert_eq!(
            validate(&[0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]),
            true
        );
        // Invalid version
        assert_eq!(
            validate(&[0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x01]),
            false
        );
    }

    #[test]
    fn parse_wasm() {
        assert!(parse(&[0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]).is_ok());
        assert!(parse(&[0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x01]).is_err());
    }

    #[test]
    fn instantiate_wasm() {
        let module = parse(&[0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]);
        assert!(module.is_ok());
        let instance = module.unwrap().instantiate();
        assert!(instance.is_ok());
    }

    #[test]
    fn find_exported_function_index() {
        /* wat2wasm
        (module
          (func $f (export "foo") (result i32) (i32.const 42))
          (global (export "g1") i32 (i32.const 0))
          (table (export "tab") 0 anyfunc)
          (memory (export "mem") 1 2)
        )
        */
        let input = hex::decode(
        "0061736d010000000105016000017f030201000404017000000504010101020606017f0041000b07180403666f6f00000267310300037461620100036d656d02000a06010400412a0b").unwrap();

        let module = parse(&input);
        assert!(module.is_ok());
        let instance = module.unwrap().instantiate();
        assert!(instance.is_ok());
        let mut instance = instance.unwrap();

        let func_idx = instance.find_exported_function_index(&"foo");
        assert!(func_idx.is_some());
        assert_eq!(func_idx.unwrap(), 0);

        assert!(instance.find_exported_function_index(&"bar").is_none());
        assert!(instance.find_exported_function_index(&"g1").is_none());
        assert!(instance.find_exported_function_index(&"tab").is_none());
        assert!(instance.find_exported_function_index(&"mem").is_none());
    }

    #[test]
    fn unsafe_execute_wasm() {
        /* wat2wasm
          (func)
          (func (result i32) i32.const 42)
          (func (param i32 i32) (result i32)
            (i32.div_u (local.get 0) (local.get 1))
          )
          (func unreachable)
        */
        let input = hex::decode("0061736d01000000010e036000006000017f60027f7f017f030504000102000a150


using BookServiceAPI.Models;

namespace BookServiceAPI.Repositories
{
    public class BookRepository : IBookRepository
    {
        public static List<Book> books = new List<Book>();
        public void Add(Book book)
        {
            try
            {
                books.Add(book);

            }
            catch (Exception)
            {

                throw;
            }
        }

        public void Delete(int BookId)
        {
            try
            {
                foreach(var book in books)
                {
                    if(book.BookId==BookId)
                    {
                        books.Remove(book);
                    }
                }
            }
            catch (Exception)
            {

                throw;
            }
        }

        public List<Book> GetAll()
        {
            return books;
        }

        public Book GetBook(int BookId)
        {
            try
            {
                foreach(var book in books)
                {
                    if(book.BookId==BookId)
                    {
                        return book;
                    }
                }
                return null;

            }
            catch (Exception)
            {

                throw;
            }
        }

        public List<Book> GetBookByAuthor(string Author)
        {
            List<Book> bok = new List<Book>();
            try
            {
                foreach (var book in books)
                {
                    if (book.Author == Author)
                    {
                        bok.Add(book);
                    }
                }
                return bok;
            }
            catch (Exception)
            {

                throw;
            }
        }

        public List<Book> GetBookById(int BookId)
        {
            List<Book> bok = new List<Book>();
            try
            {
                foreach (var book in books)
                {
                    if (book.BookId == BookId)
                    {
                        bok.Add(book);
                    }
                }


.349L7.06098 6.409L4.93896 8.531Z" fill="var(--color-text)"></path></svg> Settings

Member Visibility
<form>

<input type="checkbox" id="tsd-filter-protected" name="protected"/><svg width="32" height="32" viewBox="0 0 32 32" aria-hidden="true"><rect class="tsd-checkbox-background" width="30" height="30" x="1" y="1" rx="6" fill="none"></rect><path class="tsd-checkbox-checkmark" d="M8.35422 16.8214L13.2143 21.75L24.6458 10.25" stroke="none" stroke-width="3.5" stroke-linejoin="round" fill="none"></path></svg>Protected

<input type="checkbox" id="tsd-filter-inherited" name="inherited" checked/><svg width="32" height="32" viewBox="0 0 32 32" aria-hidden="true"><rect class="tsd-checkbox-background" width="30" height="30" x="1" y="1" rx="6" fill="none"></rect><path class="tsd-checkbox-checkmark" d="M8.35422 16.8214L13.2143 21.75L24.6458 10.25" stroke="none" stroke-width="3.5" stroke-linejoin="round" fill="none"></path></svg>Inherited

</form>

Theme
<select id="theme"><option value="os">OS</option><option value="light">Light</option><option value="dark">Dark</option></select>

<svg width="20" height="20" viewBox="0 0 24 24" fill="none"><path d="M4.93896 8.531L12 15.591L19.061 8.531L16.939 6.409L12 11.349L7.06098 6.409L4.93896 8.531Z" fill="var(--color-text)"></path></svg> Modules

@xbim/viewer -<wbr/> v2.1.0

<svg class="tsd-kind-icon" width="24" height="24" viewBox="0 0 24 24"><rect fill="var(--color-icon-background)" stroke="var(--color-ts-interface)" stroke-width="1.5" x="1" y="1" width="22" height="22" rx="6" id="icon-256-path"></rect><path d="M9.51 16V15.016H11.298V8.224H9.51V7.24H14.19V8.224H12.402V15.016H14.19V16H9.51Z" fill="var(--color-text)" id="icon-256-text"></path></svg>Viewer<wbr/>Interaction<wbr/>Event<wbr/>Map

<svg class="tsd-kind-icon" width="24" height="24" viewBox="0 0 24 24"><use href="#icon-1024-path"></use><use href="#icon-1


                          */
/*  05-19-2020     Timothy Stapko           Initial Version 6.0           */
/*  09-30-2020     Timothy Stapko           Modified comment(s),          */
/*                                            resulting in version 6.1    */
/*                                                                        */
/**************************************************************************/
UINT _nxe_secure_dtls_server_trusted_certificate_remove(NX_SECURE_DTLS_SERVER *server_ptr,
                                                        UCHAR *common_name, UINT common_name_length, UINT cert_id)
{
#ifdef NX_SECURE_ENABLE_DTLS
UINT status;

    if(server_ptr == NX_NULL || common_name == NX_NULL || common_name_length == NX_NULL)
    {
        return(NX_PTR_ERROR);
    }

    /* Call the actual function. */
    status = _nx_secure_dtls_server_trusted_certificate_remove(server_ptr, common_name, common_name_length, cert_id);

    return(status);
#else
    NX_PARAMETER_NOT_USED(server_ptr);
    NX_PARAMETER_NOT_USED(common_name);
    NX_PARAMETER_NOT_USED(common_name_length);
    NX_PARAMETER_NOT_USED(cert_id);

    return(NX_NOT_SUPPORTED);
#endif /* NX_SECURE_ENABLE_DTLS */
}


AccountID,
		CloudIDs:  cloudIDs,
	}
	if _, err := hd.syncCli.Route(kt, params, &gcp.SyncRouteOption{}); err != nil {
		logs.Errorf("sync gcp route failed, err: %v, opt: %v, rid: %s", err, params, kt.Rid)
		return err
	}

	return nil
}

// RemoveDeleteFromCloud ...
func (hd *routeHandler) RemoveDeleteFromCloud(kt *kit.Kit) error {
	if err := hd.syncCli.RemoveRouteDeleteFromCloud(kt, hd.request.AccountID); err != nil {
		logs.Errorf("remove route delete from cloud failed, err: %v, accountID: %s, rid: %s", err,
			hd.request.AccountID, kt.Rid)
		return err
	}

	return nil
}

// Name ...
func (hd *routeHandler) Name() enumor.CloudResourceType {
	return enumor.RouteCloudResType
}
/*
 * TencentBlueKing is pleased to support the open source community by making
 * 蓝鲸智云 - 混合云管理平台 (BlueKing - Hybrid Cloud Management System) available.
 * Copyright (C) 2022 THL A29 Limited,
 * a Tencent company. All rights reserved.
 * Licensed under the MIT License (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at http://opensource.org/licenses/MIT
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * We undertake not to change the open source license (MIT license) applicable
 *
 * to the current version of the project delivered to anyone in the future.
 */

package azure

import (
	"fmt"

	ressync "hcm/cmd/hc-service/logics/res-sync"
	"hcm/cmd/hc-service/logics/res-sync/azure"
	"hcm/cmd/hc-service/service/sync/handler"
	adazure "hcm/pkg/adaptor/azure"
	typesni "hcm/pkg/adaptor/types/network-interface"
	"hcm/pkg/api/hc-service/sync"
	"hcm/pkg/criteria/constant"
	"hcm/pkg/criteria/enumor"
	"hcm/pkg/kit"
	"hcm/pkg/logs"
	"hcm/pkg/rest"
	"hcm/pkg/tools/slice"

	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/network/armnetwork/v2"
)

// SyncNetworkInterface ....
func (svc *service) SyncNetworkInterface(cts *rest.Contexts) (interface{}, error) {
	return nil, handler.ResourceSync(cts, &networkInterfaceHandler{cli: svc.syncCli})
}

// networkInterfaceHandler networkInterface sync handler.
type networkInterfaceHandler struct {
	cli ressync.Interface

	// Prepare 构建参数
	request *sync.AzureSyncReq
	syncCli azure.Interface
	pager   *adazure.Pager[armnetwork.InterfacesClientListAllResponse, typesni.AzureNI]
}

var _ handler.Handler = new(networkInterfaceHandler)

// Prepare ...
func (hd *networkInterfaceHandler) Prepare(cts *rest.Contexts) error {
	request, syncCli, err := defaultPrepare(cts, hd.cli)
	if err != nil {
		return err
	}

	hd.request = request
	hd.syncCli = syncCli

	pager, err := hd.syncCli.CloudCli().ListNetworkInterfaceByPage(cts.Kit)
	if err != nil {


#if !UNITY_WEBGL || UNITY_EDITOR

using System;
using System.Diagnostics;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Networking.Transport.Logging;

namespace Unity.Networking.Transport
{
    internal static class WebSocket
    {
        [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
        static void Warn(string msg) => DebugLog.LogWarning(msg);

        [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
        static void WarnIf(bool condition, string msg) { if (condition) DebugLog.LogWarning(msg); }

        public enum Opcode
        {
            Continuation = 0,
            TextData = 1,
            BinaryData = 2,
            Close = 8,
            Ping = 9,
            Pong = 10
        }

        public enum StatusCode
        {
            Normal = 1000,
            ProtocolError = 1002,
            UnsupportedDataType = 1003,
            MessageTooBig = 1009,
            InternalError = 1011,
        }

        public enum State
        {
            None,
            ClosedAndFlushed,
            Closed,
            Closing,
            Opening,
            Open,
        }

        public enum Role
        {
            Server = 0, // incoming (passive) connection
            Client = 1, // outgoing (active) connection
        }

        public static unsafe void Connect(ref Buffer buffer, ref NetworkEndpoint remoteEndpoint, ref Keys keys)
        {
            FixedString32Bytes end = "\r\n";
            FixedString512Bytes handshake = "GET / HTTP/1.1\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Version: 13\r\n";
            FixedString32Bytes key = "Sec-WebSocket-Key: ";
            handshake.Append(key);
            GenerateBase64Key(out key, ref keys);
            handshake.Append(key);
            handshake.Append(end);
            FixedString128Bytes host = "Host: ";
            handshake.Append(host);
            handshake.Append(remoteEndpoint.ToFixedString());
            handshake.Append(end);
            handshake.Append(end);

            fixed (byte* data = buffer.Data)
            {
                UnsafeUtility.MemCpy(data, handshake.GetUnsafePtr(), (uint)handshake.Length);
            }
            buffer.Length = handshake.Length;
        }

        public static unsafe State Handshake(ref Buffer recvbuffer, ref Buffer sendbuffer, bool isClient, ref Keys keys)
        {
            if (recvbuffer.Length == 0)
                return State.Opening;

            // If we can't find an ETX the message is not complete yet.
            var complete = false;
            int length;
            for (length = 0; length < recvbuffer.Length - 3 && !complete; ++length)
                complete = recvbuffer.Data[length] == '\r'
                        && recvbuffer.Data[length + 1] == '\n'
                        && recvbuffer.Data[length + 2] == '\r'
                        && recvbuffer.Data[length + 3] == '\n';

            if (!complete)
                return State.Opening;

            length += 3;
            fixed (byte* data = recvbuffer.Data)
            {
                // If you need to inspect this while debugging open the Immediate Window in Visual Studio and enter
                // "System.Text.Encoding.UTF8.GetString(recvHandshake)"
                var recvHandshake = data;
                var recvHandshakeLength = length;

                int lineStart = 0;
                int lineEnd = 0;
                while (recvHandshake[lineEnd] != '\r' || recvHandshake[lineEnd + 1] != '\n')
                    ++lineEnd;

                int firstLineEnd = lineEnd;
                var headerLookup = new NativeParallelHashMap<FixedString512Bytes, FixedString512Bytes>(16, Allocator.Temp);
                while (true)
                {
                    lineEnd += 2;
                    lineStart = lineEnd;
                    while (recvHandshake[lineEnd] != '\r' || recvHandshake[lineEnd + 1] != '\n')
                        ++lineEnd;

                    if (lineStart == lineEnd)
                        break;

                    // Found a line - analyze it


@RunWith(AndroidJUnit4::class)
internal class RepoUriGetterTest {
    @Test
    fun testTrailingSlash() {
        val uri = RepoUriGetter.getUri("http://example.org/fdroid/repo/")
        assertEquals("http://example.org/fdroid/repo", uri.uri.toString())
        assertNull(uri.fingerprint)
    }

    @Test
    fun testWithoutTrailingSlash() {
        val uri = RepoUriGetter.getUri("http://example.org/fdroid/repo")
        assertEquals("http://example.org/fdroid/repo", uri.uri.toString())
        assertNull(uri.fingerprint)
    }

    @Test
    fun testFingerprint() {
        val uri = RepoUriGetter.getUri("https://example.org/repo?fingerprint=foobar&test=42")
        assertEquals("https://example.org/repo", uri.uri.toString())
        assertEquals("foobar", uri.fingerprint)
    }

    @Test
    fun testFingerprintWithTrailingWhitespace() {
        val uri1 = RepoUriGetter.getUri("https://example.org/repo?fingerprint=foobar ")
        assertEquals("https://example.org/repo", uri1.uri.toString())
        assertEquals("foobar", uri1.fingerprint)

        val uri2 = RepoUriGetter.getUri("https://example.org/repo?fingerprint=foobar     ")
        assertEquals("https://example.org/repo", uri2.uri.toString())
        assertEquals("foobar", uri2.fingerprint)
    }

    @Test
    fun testHash() {
        val uri = RepoUriGetter.getUri("https://example.org/repo?fingerprint=foobar&test=42#hash")
        assertEquals("https://example.org/repo", uri.uri.toString())
        assertEquals("foobar", uri.fingerprint)
    }

    @Test
    fun testAddFdroidSlashRepo() {
        val uri = RepoUriGetter.getUri("https://example.org")
        assertEquals("https://example.org/fdroid/repo", uri.uri.toString())
        assertNull(uri.fingerprint)
    }

    @Test
    fun testLeaveSingleRepo() {
        val uri = RepoUriGetter.getUri("https://example.org/repo")
        assertEquals("https://example.org/repo", uri.uri.toString())
        assertNull(uri.fingerprint)
    }

    @Test
    fun testAddsMissingRepo() {
        val uri = RepoUriGetter.getUri("https://example.org/fdroid/")
        assertEquals("https://example.org/fdroid/repo", uri.uri.toString())
        assertNull(uri.fingerprint)
    }

    @Test
    fun testFDroidLink() {
        val uri1 = RepoUriGetter.getUri(
            "https://fdroid.link/index.html#https://f-droid.org/repo?" +
                "fingerprint=43238d512c1e5eb2d6569f4a3afbf5523418b82e0a3ed1552770abb9a9c9ccab"
        )
        assertEquals("https://f-droid.org/repo", uri1.uri.toString())
        assertEquals(
            "43238d512c1e5eb2d6569f4a3afbf5523418b82e0a3ed1552770abb9a9c9ccab",
            uri1.fingerprint
        )

        val uri2 = RepoUriGetter.getUri("https://fdroid.link#https://f-droid.org/repo")
        assertEquals("https://f-droid.org/repo", uri2.uri.toString())
        assertNull(uri2.fingerprint)

        val uri3 = RepoUriGetter.getUri("https://fdroid.link/#http://f-droid.org/repo")
        assertEquals("http://


her.finalize()
//! };
//! let digest = digest.as_slice();
//!
//! // creates the cryptographic core of the signature without any metadata
//! let signature = signing_key
//!     .create_signature(passwd_fn, HashAlgorithm::SHA2_256, digest)
//!     .expect("Failed to crate signature");
//!
//! // the signature can already be verified
//! verification_key
//!     .verify_signature(HashAlgorithm::SHA2_256, digest, &signature)
//!     .expect("Failed to validate signature");
//!
//! // wraps the signature in the apropriate package fmt ready to be serialized
//! let signature = Signature::new(
//!     types::Version::Old,
//!     packet::SignatureVersion::V4,
//!     packet::SignatureType::Binary,
//!     PublicKeyAlgorithm::RSA,
//!     HashAlgorithm::SHA2_256,
//!     [digest[0], digest[1]],
//!     signature,
//!     vec![
//!         packet::Subpacket::SignatureCreationTime(now),
//!         packet::Subpacket::Issuer(signing_key.key_id()),
//!     ],
//!     vec![],
//! );
//!
//! // sign and and write the package (the package written here is NOT rfc4880 compliant)
//! let mut signature_bytes = Vec::with_capacity(1024);
//!
//! let mut buff = Cursor::new(&mut signature_bytes);
//! packet::write_packet(&mut buff, &signature)
//!     .expect("Write must succeed");
//!
//!
//! let raw_signature = signature.signature;
//! verification_key
//!     .verify_signature(HashAlgorithm::SHA2_256, digest, &raw_signature)
//!     .expect("Verify must succeed");
//! ```

#[macro_use]
mod key_parser_macros;

pub mod parse;
pub mod public;
pub mod secret;
pub mod shared;

pub use self::parse::*;
pub use self::public::*;
pub use self::secret::*;
pub use self::shared::*;
// Copyright 2020 <NAME>
// SPDX-License-Identifier: Apache-2.0

use crate::{payload::transaction::constants::IOTA_SUPPLY, Error};

use bee_common::packable::{Packable, Read, Write};

use std::ops::RangeInclusive;

pub(crate) const TREASURY_OUTPUT_KIND: u8 = 2;
// TODO check if this is correct
const TREASURY_OUTPUT_AMOUNT: RangeInclusive<u64> = 1..=IOTA_SUPPLY;

#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TreasuryOutput {
    amount: u64,
}

impl TreasuryOutput {
    pub fn new(amount: u64) -> Result<Self, Error> {
        if !TREASURY_OUTPUT_AMOUNT.contains(&amount) {
            return Err(Error::InvalidTreasuryAmount(amount));
        }

        Ok(Self { amount })
    }

    pub fn amount(&self) -> u64 {
        self.amount
    }
}

impl Packable for TreasuryOutput {
    type Error = Error;

    fn packed_len(&self) -> usize {
        self.amount.packed_len()
    }

    fn pack<W: Write>(&self, writer: &mut W) -> Result<(), Self::Error> {
        self.amount.pack(writer)?;

        Ok(())
    }

    fn unpack<R: Read + ?Sized>(reader: &mut R) -> Result<Self, Self::Error> {
        Self::new(u64::unpack(reader)?)
    }
}
extern crate byteorder;
extern crate clap;
extern crate image;
#[macro_use]
extern crate lazy_static;

pub mod error;
pub mod format;

use error::*;
use std::fs::{self, File};
use std::path::Path;
use std::fmt::Write as WF;
use std::io::{Write as WI, BufReader};
use clap::{App, Arg, Sub


,
  y: number,
  color: Array<number>
) => {
  const w = imgData.width;
  const d = imgData.data;
  d[4 * (y * w + x)] = color[0];
  d[4 * (y * w + x) + 1] = color[1];
  d[4 * (y * w + x) + 2] = color[2];
  d[4 * (y * w + x) + 3] = color[3];
};

/**
 * 绘制马赛克
 *    实现思路：
 *      1. 获取鼠标划过路径区域的图像信息
 *      2. 将区域内的像素点绘制成周围相近的颜色
 * @param mouseX 当前鼠标X轴坐标
 * @param mouseY 当前鼠标Y轴坐标
 * @param size 马赛克画笔大小
 * @param degreeOfBlur 马赛克模糊度
 * @param context 需要进行绘制的画布
 */
export function drawMosaic(
  mouseX: number,
  mouseY: number,
  size: number,
  degreeOfBlur: number,
  context: CanvasRenderingContext2D
) {
  // 获取设备像素比
  const dpr = window.devicePixelRatio || 1;
  // 获取鼠标经过区域的图片像素信息
  const imgData = context.getImageData(
    mouseX * dpr,
    mouseY * dpr,
    size * dpr,
    size * dpr
  );
  // 获取图像宽高
  const w = imgData.width;
  const h = imgData.height;
  // 等分图像宽高
  const stepW = w / degreeOfBlur;
  const stepH = h / degreeOfBlur;
  // 循环画布像素点
  for (let i = 0; i < stepH; i++) {
    for (let j = 0; j < stepW; j++) {
      // 随机获取一个小方格的随机颜色
      const color = getAxisColor(
        imgData,
        j * degreeOfBlur + Math.floor(Math.random() * degreeOfBlur),
        i * degreeOfBlur + Math.floor(Math.random() * degreeOfBlur)
      );
      // 循环小方格的像素点
      for (let k = 0; k < degreeOfBlur; k++) {
        for (let l = 0; l < degreeOfBlur; l++) {
          // 设置小方格的颜色
          setAxisColor(
            imgData,
            j * degreeOfBlur + l,
            i * degreeOfBlur + k,
            color
          );
        }
      }
    }
  }
  // 渲染打上马赛克后的图像信息
  context.putImageData(imgData, mouseX * dpr, mouseY * dpr);
}
import * as t from "io-ts";

import ErrorBase, { errorObject } from "./ErrorBase";

type V = {
	error?: undefined;
	[K: string]: unknown;
};

// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
const succeedResult = <T extends t.Mixed>(valueType: T) =>
	t.intersection([
		valueType,
		t.partial({
			error: t.undefined
		})
	]);

type SucceededResult<T> = T & {
	error?: undefined;
};

const failedResult = t.type({
	error: errorObject
});

export type FailedResult = t.TypeOf<typeof failedResult>;

// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
export const result = <T extends t.Mixed>(valueType: T) =>
	t.union([succeedResult(valueType), failedResult]);

type Result<T> = SucceededResult<T> | FailedResult;

export const fromError = <E extends ErrorBase>(error: E): FailedResult => {
	return {
		error: error.toObject()
	};
};

export const fromValue = <T extends V>(value: T): SucceededResult<T> => {
	return value;
};

// eslint-disable-next-line no-undef
export default Result;
// import { IAbstractData } from "../interfaces/iCharactersData";

import { Factory } from "./factory";

export class AbstractData<T> {
    public count: number;
    public next: string;
    public previous: string;
    public results: T[];
    p


         "elapsed_precise" => {
                        format!("{}", FormattedDuration(state.started.elapsed()))
                    }
                    "elapsed" => format!("{:#}", HumanDuration(state.started.elapsed())),
                    "per_sec" => format!("{:.4}/s", state.per_sec()),
                    "bytes_per_sec" => format!("{}/s", HumanBytes(state.per_sec() as u64)),
                    "binary_bytes_per_sec" => {
                        format!("{}/s", BinaryBytes(state.per_sec() as u64))
                    }
                    "eta_precise" => format!("{}", FormattedDuration(state.eta())),
                    "eta" => format!("{:#}", HumanDuration(state.eta())),
                    "duration_precise" => format!("{}", FormattedDuration(state.duration())),
                    "duration" => format!("{:#}", HumanDuration(state.duration())),
                    _ => "".into(),
                }
            });

            rv.push(if let Some(ref var) = wide_element {
                let total_width = state.width();
                if var.key == "bar" {
                    let bar_width = total_width.saturating_sub(measure_text_width(&s));
                    s.replace(
                        "\x00",
                        &self.format_bar(state.fraction(), bar_width, var.alt_style.as_ref()),
                    )
                } else if var.key == "msg" {
                    let msg_width = total_width.saturating_sub(measure_text_width(&s));
                    let msg = pad_str(state.message(), msg_width, var.align, true);
                    s.replace(
                        "\x00",
                        if var.last_element {
                            msg.trim_end()
                        } else {
                            &msg
                        },
                    )
                } else {
                    unreachable!()
                }
            } else {
                s.to_string()
            });
        }

        rv
    }
}

fn expand_template<F: FnMut(&TemplateVar<'_>) -> String>(s: &str, mut f: F) -> Cow<'_, str> {
    lazy_static::lazy_static! {
        static ref VAR_RE: Regex = Regex::new(r"(\}\})|\{(\{|[^{}}]+\})").unwrap();
        static ref KEY_RE: Regex = Regex::new(
            r"(?x)
                ([^:]+)
                (?:
                    :
                    ([<^>])?
                    ([0-9]+)?
                    (!)?
                    (?:\.([0-9a-z_]+(?:\.[0-9a-z_]+)*))?
                    (?:/([a-z_]+(?:\.[a-z_]+)*))?
                )?
            "
        )
        .unwrap();
    }
    VAR_RE.replace_all(s, |caps: &Captures<'_>| {
        if caps.get(1).is_some() {
            return "}".into();
        }
        let key = &caps[2];
        if key == "{" {
            return "{".into();
        }
        let mut var = TemplateVar {
            key,
            align: Alignment::Left,
            truncate: false,
            width: None,
            style: None,
            alt_style: None,
            last_element: caps.get(0).unwrap().end() >= s.len(),
        };
        if let Some(opt_caps) = KEY_RE.captures(&key[..key.len() - 1]) {
            if let Some(short_key) = opt_caps.get(1) {
                var.key = short_key.as_str();
            }
            var.align = match opt_caps.get(2).map(|x| x.as_str()) {
                Some("<") => Alignment::Left,
                Some("^") => Alignment::Center,
                Some(">") => Alignment::Right,
                _ => Alignment::Left,
            };
            if let Some(width) = opt_caps.get(3) {
                var.width = Some(width.as_str().parse().unwrap


yIndex(int index) {
        return entryByIndex(index, PoolEntry.class);
    }

    private static boolean checkTag(int tag, Class<?> cls) {
        var type = switch (tag) {
            // JVMS Table 4.4-B. Constant pool tags
            case TAG_UTF8 -> AbstractPoolEntry.Utf8EntryImpl.class;
            case TAG_INTEGER -> AbstractPoolEntry.IntegerEntryImpl.class;
            case TAG_FLOAT -> AbstractPoolEntry.FloatEntryImpl.class;
            case TAG_LONG -> AbstractPoolEntry.LongEntryImpl.class;
            case TAG_DOUBLE -> AbstractPoolEntry.DoubleEntryImpl.class;
            case TAG_CLASS -> AbstractPoolEntry.ClassEntryImpl.class;
            case TAG_STRING -> AbstractPoolEntry.StringEntryImpl.class;
            case TAG_FIELDREF -> AbstractPoolEntry.FieldRefEntryImpl.class;
            case TAG_METHODREF -> AbstractPoolEntry.MethodRefEntryImpl.class;
            case TAG_INTERFACE_METHODREF -> AbstractPoolEntry.InterfaceMethodRefEntryImpl.class;
            case TAG_NAME_AND_TYPE -> AbstractPoolEntry.NameAndTypeEntryImpl.class;
            case TAG_METHOD_HANDLE -> AbstractPoolEntry.MethodHandleEntryImpl.class;
            case TAG_METHOD_TYPE -> AbstractPoolEntry.MethodTypeEntryImpl.class;
            case TAG_DYNAMIC -> AbstractPoolEntry.ConstantDynamicEntryImpl.class;
            case TAG_INVOKE_DYNAMIC -> AbstractPoolEntry.InvokeDynamicEntryImpl.class;
            case TAG_MODULE -> AbstractPoolEntry.ModuleEntryImpl.class;
            case TAG_PACKAGE -> AbstractPoolEntry.PackageEntryImpl.class;
            default -> null;
        };
        return type != null && cls.isAssignableFrom(type);
    }

    static <T extends PoolEntry> T checkType(PoolEntry e, int index, Class<T> cls) {
        if (cls.isInstance(e)) return cls.cast(e);
        throw checkTypeError(index, cls);
    }

    private static ConstantPoolException checkTypeError(int index, Class<?> cls) {
        return new ConstantPoolException("Not a " + cls.getSimpleName() + " at index: " + index);
    }

    @Override
    public <T extends PoolEntry> T entryByIndex(int index, Class<T> cls) {
        Objects.requireNonNull(cls);
        if (index <= 0 || index >= constantPoolCount) {
            throw new ConstantPoolException("Bad CP index: " + index);
        }
        PoolEntry info = cp[index];
        if (info == null) {
            int offset = cpOffset[index];
            if (offset == 0) {
                throw new ConstantPoolException("Unusable CP index: " + index);
            }
            int tag = readU1(offset);
            if (!checkTag(tag, cls)) {
                throw new ConstantPoolException(
                        "Bad tag (" + tag + ") at index (" + index + ") position (" + offset + "), expected " + cls.getSimpleName());
            }
            final int q = offset + 1;
            info = switch (tag) {
                case TAG_UTF8 -> new AbstractPoolEntry.Utf8EntryImpl(this, index, buffer, q + 2, readU2(q));
                case TAG_INTEGER -> new AbstractPoolEntry.IntegerEntryImpl(this, index, readInt(q));
                case TAG_FLOAT -> new AbstractPoolEntry.FloatEntryImpl(this, index, readFloat(q));
                case TAG_LONG -> new AbstractPoolEntry.LongEntryImpl(this, index, readLong(q));
                case TAG_DOUBLE -> new AbstractPoolEntry.DoubleEntryImpl(this, index, readDouble(q));
                case TAG_CLASS -> new AbstractPoolEntry.ClassEntryImpl(this, index, readEntry(q, AbstractPoolEntry.Utf8EntryImpl.class));
                case TAG_STRING -> new AbstractPoolEntry.StringEntryImpl(this, index, readEntry(q, AbstractPoolEntry.Utf8EntryImpl.class));
                case TAG_FIELDREF -> new AbstractPoolEntry.FieldRefEntryImpl(this, index, readEntry


/*
 * Copyright (c) The mlkem-native project authors
 * SPDX-License-Identifier: Apache-2.0 OR ISC OR MIT
 */

#include "../../../common.h"
#if defined(MLK_ARITH_BACKEND_X86_64_DEFAULT) && \
    !defined(MLK_CONFIG_MULTILEVEL_NO_SHARED)
/* simpasm: header-end */

#include "consts.h"

.macro mulcache_compute_iter i
vmovdqa (64*\i+16)*2(%rsi), %ymm2
vmovdqa (64*\i+48)*2(%rsi), %ymm3
vmovdqa (MLK_AVX2_BACKEND_DATA_OFFSET_MULCACHE_TWIDDLES + 16*\i)*2(%rdx), %ymm4
vmovdqa (MLK_AVX2_BACKEND_DATA_OFFSET_MULCACHE_TWIDDLES + 64 + 16*\i)*2(%rdx), %ymm1

vpmullw %ymm2, %ymm1, %ymm5
vpmullw %ymm3, %ymm1, %ymm6

vpmulhw %ymm2, %ymm4, %ymm7
vpmulhw %ymm3, %ym


PROTO_0:
  GETUPVAL R0 0
  NAMECALL R0 R0 K0 ["Disconnect"]
  CALL R0 1 0
  GETUPVAL R0 1
  LOADNIL R1
  CALL R0 1 0
  RETURN R0 0

PROTO_1:
  GETUPVAL R0 0
  LOADK R2 K0 ["ShareDialogModel"]
  GETUPVAL R3 1
  NAMECALL R0 R0 K1 ["OnSetItem"]
  CALL R0 3 1
  GETUPVAL R1 1
  GETUPVAL R2 0
  LOADK R4 K0 ["ShareDialogModel"]
  NAMECALL R2 R2 K2 ["GetItem"]
  CALL R2 2 -1
  CALL R1 -1 0
  NEWCLOSURE R1 P0
  CAPTURE VAL R0
  CAPTURE UPVAL U1
  RETURN R1 1

PROTO_2:
  GETUPVAL R0 0
  LOADK R2 K0 ["ShareAccess"]
  NAMECALL R0 R0 K1 ["Invoke"]
  CALL R0 2 0
  RETURN R0 0

PROTO_3:
  GETUPVAL R0 0
  LOADK R2 K0 ["ShareDialogDismissed"]
  NAMECALL R0 R0 K1 ["Invoke"]
  CALL R0 2 0
  RETURN R0 0

PROTO_4:
  GETUPVAL R1 0
  GETTABLEKS R0 R1 K0 ["use"]
  CALL R0 0 1
  NAMECALL R0 R0 K1 ["get"]
  CALL R0 1 1
  GETUPVAL R2 1
  GETTABLEKS R1 R2 K2 ["useState"]
  LOADNIL R2
  CALL R1 1 2
  GETUPVAL R4 1
  GETTABLEKS R3 R4 K3 ["useEffect"]
  NEWCLOSURE R4 P0
  CAPTURE VAL R0
  CAPTURE VAL R2
  NEWTABLE R5 0 2
  MOVE R6 R0
  MOVE


-- Define icons and titles for special filetypes.
-- icons are used by tabline, winbar and statusline.
-- titles are used by tabline.

local icons = require('rockyz.icons')

local special_filetypes = {
    aerial = {
        icon = icons.misc.outline,
        title = 'Outline [Aerial]',
    },
    ['ccc-ui'] = {
        icon = icons.misc.color,
        title = 'Color Picker',
    },
    cmdwin = { -- for Command-line window
        icon = icons.misc.code,
        title = 'Command-line',
    },
    floggraph = {
        icon = icons.misc.graph,
        title = 'Flog Graph',
    },
    fugitive = {
        icon = icons.git.branch,
        title = 'Fugitive',
    },
    fugitiveblame = {
        icon = icons.git.commit,
        title = 'Fugitive Blame',
    },
    fzf = {
        icon = icons.misc.search,
        title = 'FZF',
    },
    ['gitsigns.blame'] = {
        icon = icons.git.commit,
        title = 'Gitsigns Blame',
    },
    harpoon = {
        icon = icons.misc.list,
        title = 'Harpoon List',
    },
    help = {
        icon = icons.misc.help,
        title = 'Vim Help',
    },
    kitty_scrollback = {
        icon = ico


): TOutput {
  return Object.keys(map).reduce((result: TOutput, key: string) => {
    return reducer(result, map[key], key);
  }, initial);
}
import { DateTime } from 'luxon';

import {
  AKAMAI_DATE,
  PAYMENT_HARD_MAX,
  PAYMENT_MIN,
  PAYMENT_SOFT_MAX,
} from 'src/constants';
import { TaxDetail } from 'src/featureFlags';
import { parseAPIDate } from 'src/utilities/date';

export const cleanCVV = (input: string): string => {
  // All characters except numbers
  const regex = /(([\D]))/g;

  // Prevents more than 4 characters from being submitted
  const cvv = input.slice(0, 4);
  return cvv.replace(regex, '');
};

export const getTaxID = (
  invoiceItemDate: string,
  taxDate?: string,
  country_tax?: TaxDetail
) => {
  if (!country_tax?.tax_id || !taxDate) {
    return undefined;
  }
  const taxStartedBeforeThisInvoiceItem =
    Date.parse(invoiceItemDate) > Date.parse(taxDate);
  return taxStartedBeforeThisInvoiceItem ? country_tax : undefined;
};

export const renderUnitPrice = (v: null | string) => {
  const parsedValue = parseFloat(`${v}`);
  return Number.isNaN(parsedValue) ? null : `$${parsedValue}`;
};

export const getShouldUseAkamaiBilling = (date: string) => {
  const invoiceDate = parseAPIDate(date);
  const akamaiDate = DateTime.fromSQL(AKAMAI_DATE);
  return invoiceDate > akamaiDate;
};

export function getPaymentLimits(
  balance: number | undefined
): { max: number; min: number } {
  if (balance === undefined) {
    return { max: PAYMENT_HARD_MAX, min: PAYMENT_MIN };
  }

  return {
    max: balance <= PAYMENT_SOFT_MAX ? PAYMENT_SOFT_MAX : PAYMENT_HARD_MAX,
    min: balance < PAYMENT_MIN && balance > 0 ? balance : PAYMENT_MIN,
  };
}
import { Injectable } from '@angular/core';
import { Decimal } from 'decimal.js';

@Injectable({
  providedIn: 'root',
})
export class MappingService {
  constructor() {}

  // a typescript implementation of the Dijkstra algorithm according to the pseudo code section via Wikipedia
  // https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode

  calculatePathWithDistance(paths, source, target) {
    const Q = new Set();
    const prev = {};
    const dist = {};
    const adj = {};

    const vertexWithMinDist = (q, d) => {
      let minDistance = Infinity;
      let u = null;

      for (const v of q) {
        if (dist[v] < minDistance) {
          minDistance = d[v];
          u = v;
        }
      }
      return u;
    };

    for (const path of paths) {
      const v1 = path[0];
      const v2 = path[1];
      let len = path[2];

      // calculate the impact of traffic on the travelling time. the usage
      // of decimal.js is required to ensure accurate decimal division.
      // i then convert the new length back to the number as the rest of
      // the algorith requires it.

      let lenDec = new Decimal(path[2]);
      const traffic = new Decimal(path[3]);

      if (traffic.greaterThan(0)) {
        lenDec = lenDec.dividedBy(traffic).toDecimalPlaces(2);
        len = lenDec.toNumber();
      }

      Q.add(v1);
      Q.add(v2);

      dist[v1] = Infinity;
      dist[v2] = Infinity;

      if (adj[v1] === undefined) {
        adj[v1] = {};
      }
      if (adj[v2] =


Jogue 2 moedas. Este ataque causa 120 pontos de dano para cada cara.",
				de: "Wirf 2 Münzen. Diese Attacke fügt 120 Schadenspunkte pro Kopf zu."
			},
			damage: "120×",

		},
	],

	weaknesses: [
		{
			type: "Grass",
			value: "×2"
		},
	],

	retreat: 3,
	regulationMark: "D",

	variants: {
		normal: true,
		reverse: true,
		holo: false,
		firstEdition: false
	},

	description: {
		en: "Mud that hardens around a Mudsdale's legs sets harder than stone. It's so hard that it allows this Pokémon to scrap a truck with a single kick."
	},

	dexId: [750]
}

export default card
import { expect } from 'chai';
import { Tree } from '../src/tree.class';
import { BasicComparable } from './model/basic-comparable.class';

describe('AVL Move tests', () => {
	let tree: Tree<BasicComparable, number>;
	beforeEach(() => {
		tree = new Tree<BasicComparable, number>();
		tree.set(new BasicComparable(1), 1);
		tree.set(new BasicComparable(2), 2);
		tree.set(new BasicComparable(3), 3);
		tree.set(new BasicComparable(4), 4);
	});

	it('should be able to keep its reference', () => {
		const originalNode = tree.getNode(new BasicComparable(3));
		const newKey = new BasicComparable(7);
		const result = tree.moveNode(originalNode.key, newKey);
		const resultNode = tree.getNode(newKey);
		expect(originalNode).to.equal(resultNode);
		expect(result).to.be.true;
	});

	it('should fail when moving to an existing key', () => {
		const originalNode = tree.getNode(new BasicComparable(3));
		const newKey = new BasicComparable(4);
		const result = tree.moveNode(originalNode.key, newKey);
		const resultNode = tree.getNode(newKey);
		expect(originalNode).to.not.equal(resultNode);
		expect(result).to.not.be.true;
	});
});
import { Injectable } from '@angular/core';
import { Subject, Subscriber, Subscription } from 'rxjs';

@Injectable({
  providedIn: 'root'
})
export class ExampleSubjectService {
  subject: Subject<String>;
  constructor() {
    this.subject = new Subject<String>();
  }

  subscribe(subscriberObj:Subscriber<String>): Subscription {
    return this.subject.subscribe(subscriberObj);
  }

  next(value:String) {
    this.subject.next(value);
  }
}
import { IAssemblyLexer } from "../../Assembler/IAssemblyLexer";
import { AssemblyTokenKind } from "../../Assembler/AssemblyTokenKind";
import { AssemblyToken } from "../../Assembler/AssemblyToken";
import { AssemblyLexer } from "../../Assembler/AssemblyLexer";
import SourceText from "../../Language/Compiler/Syntax/Text/SourceText";
import { Diagnostics } from "../../Language/Compiler/Diagnostics/Diagnostics";

describe("The AssemblyLexer class ", () => {

    function test(assembly : string, tokenTypes : AssemblyTokenKind[])
    {
        const source = new SourceText(assembly);
        const diagnostics = new Diagnostics(source);
        let lexer : IAssemblyLexer = new AssemblyLexer(source, diagnostics);

        var tokens : AssemblyToken[] = [];
        while(lexer.advance())
            tokens.push(lexer.current);

        expect(tokens.length).toEqual(tokenTypes.length);

        for(let i = 0; i < tokens.length; i++)
        {
            expect(tokens[i].token).toEqual(tokenTypes[i]);
        }
    }

    it("lexes an identifier"


    opt      = opts;
    mId      = -1;

    mindeg   = -1;
    maxdeg   = -1;
    ne = 0;
    nn = 0;
    for (j = 0; j < nClasses; j++) {
        clist[j] = clnum[j];
        nn += clnum[j];
        ne += cldeg[j]*clnum[j];
        if (mindeg < 0) {
            mindeg = cldeg[j];
        } else {
            mindeg = Min(mindeg, cldeg[j]);
        }
        if (maxdeg < 0) {
            maxdeg = cldeg[j];
        } else {
            maxdeg = Max(maxdeg, cldeg[j]);
        }
    }
    if (ne % 2 != 0) {
        if (prlevel > 0) {
            fprintf(GRCC_Stderr, "Sum of degrees are not even\n");
            for (j = 0; j < nClasses; j++) {
                fprintf(GRCC_Stderr, "class %2d: %2d %2d %2d\n",
                       j, cldeg[j], clnum[j], cltyp[j]);
            }
        }
        erEnd("illegal degrees of nodes");
    }
    pId    = pid;
    nNodes = nn;
    nodes  = new MNode*[nNodes];
    group  = new SGroup();
#ifdef ORBITS
    orbits = new MOrbits();
#endif

    nEdges = ne / 2;
    nLoops = nEdges - nNodes + 1;

    egraph = new EGraph(nNodes, nEdges, maxdeg);
    nn = 0;
    nExtern = 0;
#ifdef DEBUG3
    printf("MGraph::MGraph: nClasses=%d\n", nClasses);
#endif
    for (j = 0; j < nClasses; j++) {
#ifdef DEBUG3
        printf("cmind[%d]=%d, cmaxd[%d]=%d\n", j, cmind[j], j, cmaxd[j]);
#endif
        for (k = 0; k < clist[j]; k++, nn++) {
            nodes[nn] = new MNode(nn, cldeg[j], cltyp[j], j, cmind[j], cmaxd[j]);
            egraph->setExtLoop(nn, cltyp[j]);
            if (cltyp[j] < 0) {
                nExtern++;
            }
        }
    }
    egraph->endSetExtLoop();

    init();
}

//---------------------------------------------------------------
MGraph::MGraph(int pid, int ncl, NCInput *mgi, Options *opts)
{
    int nn, ne, j, k;

#ifdef DEBUGM
    printf("MGraph::MGraph(pid=%d, ncl=%d)\n", pid, ncl);
    for (j = 0; j < ncl; j++){
        printf("%d: deg=%d, num=%d, typ=%d, mind=%d, maxd=%d\n",
               j, mgi[j].cldeg, mgi[j].clnum, mgi[j].cltyp,
               mgi[j].cmind, mgi[j].cmaxd);
    }
    opts->print();
#endif

    // initial conditions
    nClasses = ncl;
    clist    = new int[ncl];
    opt      = opts;
    mId      = -1;

    mindeg   = -1;
    maxdeg   = -1;
    ne = 0;
    nn = 0;
    for (j = 0; j < nClasses; j++) {
        clist[j] = mgi[j].clnum;
        nn += mgi[j].clnum;
        ne += mgi[j].cldeg*mgi[j].clnum;
        if (mindeg < 0) {
            mindeg = mgi[j].cldeg;
        } else {
            mindeg = Min(mindeg, mgi[j].cldeg);
        }
        if (maxdeg < 0) {
            maxdeg = mgi[j].cldeg;
        } else {
            maxdeg = Max(maxdeg, mgi[j].cldeg);
        }
    }
    if (ne % 2 != 0) {
        if (prlevel > 0) {


 equal to RHS.
			// Set both to be the intersection of LHS and RHS.
			lhs, setLHS := s.valueOf(n.LHS)
			rhs, setRHS := s.valueOf(n.RHS)
			intersection := lhs.Intersect(rhs)
			if setLHS != nil {
				setLHS(intersection)
			}
			if setRHS != nil {
				setRHS(intersection)
			}

		case ast.OpNE:
			// LHS is not equal to RHS.
			// Remove RHS values from the LHS and vice-versa.
			lhs, setLHS := s.valueOf(n.LHS)
			rhs, setRHS := s.valueOf(n.RHS)
			if setLHS != nil {
				setLHS(lhs.Difference(rhs))
			}
			if setRHS != nil {
				setRHS(rhs.Difference(lhs))
			}

		case ast.OpLT:
			// LHS is less than RHS.
			// Set LHS to be less than RHS, and RHS to be greater than LHS.
			lhs, setLHS := s.valueOf(n.LHS)
			rhs, setRHS := s.valueOf(n.RHS)
			if lhs, ok := lhs.(SetRelational); ok && setLHS != nil {
				setLHS(lhs.SetLessThan(rhs))
			}
			if rhs, ok := rhs.(SetRelational); ok && setRHS != nil {
				setRHS(rhs.SetGreaterThan(lhs))
			}

		case ast.OpLE:
			// LHS is less than or equal to RHS.
			// Set LHS to be less than or equal to RHS, and RHS to be greater
			// than or equal to RHS.
			lhs, setLHS := s.valueOf(n.LHS)
			rhs, setRHS := s.valueOf(n.RHS)
			if lhs, ok := lhs.(SetRelational); ok && setLHS != nil {
				setLHS(lhs.SetLessEqual(rhs))
			}
			if rhs, ok := rhs.(SetRelational); ok && setRHS != nil {
				setRHS(rhs.SetGreaterEqual(lhs))
			}

		case ast.OpGT:
			// LHS is greater than RHS.
			// Set LHS to be greater than RHS, and RHS to be less than LHS.
			lhs, setLHS := s.valueOf(n.LHS)
			rhs, setRHS := s.valueOf(n.RHS)
			if lhs, ok := lhs.(SetRelational); ok && setLHS != nil {
				setLHS(lhs.SetGreaterThan(rhs))
			}
			if rhs, ok := rhs.(SetRelational); ok && setRHS != nil {
				setRHS(rhs.SetLessThan(lhs))
			}

		case ast.OpGE:
			// LHS is greater than or equal to RHS.
			// Set LHS to be greater than or equal to RHS, and RHS to be less
			// than or equal to RHS.
			lhs, setLHS := s.valueOf(n.LHS)
			rhs, setRHS := s.valueOf(n.RHS)
			if lhs, ok := lhs.(SetRelational); ok && setLHS != nil {
				setLHS(lhs.SetGreaterEqual(rhs))
			}
			if rhs, ok := rhs.(SetRelational); ok && setRHS != nil {
				setRHS(rhs.SetLessEqual(lhs))
			}
		}

	case *semantic.BitTest:
		lhs, _ := s.valueOf(n.Bits)
		rhs, setRHS := s.valueOf(n.Bitfield)
		if setRHS != nil {
			setRHS(rhs.Union(lhs)) // TODO: Not really true, need more complex bit logic.
		}

	case *semantic.MapContains:
		// TODO: Put an entry that says the map contained the key.

	case *semantic.UnaryOp:
		switch n.Operator {
		case ast.OpNot:


imeMsec);
	TArray<struct FSoundSubmixSpectralAnalysisBandSettings> MakeMusicalSpectralAnalysisBandSettings(int32 InNumSemitones, enum class EMusicalNoteName InStartingMusicalNote, int32 InStartingOctave, int32 InAttackTimeMsec, int32 InReleaseTimeMsec);
	TArray<struct FSoundSubmixSpectralAnalysisBandSettings> MakeFullSpectrumSpectralAnalysisBandSettings(int32 InNumBands, float InMinimumFrequency, float InMaximumFrequency, int32 InAttackTimeMsec, int32 InReleaseTimeMsec);
	bool IsAudioBusActive(class UObject* WorldContextObject, class UAudioBus* AudioBus);
	void GetPhaseForFrequencies(class UObject* WorldContextObject, TArray<float>& Frequencies, TArray<float>* Phases, class USoundSubmix* SubmixToAnalyze);
	int32 GetNumberOfEntriesInSourceEffectChain(class UObject* WorldContextObject, class USoundEffectSourcePresetChain* PresetChain);
	void GetMagnitudeForFrequencies(class UObject* WorldContextObject, TArray<float>& Frequencies, TArray<float>* Magnitudes, class USoundSubmix* SubmixToAnalyze);
	void GetCurrentAudioOutputDeviceName(class UObject* WorldContextObject, FDelegateProperty_& OnObtainCurrentDeviceEvent);
	void GetAvailableAudioOutputDevices(class UObject* WorldContextObject, FDelegateProperty_& OnObtainDevicesEvent);
	class FString Conv_AudioOutputDeviceInfoToString(struct FAudioOutputDeviceInfo& Info);
	void ClearSubmixEffects(class UObject* WorldContextObject, class USoundSubmix* SoundSubmix);
	void ClearSubmixEffectChainOverride(class UObject* WorldContextObject, class USoundSubmix* SoundSubmix, float FadeTimeSec);
	void ClearMasterSubmixEffects(class UObject* WorldContextObject);
	int32 AddSubmixEffect(class UObject* WorldContextObject, class USoundSubmix* SoundSubmix, class USoundEffectSubmixPreset* SubmixEffectPreset);
	void AddSourceEffectToPresetChain(class UObject* WorldContextObject, class USoundEffectSourcePresetChain* PresetChain, const struct FSourceEffectChainEntry& Entry);
	void AddMasterSubmixEffect(class UObject* WorldContextObject, class USoundEffectSubmixPreset* SubmixEffectPreset);
};

// 0x20 (0x4C0 - 0x4A0)
// Class AudioMixer.SynthSound
class USynthSound : public USoundWaveProcedural
{
public:
	TWeakObjectPtr<class USynthComponent>        OwningSynthComponent;                              // 0x4A0(0x8)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                        Pad_F16[0x18];                                     // Fixing Size Of Struct [ Dumper-7 ]

	static class UClass* StaticClass();
	static class USynthSound* GetDefaultObj();

};

// 0xE8 (0x150 - 0x68)
// Class AudioMixer.SubmixEffectDynamicsProcessorPreset
class USubmixEffectDynamicsProcessorPreset : public USoundEffectSubmixPreset
{
public:
	uint8                                        Pad_F31[0x88];                                     // Fixing Size After Last Property  [ Dumper-7 ]
	struct FSubmixEffectDynamicsProcessorSettings Settings;                                          // 0xF0(0x60)(Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)

	static class UClass* StaticClass();
	static class USubmixEffectDynamicsProcessorPreset* GetDefaultObj();

	void SetSettings(struct FSubmixEffectDynamicsProcessorSettings& Settings);
	void SetExternalSubmix(class USoundSubmix* Submix);
	void SetAudioBus(class UAudioBus* AudioBus);
	void ResetKey();
};

// 0x48 (0xB0 - 0x68)
// Class AudioMixer.SubmixEffectSubmixEQPreset
class USubmixEffectSubmixEQPreset : public USound


ishu lacag kuugu siiyaan. Aynu nidhaahno ciwaanka wuxuu ka bilaabmaa xarafka alfanumeric ee 7XybV3... Laakin iska tuurista khatarta gaarka ah ee cad ee qof kasta oo awood u leh inuu hubiyo dheelitirka Bitcoin oo arag inta aad iibisay, waxaa jira ilbiriqsi, oo aan inta badan laga hadlin khatarta gaarka ah. Aynu sheegno inaad sidoo kale ahayd hacker dhulka hoostiisa ah oo wata magaca l33tz0r. Waxaad qabtaa shaqo foori, adigoo u sheegaya dad aan shaki ku jirin musuqmaasuqa dowladda, waxaana lama huraan ah inaad qariso aqoonsigaaga. Waxaad aqbashaa deeqaha Bitcoin ee shaqadaada, oo waxaad ku dhejisaa ciwaanka madal dadweyne. Waa isla cinwaanka aad lacagta ka aqbasho macaamiishaada tufaaxa. 7XybV3... mid.
\n\n
Weerar aan magac-u-dhigin oo fudud, laakiin ba\'an ayaa noqon doona in la isticmaalo matoorka raadinta intarneetka si aad u raadiso ciwaanka Bitcoin. Ku dhejinta ciwaanka 7XybV3... matoorka waxay keenaysaa laba natiijo oo kala duwan. Ganacsiga tufaaxa, iyo l33tz0r. Tani waxay ku filan tahay in la isku xiro labada aqoonsi oo aan la aqoonsan l33tz0r, oo leh cawaaqib cabsi leh oo ka iman kara awoodaha jira.
\n\n
 Waxaa muhiim ah in la ogaado in weerarkan sidoo kale uu suurtagal yahay Monero. Inkasta oo Monero ay qariso inta badan xogta silsiladda ku jirta, weerarkani midna ma isticmaalo. Kaliya waxay isticmaashaa ciwaanka, kaas oo ay tahay in la wadaago si loo helo lacag bixinta. Si fagaare ah kiiska deeqaha aan la garanayn. Tani waa hal dariiqo oo ay isticmaalayaasha Monero si ula kac ah u dhaawici karaan sirtooda, iyo sidoo kale tusaale ahaan sida, in kasta oo Monero uu yahay heerka ugu sarreeya ee ku saabsan ilaalinta sirta, ma aha rasaas.
\n\n
 Habka caadiga ah ee dhibaatadan lagu xaliyo waxay ahayd lahaanshaha boorsooyin badan. Iyadoo cinwaano kala duwan lagu dhejiyay aqoonsi kasta (ama kiis adeegsi), lama xiriirin karo. Laakiin sirnimadani waxay haysaa kaliya haddii isticmaaluhu uusan waligiis isku darin. Si lama filaan ah u dhajinta ciwaanka khaldan waxay yeelan doontaa saameyn isku mid ah isku xirka. Sidoo kale, iniinaha ciwaan kasta waa in la ilaaliyaa, iyada oo la kordhinayo shaqada infosec ee lagama maarmaanka u ah shandad kasta oo cusub oo la sameeyo.
\n\n
Xalka Monero wuxuu ahaa dharka hoose. Awoodda lagu abuuro tiro aad u tiro badan oo cinwaano ah oo ku hoos jira ciwaanka ugu muhiimsan, iy


a Etemad; Lea Verou. CSS Images Module Level 4. URL: https://drafts.csswg.org/css-images-4/

[CSS-INLINE-3]

Elika Etemad. CSS Inline Layout Module Level 3. URL: https://drafts.csswg.org/css-inline-3/

[CSS-LINE-GRID-1]

Elika Etemad; Koji Ishii; Alan Stearns. CSS Line Grid Module Level 1. URL: https://drafts.csswg.org/css-line-grid/

[CSS-LISTS-3]

Elika Etemad; Tab Atkins Jr.. CSS Lists and Counters Module Level 3. URL: https://drafts.csswg.org/css-lists-3/

[CSS-LOGICAL-1]

Rossen Atanassov; Elika Etemad. CSS Logical Properties and Values Level 1. URL: https://drafts.csswg.org/css-logical-1/

[CSS-MASKING-1]

Dirk Schulze; Brian Birtles; Tab Atkins Jr.. CSS Masking Module Level 1. URL: https://drafts.fxtf.org/css-masking-1/

[CSS-MULTICOL-2]

CSS Multi-column Layout Module Level 2. Editor's Draft. URL: https://drafts.csswg.org/css-multicol-2/

[CSS-OVERFLOW-3]

Elika Etemad; Florian Rivoal. CSS Overflow Module Level 3. URL: https://drafts.csswg.org/css-overflow-3/

[CSS-OVERFLOW-4]

David Baron; Florian Rivoal; Elika Etemad. CSS Overflow Module Level 4. URL: <a href


AL_DISTANCE_MODEL = 0xD000,
  AL_INVERSE_DISTANCE = 0xD001,
  AL_INVERSE_DISTANCE_CLAMPED = 0xD002,
  AL_LINEAR_DISTANCE = 0xD003,
  AL_LINEAR_DISTANCE_CLAMPED = 0xD004,
  AL_EXPONENT_DISTANCE = 0xD005,
  AL_EXPONENT_DISTANCE_CLAMPED = 0xD006,
};
void alEnable( ALenum capability );
void alDisable( ALenum capability );
ALboolean alIsEnabled( ALenum capability );
const ALchar* alGetString( ALenum param );
void alGetBooleanv( ALenum param, ALboolean* data );
void alGetIntegerv( ALenum param, ALint* data );
void alGetFloatv( ALenum param, ALfloat* data );
void alGetDoublev( ALenum param, ALdouble* data );
ALboolean alGetBoolean( ALenum param );
ALint alGetInteger( ALenum param );
ALfloat alGetFloat( ALenum param );
ALdouble alGetDouble( ALenum param );
ALenum alGetError( void );
ALboolean alIsExtensionPresent( const ALchar* extname );
void* alGetProcAddress( const ALchar* fname );
ALenum alGetEnumValue( const ALchar* ename );
void alListenerf( ALenum param, ALfloat value );
void alListener3f( ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 );
void alListenerfv( ALenum param, const ALfloat* values );
void alListeneri( ALenum param, ALint value );
void alListener3i( ALenum param, ALint value1, ALint value2, ALint value3 );
void alListeneriv( ALenum param, const ALint* values );
void alGetListenerf( ALenum param, ALfloat* value );
void alGetListener3f( ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3 );
void alGetListenerfv( ALenum param, ALfloat* values );
void alGetListeneri( ALenum param, ALint* value );
void alGetListener3i( ALenum param, ALint *value1, ALint *value2, ALint *value3 );
void alGetListeneriv( ALenum param, ALint* values );
void alGenSources( ALsizei n, ALuint* sources );
void alDeleteSources( ALsizei n, const ALuint* sources );
ALboolean alIsSource( ALuint sid );
void alSourcef( ALuint sid, ALenum param, ALfloat value );
void alSource3f( ALuint sid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 );
void alSourcefv( ALuint sid, ALenum param, const ALfloat* values );
void alSourcei( ALuint sid, ALenum param, ALint value );
void alSource3i( ALuint sid, ALenum param, ALint value1, ALint value2, ALint value3 );
void alSourceiv( ALuint sid, ALenum param, const ALint* values );
void alGetSourcef( ALuint sid, ALenum param, ALfloat* value );
void alGetSource3f( ALuint sid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3);
void alGetSourcefv( ALuint sid, ALenum param, ALfloat* values );
void alGetSourcei( ALuint sid,  ALenum param, ALint* value );
void alGetSource3i( ALuint sid, ALenum param, ALint* value1, ALint* value2, ALint* value3);
void alGetSourceiv( ALuint sid,  ALenum param, ALint* values );
void alSourcePlayv( ALsizei ns, const ALuint *sids );


878,487.9411634 42.3811182,488.2467120 41.8584728,488.9131622 41.2507743,489.4844052 41.1805130,489.5264735 41.0794353,489.5884689 41.0375251,489.4379087 41.0054761,489.3759133 40.9574026,489.3227744 40.8797453,489.2430661 40.8144147,489.1655719 40.7749697,489.0947201 40.7589452,489.0039411 40.7466187,488.8998775 40.7688065,488.8356680 40.7934595,488.7803150 40.7108717,488.4127710 40.6319818,487.9411634 40.6270512,487.9013093 40.5777450,487.5647630 40.5654185,487.1042260 40.5777450,486.1366555 40.5851410,485.8908882 40.5407654,485.5654125 40.4840633,485.2620780 40.3262836,484.8303246 40.2646509,484.7063339 40.4433857,484.6996915 40.4507817,484.5225619 40.4088714,484.3387899 40.3940796,484.2767945 40.2868386,483.9911730 40.2387651,483.7299069 40.2375325,483.3955747 40.2720468,482.8774706 40.2893040,482.7003410 40.3558673,482.4324324 40.4051734,482.2043781 40.4187326,481.9342554 40.4322918,481.6552762 40.4359898,481.5091443 40.4384551,481.3630124 40.4285939,481.0707485 40.4285939,480.5083620 40.4396878,479.6869234 40.4088714,479.3415207 40.3805204,479.0957533 40.2252059,479.1998170 40.1376875,479.2042452 40.0698915,478.8787695 40.1549446,478.6927834"/>
<polygon id="uswijs274" fill="#EBECED" stroke="#FFFFFF" vector-effect="non-scaling-stroke" fill-rule="evenodd" data-district-id="2916" data-district_name="PHILADELPHIA WD 29 PCT 16" points="112.9172920,347.1408328 113.9095786,347.3578166 114.9573348,347.5858710 115.3209678,347.6722217 115.5255884,347.7209323 115.7992376,347.7873559 116.8174100,348.0331232 118.1425133,348.3342436 118.8623834,348.5180156 119.5489718,348.6929311 120.1357152,348.8346347 120.8629812,348.9874090 120.4796258,352.1248173 119.7548251,351.9631866 119.1791755,351.8458382 118.4938198,351.6753509 118.1141623,351.5978567 117.7998354,351.5314331 116.5326669,351.2280987 114.5739793,350.7432063 114.4630404,350.7254934 113.5903212,350.5018672 113.2106637,350.4066601 113.0097411,350.3557353 112.5253079,350.2317446 112.9172920,347.1408328"/>
<polygon id="uswijs275" fill="#EBECED" stroke="#FFFFFF" vector-effect="non-scaling-stroke" fill-rule="evenodd" data-district-id="2917" data-district_name="PHILADELPHIA WD 29 PCT 17" points="118.1141623,351.597


ervalDivideTests {

    @ParameterizedTest
    @MethodSource("intervalDivideNumberCases")
    @Execution(ExecutionMode.CONCURRENT)
    fun intervalDivideNumber(tc: SuccessTestCase) = tc.run()

    @ParameterizedTest
    @MethodSource("intervalDivideNegativeCases")
    @Execution(ExecutionMode.CONCURRENT)
    fun intervalDivideNegative(tc: SuccessTestCase) = tc.run()

    @ParameterizedTest
    @MethodSource("intervalDivideZeroCases")
    @Execution(ExecutionMode.CONCURRENT)
    fun intervalDivideZero(tc: FailureTestCase) = tc.run()

    @ParameterizedTest
    @MethodSource("intervalDivideNullCases")
    @Execution(ExecutionMode.CONCURRENT)
    fun intervalDivideNull(tc: SuccessTestCase) = tc.run()

    @ParameterizedTest
    @MethodSource("intervalDivideMissingCases")
    @Execution(ExecutionMode.CONCURRENT)
    fun intervalDivideMissing(tc: SuccessTestCase) = tc.run()

    @ParameterizedTest
    @MethodSource("intervalDivideDecimalCases")
    @Execution(ExecutionMode.CONCURRENT)
    fun intervalDivideDecimal(tc: SuccessTestCase) = tc.run()

    @ParameterizedTest
    @MethodSource("intervalDivideDoubleCases")
    @Execution(ExecutionMode.CONCURRENT)
    fun intervalDivideDouble(tc: SuccessTestCase) = tc.run()

    @ParameterizedTest
    @MethodSource("intervalDivideWithPrecisionOverflowCases")
    @Execution(ExecutionMode.CONCURRENT)
    fun intervalDivideWithPrecisionOverflowCases(tc: FailureTestCase) = tc.run()

    companion object {
        private const val INTERVAL_Y = "INTERVAL '3' YEAR"
        private const val INTERVAL_M = "INTERVAL '7' MONTH"
        private const val INTERVAL_YM = "INTERVAL '1-5' YEAR TO MONTH"

        private const val INTERVAL_D = "INTERVAL '2' DAY"
        private const val INTERVAL_H = "INTERVAL '4' HOUR"
        private const val INTERVAL_MIN = "INTERVAL '5' MINUTE"
        private const val INTERVAL_S = "INTERVAL '10.5' SECOND"
        private const val INTERVAL_DTS = "INTERVAL '2 4:5:10.5' DAY TO SECOND"
        private const val NANOS_PER_SECOND = 1000000000

        private class Input(
            val arg0: String,
            val arg1: String,
            val expected: Datum
        )

        @JvmStatic
        fun intervalDivideNumberCases() = listOf(
            Input(INTERVAL_Y, "3", Datum.intervalYearMonth(1, 0, 2)),
            Input(INTERVAL_M, "3", Datum.intervalYearMonth(0, 2, 2)),
            Input(INTERVAL_YM, "3", Datum.intervalYearMonth(0, 5, 2)),

            Input(INTERVAL_D, "3", Datum.intervalDaySecond(0, 16, 0, 0, 0, 2, 6)),
            Input(INTERVAL_H, "3", Datum.intervalDaySecond(0, 1, 20, 0, 0, 2, 6)),
            Input(INTERVAL_MIN, "3", Datum.intervalDaySecond(0, 0, 1, 40, 0, 2, 6)),
            Input(INTERVAL_S, "3", Datum.intervalDaySecond(0, 0, 0, 3, (0.5 * NANOS_PER_SECOND).toInt(), 2, 6)),
            Input(INTERVAL_DTS, "3", Datum.intervalDaySecond(0, 17, 21, 43, (0.5 * NANOS_PER_SECOND).toInt(), 2, 6))
        ).map { case ->
            SuccessTestCase("${case.arg0} / ${case.arg1}", case.expected)
        }

        @JvmStatic
        fun intervalDivideNegativeCases() = listOf(
            Input(INTERVAL_Y, "-3", Datum.intervalYearMonth(-1, 0, 2)),
            Input(INTERVAL_M, "-3", Datum.intervalYearMonth(0, -2, 2)),
            Input(INTERVAL_YM, "-3", Datum.intervalYearMonth(0, -5, 2)),

            Input(INTERVAL_D, "-3", Datum.intervalDaySecond(0, -16, 0, 0, 0, 2, 6)),