he) {
        return text;
    }
    try {
        text = FS.readFileSync(path, charset);
        text = text.replace(/^\uFEFF/, '');
    }
    catch (err0) {
        return "";
    }
    if (text) {
        var ext = getExtension(path).toLowerCase();
        if (ext == "ts" || ext == "exml") {
            textTemp[path] = text;
        }
    }
    return text;
}

/**
 * 读取字节流文件,返回字节流，若失败，返回null.
 * @param path 要打开的文件路径
 */
export function readBinary(path: string): any {
    path = escapePath(path);
    try {
        var binary = FS.readFileSync(path);
    }
    catch (e) {
        return null;
    }
    return binary;
}

export function copy(source: string, dest: string): void {
    source = escapePath(source);
    dest = escapePath(dest);
    var stat = FS.lstatSync(source);
    if (stat.isDirectory()) {
        _copy_dir(source, dest);
    }
    else {
        _copy_file(source, dest);
    }
}

export function isDirectory(path: string): boolean {
    path = escapePath(path);
    try {
        var stat = FS.statSync(path);
    }
    catch (e) {
        return false;
    }
    return stat.isDirectory();
}

/**
 * 删除文件或目录
 * @param path 要删除的文件源路径
 */
export function remove(path: string): void {
    path = escapePath(path);
    try {
        FS.lstatSync(path).isDirectory()
            ? rmdir(path)
            : FS.unlinkSync(path);

        getDirectoryListing(path);
    }
    catch (e) {
    }
}

export function move(oldPath: string, newPath: string) {
    copy(oldPath, newPath);
    remove(oldPath);
}

/**
 * 指定路径的文件或文件夹是否存在
 */
export function exists(path: string): boolean {
    path = escapePath(path);
    return FS.existsSync(path);
}

/**
 * 转换本机路径为Unix风格路径。
 */
export function escapePath(path: string): string {
    if (!path)
        return "";
    return path.split("\\").join("/");
}

export function existsSync(path: string): boolean {
    return FS.existsSync(path);
}

/**
 * 获取路径的文件名(不含扩展名)或文件夹名
 */
export function getFileName(path: string): string {
    if (!path)
        return "";
    path = escapePath(path);
    var startIndex = path.lastIndexOf("/");
    var endIndex;
    if (startIndex > 0 && startIndex == path.length - 1) {
        path = path.substring(0, path.length - 1);
        startIndex = path.lastIndexOf("/");
        endIndex = path.length;
        return path.substring(startIndex + 1, endIndex);
    }
    endIndex = path.lastIndexOf(".");
    if (endIndex == -1 || isDirectory(path))
        endIndex = path.length;
    return path.substring(startIndex + 1, endIndex);
}

/**
 * 获取指定文件夹下的文件或文件夹列表，不包含子文件夹内的文件。
 * @param path 要搜索的文件夹
 * @param relative 是否返回相对路径，若不传入或传入false，都返回绝对路径。
 */
export function getDirectoryListing(path: string, relative: boolean = false): string[] {
    path = escapePath(path);
    try {
        var list = readdirSync(path);
    }
    catch (e) {
        return [];


()
                                }
                            }
                        }

                        XmlPullParser.END_TAG -> {
                            when (parser.name) {
                                TAG_PLUGIN -> {
                                    currentPlugin?.let { plugin ->
                                        pluginList.add(
                                            plugin.copy(
                                                staticReceivers = currentReceivers ?: emptyList(),
                                                providers = currentProviders ?: emptyList(),
                                            ),
                                        )
                                    }
                                    currentPlugin = null
                                    currentReceivers = null
                                    currentProviders = null
                                }

                                TAG_RECEIVER -> {
                                    if (currentReceiverName != null && currentFilters != null) {
                                        currentReceivers?.add(
                                            StaticReceiverInfo(
                                                currentReceiverName,
                                                currentReceiverEnabled,
                                                currentReceiverExported,
                                                currentFilters,
                                            ),
                                        )
                                    }
                                }

                                TAG_INTENT_FILTER -> {
                                    currentFilters?.add(
                                        IntentFilterInfo(
                                            actions = currentActions ?: emptyList(),
                                            categories = currentCategories ?: emptyList(),
                                            schemes = currentSchemes ?: emptyList(),
                                        ),
                                    )
                                }

                                TAG_PROVIDER -> {
                                    if (currentProviderName != null && currentAuthorities != null) {
                                        currentProviders?.add(
                                            ProviderInfo(
                                                currentProviderName,
                                                currentAuthorities,
                                                currentProviderEnabled,
                                                currentProviderExported,
                                                currentMetaData ?: emptyList(),
                                            ),
                                        )
                                    }
                                    inProviderTag = false
                                }
                            }
                        }
                    }
                    eventType = parser.next()
                }
            }
        } catch (e: Exception) {
            throw IOException("读取或解析 ${targetFile.name} 时发生错误", e)
        }
        return pluginList
    }

    /**
     * 尝试从备份文件恢复数据
     */
    private fun tryRestoreFromBackup() {
        Timber
            .tag(TAG)
            .w("正在尝试从备份文件恢复: ${backupConfigFile.absolutePath}")
        try {
            if (backupConfigFile.exists()) {
                val plugins = loadPluginsFromDisk(useBackup = true)
                pluginCache.clear()
                plugins.forEach { plugin ->
                    pluginCache[plugin.id] = plugin
                }
                cacheInitialized = true
                hasUnsavedChanges.set(true) // 标记需要重新保存主文件
                scheduleDelayedWrite()
                Timber
                    .tag(TAG)
                    .i("成功从备份文件恢复。已加载 ${pluginCache.size} 个插件。主文件将被重写。")
            } else {
                Timber.tag(TAG).w("备份文件不存在。无法恢复。")
                // 备份文件也不存在，初始化为空缓存
                pluginCache.clear()
                cacheInitialized = true
                hasUnsavedChanges.set(false)
            }
        } catch (e: Exception) {
            Timber
                .tag(TAG)
                .e(e, "从备份文件恢复失败: ${e.message}。正在初始化空缓存。")
            // 备份文件也损坏，初始化为空缓存
            pluginCache.clear()


tml
 *
 * Copyright (C) 2007 by Steven Levithan <stevenlevithan.com>
 *
 * Distributed under the terms of the MIT license.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:

 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.

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

print(BUGNUMBER + ": " + summary);

/**************
 * BEGIN TEST *
 **************/

var ecmaSampleRe = /<(\/)?([^<>]+)>/;

var testCode = [
    ["''.split()",                   [""]],
    ["''.split(/./)",                [""]],
    ["''.split(/.?/)",               []],
    ["''.split(/.??/)",              []],
    ["'ab'.split(/a*/)",             ["", "b"]],
    ["'ab'.split(/a*?/)",            ["a", "b"]],
    ["'ab'.split(/(?:ab)/)",         ["", ""]],
    ["'ab'.split(/(?:ab)*/)",        ["", ""]],
    ["'ab'.split(/(?:ab)*?/)",       ["a", "b"]],
    ["'test'.split('')",             ["t", "e", "s", "t"]],
    ["'test'.split()",               ["test"]],
    ["'111'.split(1)",               ["", "", "", ""]],
    ["'test'.split(/(?:)/, 2)",      ["t", "e"]],
    ["'test'.split(/(?:)/, -1)",     ["t", "e", "s", "t"]],
    ["'test'.split(/(?:)/, undefined)", ["t", "e", "s", "t"]],
    ["'test'.split(/(?:)/, null)",   []],
    ["'test'.split(/(?:)/, NaN)",    []],
    ["'test'.split(/(?:)/, true)",   ["t"]],
    ["'test'.split(/(?:)/, '2')",    ["t", "e"]],
    ["'test'.split(/(?:)/, 'two')",  []],
    ["'a'.split(/-/)",               ["a"]],
    ["'a'.split(/-?/)",              ["a"]],
    ["'a'.split(/-??/)",             ["a"]],
    ["'a'.split(/a/)",               ["", ""]],
    ["'a'.split(/a?/)",              ["", ""]],
    ["'a'.split(/a??/)",             ["a"]],
    ["'ab'.split(/-/)",              ["ab"]],
    ["'ab'.split(/-?/)",             ["a", "b"]],
    ["'ab'.split(/-??/)",            ["a", "b"]],
    ["'a-b'.split(/-/)",             ["a", "b"]],
    ["'a-b'.split(/-?/)",            ["a


in pending for a reason...)

Some commands grew new option flags, such as cp --remove-destination
and touch -h.

The parallel build has better error reporting now. When toybox needs to
re-exec itself to regain suid root permissions and hasn't got the suid bit,
it now gives the right error message ("not root" instead of "no such command").

Added a test to "mount" to not mount the same device/directory combination
over itself (the OS catches this for block devices, but not for tmpfs).
Make blkid distinguish ext3 from ext4. Added catv back into cat (because
the Android guys wanted it, and they have historical usage on their side,
so...). Handle nanoseconds in touch.

Fixed a segfault when CP_MORE was disabled (the resulting option flag list
no longer defined -d but still had it in option groups at the end).
Workaround for glibc redefining dirname() and basename() to random non-posix
semantics because gnu. (They could have created dirname_r() but didn't want
to.)

Fix an ifconfig test that was preventing assigning an ipv4 address to
interface aliases. Several cleanup passes on hwclock but not quite
promoted out of pending yet.

Fixed a wrong error message in rm (if you had a chmod 000 directory and
did rm -r on it without -f, after the prompt it would complain it was a
directory, which was not the problem).

The gzip compression code now does "store only" output to stdout, for
what that's worth.

Cleanup mountpoint and expand, and remove them from toys/pending/README
(a list of commands that predate the toys/pending directory but needed
another pass).

Library and infrastructure:

Reworked the option parsing infrastructure so more commands build
standalone (via scripts/single.sh or "make change"). The option flag bit
values are no longer packed, it leaves spaces where currently disabled
flags go, and you can #define FORCE_FLAGS so disabled flags aren't zeroed.
This allows multiple commands to more easily share infrastructure, even if
your current flag context is for a disabled command (switched off in config),
you can force them to stay on and as long as the flags read the same right
to left they'll have the same values.

We've started removing use of strncpy() because it's a hugely broken
standard C function: the length is the maximum length to _append_, not
the size of the destination buffer. It memsets the remaining space it didn't
copy ala "memset(dest+strlen(dest), 0, len);" so
if you think len is the size of dest you're guaranteed to stomp memory off the
end). And if it runs out of space it won't null terminate because reasons.
(Meanwhile sprintf("%*s", len, str) is counting wide characters in your current
locale, so if you set a locale other than "C" it will also go past your
allocated buffer size. Whoever is maintining the C library standards is really
bad at strings.)
Instead we have xstrncat() which will error_exit() if src+dest+1 doesn't
fit in the buffer. (Because randomly truncating input data isn't necessarily
an improvement.) And there's always xmprintf().

Similarly, strtol() doesn't return an error indicator on overflow,
you have to clear and then check errno. So new xstrtol() that cares
about overflow.

The bionic and musl guys agree faccessat(AT_SYMLINK_NOFOLLOW) is not
supported, so stop using it.

Fixed toy_exec() to detect when argc is in optargs, so we don't
need a separate xexec_optargs().

<


ated::unffor::helper::scalar::unffor(packed16, const_cast<uint16_t*>(unpacked16), 16, base16);
	for (int k = 0; k < 1024; ++k)
	{
		ASSERT_EQ(helper::rand_arr_25_b16_w16_arr[k], unpacked16[k]);
	}
}
TEST_F(helper_scalar_av_1024_uf1_unffor, test_26_bw_0_ow_32)
{
	*(base32) = 10;
	generated::ffor::helper::scalar::ffor(const_cast<uint32_t*>(helper::rand_arr_26_b0_w32_arr), const_cast<uint32_t*>(packed32), 0, base32);
	generated::unffor::helper::scalar::unffor(packed32, const_cast<uint32_t*>(unpacked32), 0, base32);
	for (int k = 0; k < 1024; ++k)
	{
		ASSERT_EQ(helper::rand_arr_26_b0_w32_arr[k], unpacked32[k]);
	}
}
TEST_F(helper_scalar_av_1024_uf1_unffor, test_27_bw_1_ow_32)
{
	*(base32) = 10;
	generated::ffor::helper::scalar::ffor(const_cast<uint32_t*>(helper::rand_arr_27_b1_w32_arr), const_cast<uint32_t*>(packed32), 1, base32);
	generated::unffor::helper::scalar::unffor(packed32, const_cast<uint32_t*>(unpacked32), 1, base32);
	for (int k = 0; k < 1024; ++k)
	{
		ASSERT_EQ(helper::rand_arr_27_b1_w32_arr[k], unpacked32[k]);
	}
}
TEST_F(helper_scalar_av_1024_uf1_unffor, test_28_bw_2_ow_32)
{
	*(base32) = 10;
	generated::ffor::helper::scalar::ffor(const_cast<uint32_t*>(helper::rand_arr_28_b2_w32_arr), const_cast<uint32_t*>(packed32), 2, base32);
	generated::unffor::helper::scalar::unffor(packed32, const_cast<uint32_t*>(unpacked32), 2, base32);
	for (int k = 0; k < 1024; ++k)
	{
		ASSERT_EQ(helper::rand_arr_28_b2_w32_arr[k], unpacked32[k]);
	}
}
TEST_F(helper_scalar_av_1024_uf1_unffor, test_29_bw_3_ow_32)
{
	*(base32) = 10;
	generated::ffor::helper::scalar::ffor(const_cast<uint32_t*>(helper::rand_arr_29_b3_w32_arr), const_cast<uint32_t*>(packed32), 3, base32);
	generated::unffor::helper::scalar::unffor(packed32, const_cast<uint32_t*>(unpacked32), 3, base32);
	for (int k = 0; k < 1024; ++k)
	{
		ASSERT_EQ(helper::rand_arr_29_b3_w32_arr[k], unpacked32[k]);
	}
}
TEST_F(helper_scalar_av_1024_uf1_unffor, test_30_bw_4_ow_32)
{
	*(base32) = 10;
	generated::ffor::helper::scalar::ffor(const_cast<uint32_t*>(helper::rand_arr_30_b4_w32_arr), const_cast<uint32_t*>(packed32), 4, base32);
	generated::unffor::helper::scalar::unffor(packed32, const_cast<uint32_t*>(unpacked32), 4, base32);
	for (int k = 0; k < 1024; ++k)
	{


EncodeRLP implements rlp.Encoder.
func (l *LogForStorage) EncodeRLP(w io.Writer) error {
	return rlp.Encode(w, rlpStorageLog{
		Address:     l.Address,
		Topics:      l.Topics,
		Data:        l.Data,
		BlockNumber: l.BlockNumber,
		TxHash:      l.TxHash,
		TxIndex:     l.TxIndex,
		BlockHash:   l.BlockHash,
		Index:       l.Index,
	})
}

// DecodeRLP implements rlp.Decoder.
func (l *LogForStorage) DecodeRLP(s *rlp.Stream) error {
	var dec rlpStorageLog
	err := s.Decode(&dec)
	if err == nil {
		*l = LogForStorage{
			Address:     dec.Address,
			Topics:      dec.Topics,
			Data:        dec.Data,
			BlockNumber: dec.BlockNumber,
			TxHash:      dec.TxHash,
			TxIndex:     dec.TxIndex,
			BlockHash:   dec.BlockHash,
			Index:       dec.Index,
		}
	}
	return err
}
// Copyright 2014 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

package types

import (
	"bytes"
	"crypto/ecdsa"
	"encoding/json"
	"math/big"
	"testing"

	"github.com/dappledger/AnnChain/eth/common"
	"github.com/dappledger/AnnChain/eth/crypto"
	"github.com/dappledger/AnnChain/eth/rlp"
)

// The values in those tests are from the Transaction Tests
// at github.com/ethereum/tests.
var (
	emptyTx = NewTransaction(
		0,
		common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87"),
		big.NewInt(0), 0, big.NewInt(0),
		nil,
	)

	rightvrsTx, _ = NewTransaction(
		3,
		common.HexToAddress("b94f5374fce5edbc8e2a8697c15331677e6ebf0b"),
		big.NewInt(10),
		2000,
		big.NewInt(1),
		common.FromHex("5544"),
	).WithSignature(
		HomesteadSigner{},
		common.Hex2Bytes("98ff921201554726367d2be8c804a7ff89ccf285ebc57dff8ae4c44b9c19ac4a8887321be575c8095f789dd4c743dfe42c1820f9231f98a962b210e3ac2452a301"),
	)
)

func TestTransactionSigHash(t *testing.T) {
	var homestead HomesteadSigner
	if homestead.Hash(emptyTx) != common.HexToHash("c775b99e7ad12f50d819fcd602390467e28141316969f4b57f0626f74fe3b386") {
		t.Errorf("empty transaction hash mismatch, got %x", emptyTx.Hash())
	}
	if homestead.Hash(rightvrsTx) != common.HexToHash("fe7a79529ed5f7c3375d06b26b186a8644e0e16c373d7a12be41c62d6042b77a") {
		t.Errorf("RightVRS transaction hash mismatch, got %x", rightvrsTx.Hash())
	}
}

func TestTransactionEncode(t *testing.T) {
	txb, err := rlp.EncodeToBytes(rightvrsTx)


(`>>>> Time: ${this.time}`);
    }
  }
}
import { Observable } from "rxjs/Observable";
import { Injectable } from "@angular/core";
import { Http, Response } from "@angular/http";

export interface Item
{
	icon: string;
	name: string;
	link: string[];
}

const getUrl = "/api/NineBox";

@Injectable()
export class NineBoxService
{
	_items: Item[];
	_itemsObservable: Observable<Item[]>;

	private static createItems(length: number): Item[]
	{
		const items: Item[] = [
			{
				icon: "dashboard",
				name: "Dashboard",
				link: ["/dashboard"]
			},
			{
				icon: "people",
				name: `Characters`,
				link: ["/characters"]
			},
			{
				icon: "book",
				name: `Spellbook`,
				link: ["/spellbook"]
			}
		];
		return items;
	}

	constructor(private $http: Http)
	{
		const self = this;
		this._items = NineBoxService.createItems(10);
		this._itemsObservable = Observable.create(observable => {
			observable.next(self._items);
		});
	}

	getItems(): Observable<Item[]>
	{
		return this._itemsObservable;
		// return this.$http.get(getUrl).map(x => JSON.parse(x.json()));
	}
}
declare const CHATT_SERVER_URL: string;

import { Subject } from 'rxjs';

type SendMessageType = {
  to: string;
  message: string;
};

const newChattConnection = (clientId: string) => {
  const socketInput$ = new Subject();

  const webSocketConnection = new WebSocket(`${CHATT_SERVER_URL}/${clientId}`);
  console.log('Attempting Connection...');

  webSocketConnection.onopen = () => {
    console.log('Successfully Connected');
    // webSocketConnection.send('Hi From the Client!');
  };

  webSocketConnection.onclose = event => {
    console.log('Socket Closed Connection: ', event);
    webSocketConnection.send('Client Closed!');
  };

  webSocketConnection.onerror = event => {
    console.log(`Error establishing connection = ${JSON.stringify(event)}`);
  };

  webSocketConnection.onmessage = event => {
    socketInput$.next({ type: 'INCOMING_MESSAGE', data: event.data });
  };

  return {
    sendMessage: (message: SendMessageType) => {
      webSocketConnection.send(JSON.stringify({ details: { ...message }, command: 'SendMessage' }));
    },
    incomingStream: socketInput$.asObservable()
  };
};

export default newChattConnection;
import { workspace, Uri, window } from "vscode";

class WorkspaceUtil {
  static verifyWorkspace(path: Uri) {
    return workspace.getWorkspaceFolder(path);
  }

  public static async workspaceHasHTMLFiles(): Promise<Boolean> {
    let _hasHTMLFiles: Boolean = false;

    try {
      const files = await workspace.findFiles("**/*.html");
      _hasHTMLFiles = files && files.length > 0;
    } catch (err) {
      console.log(err);
    }

    return _hasHTMLFiles;
  }

  public static isWorkspaceValid(): Boolean {
    if (!workspace.workspaceFolders) {
      window.showInformationMessage("Open a folder or workspace. File -> Open Folder");
      return false;
    }

    if (!workspace.workspaceFolders.length) {
      window.showInformationMessage("You've not added any folder in the workspace");
      return false;
    }

    return true;
  }
}

export default WorkspaceUtil;
export interface MovieType {
  Title: string;
  Year: string;
  imdbID: string;
  Type: string;
  Poster: string;
}

interface APIResponse {
  Search: MovieType[];
}

interface ErrorResponse {
  Response: string;
  Error: string;
}

type ContextType = {
  movies: MovieType[];
  error: string | null;
  loader: boolean;
  keyword: string | null;
  fetchMovies: (keyword: string | null) => Promise<void>;
  addKeyWord: (keyword: string | null) => void;
};
/**
 * @license
 * Copyright 2020 JBoss Inc
 *
 * Licensed under the Apache License, Version 2.0 (the "License");


ing:nth-last-child(n+3)>.form-select,body.theme-dark .input-group.has-validation>:nth-last-child(n+3):not(.dropdown-toggle):not(.dropdown-menu):not(.form-floating),body.theme-dark .input-group:not(.has-validation)>.dropdown-toggle:nth-last-child(n+3),body.theme-dark .input-group:not(.has-validation)>.form-floating:not(:last-child)>.form-control,body.theme-dark .input-group:not(.has-validation)>.form-floating:not(:last-child)>.form-select,body.theme-dark .input-group:not(.has-validation)>:not(:last-child):not(.dropdown-toggle):not(.dropdown-menu):not(.form-floating){border-bottom-right-radius:0;border-top-right-radius:0}body.theme-dark .input-group>.form-floating:not(:first-child)>.form-control,body.theme-dark .input-group>.form-floating:not(:first-child)>.form-select,body.theme-dark .input-group>:not(:first-child):not(.dropdown-menu):not(.form-floating):not(.valid-tooltip):not(.valid-feedback):not(.invalid-tooltip):not(.invalid-feedback){border-bottom-left-radius:0;border-top-left-radius:0;margin-left:-1px}body.theme-dark .valid-feedback{color:#198754;display:none;font-size:.875em;margin-top:.25rem;width:100%}body.theme-dark .valid-tooltip{background-color:rgba(25,135,84,.9);border-radius:.25rem;color:#fff;display:none;font-size:.875rem;margin-top:.1rem;max-width:100%;padding:.25rem .5rem;position:absolute;top:100%;z-index:5}.was-validated body.theme-dark:valid~.valid-feedback,.was-validated body.theme-dark:valid~.valid-tooltip,body.theme-dark.is-valid~.valid-feedback,body.theme-dark.is-valid~.valid-tooltip{display:block}.was-validated body.theme-dark .form-control:valid,body.theme-dark .form-control.is-valid{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3E%3Cpath fill='%23198754' d='M2.3 6.73.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3E%3C/svg%3E");background-position:right calc(.375em + .1875rem) center;background-repeat:no-repeat;background-size:calc(.75em + .375rem) calc(.75em + .375rem);border-color:#198754;padding-right:calc(1.5em + .75rem)}.was-validated body.theme-dark .form-control:valid:focus,body.theme-dark .form-control.is-valid:focus{border-color:#198754;box-shadow:0 0 0 .25rem rgba(25,135,84,.25)}.was-validated body.theme-dark textarea.form-control:valid,body.theme-dark textarea.form-control.is-valid{background-position:top calc(.375em + .1875rem) right calc(.375em + .1875rem);padding-right:calc(1.5em + .75rem)}.was-validated body.theme-dark .form-select:valid,body.theme-dark .form-select.is-valid{border-color:#198754}.was-validated body.theme-dark .form-select:valid:not([multiple]):not([size]),.was-validated body.theme-dark .form-select:valid:not([multiple])[size="1"],body.theme-dark .form-select.is


		},
						{
							ID:   "Coivaras",
							Name: "Coivaras",
						},
						{
							ID:   "Colônia do Gurguéia",
							Name: "Colônia do Gurguéia",
						},
						{
							ID:   "Colônia do Piauí",
							Name: "Colônia do Piauí",
						},
						{
							ID:   "Conceição do Canindé",
							Name: "Conceição do Canindé",
						},
						{
							ID:   "Coronel José Dias",
							Name: "Coronel José Dias",
						},
						{
							ID:   "Corrente",
							Name: "Corrente",
						},
						{
							ID:   "Cristalândia do Piauí",
							Name: "Cristalândia do Piauí",
						},
						{
							ID:   "Cristino Castro",
							Name: "Cristino Castro",
						},
						{
							ID:   "Curimatá",
							Name: "Curimatá",
						},
						{
							ID:   "Currais",
							Name: "Currais",
						},
						{
							ID:   "Curral Novo do Piauí",
							Name: "Curral Novo do Piauí",
						},
						{
							ID:   "Curralinhos",
							Name: "Curralinhos",
						},
						{
							ID:   "Demerval Lobão",
							Name: "Demerval Lobão",
						},
						{
							ID:   "Dirceu Arcoverde",
							Name: "Dirceu Arcoverde",
						},
						{
							ID:   "Dom Expedito Lopes",
							Name: "Dom Expedito Lopes",
						},
						{
							ID:   "Dom Inocêncio",
							Name: "Dom Inocêncio",
						},
						{
							ID:   "Domingos Mourão",
							Name: "Domingos Mourão",
						},
						{
							ID:   "Elesbão Veloso",
							Name: "Elesbão Veloso",
						},
						{
							ID:   "Eliseu Martins",
							Name: "Eliseu Martins",
						},
						{
							ID:   "Esperantina",
							Name: "Esperantina",
						},
						{
							ID:   "Fartura do Piauí",
							Name: "Fartura do Piauí",
						},
						{
							ID:   "Flores do Piauí",
							Name: "Flores do Piauí",
						},
						{
							ID:   "Floresta do Piauí",
							Name: "Floresta do Piauí",
						},
						{
							ID:   "Floriano",
							Name: "Floriano",
						},
						{
							ID:   "Francinópolis",
							Name: "Francinópolis",
						},
						{
							ID:   "Francisco Ayres",
							Name: "Francisco Ayres",
						},
						{
							ID:   "Francisco Macedo",
							Name: "Francisco Macedo",
						},
						{
							ID:   "Francisco Santos",
							Name: "Francisco Santos",
						},
						{
							ID:   "Fronteiras",
							Name: "Fronteiras",
						},
						{
							ID:   "Geminiano",
							Name: "Geminiano",
						},
						{
							ID:   "Gilbués",
							Name: "Gilbués",
						},
						{
							ID:   "Guadalupe",
							Name: "Guadalupe",
						},
						{
							ID:   "Guaribas",
							Name: "Guaribas",
						},
						{
							ID:   "Hug


struct mlxsw_sp_acl_tcam_mr_ruleset),
	.ruleset_add		= mlxsw_sp_acl_tcam_mr_ruleset_add,
	.ruleset_del		= mlxsw_sp_acl_tcam_mr_ruleset_del,
	.ruleset_bind		= mlxsw_sp_acl_tcam_mr_ruleset_bind,
	.ruleset_unbind		= mlxsw_sp_acl_tcam_mr_ruleset_unbind,
	.ruleset_group_id	= mlxsw_sp_acl_tcam_mr_ruleset_group_id,
	.rule_priv_size		= sizeof(struct mlxsw_sp_acl_tcam_mr_rule),
	.rule_add		= mlxsw_sp_acl_tcam_mr_rule_add,
	.rule_del		= mlxsw_sp_acl_tcam_mr_rule_del,
	.rule_action_replace	= mlxsw_sp_acl_tcam_mr_rule_action_replace,
	.rule_activity_get	= mlxsw_sp_acl_tcam_mr_rule_activity_get,
};

static const struct mlxsw_sp_acl_profile_ops *
mlxsw_sp_acl_tcam_profile_ops_arr[] = {
	[MLXSW_SP_ACL_PROFILE_FLOWER] = &mlxsw_sp_acl_tcam_flower_ops,
	[MLXSW_SP_ACL_PROFILE_MR] = &mlxsw_sp_acl_tcam_mr_ops,
};

const struct mlxsw_sp_acl_profile_ops *
mlxsw_sp_acl_tcam_profile_ops(struct mlxsw_sp *mlxsw_sp,
			      enum mlxsw_sp_acl_profile profile)
{
	const struct mlxsw_sp_acl_profile_ops *ops;

	if (WARN_ON(profile >= ARRAY_SIZE(mlxsw_sp_acl_tcam_profile_ops_arr)))
		return NULL;
	ops = mlxsw_sp_acl_tcam_profile_ops_arr[profile];
	if (WARN_ON(!ops))
		return NULL;
	return ops;
}


() = default;
/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.

For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#include "ui/new_badges.h"

#include "lang/lang_keys.h"
#include "ui/painter.h"
#include "ui/widgets/labels.h"
#include "styles/style_window.h"
#include "styles/style_settings.h"

namespace Ui::NewBadge {
namespace {

[[nodiscard]] not_null<Ui::RpWidget*> CreateNewBadge(
		not_null<Ui::RpWidget*> parent,
		rpl::producer<QString> text) {
	const auto badge = Ui::CreateChild<Ui::PaddingWrap<Ui::FlatLabel>>(
		parent.get(),
		object_ptr<Ui::FlatLabel>(
			parent,
			std::move(text),
			st::settingsPremiumNewBadge),
		st::settingsPremiumNewBadgePadding);
	badge->setAttribute(Qt::WA_TransparentForMouseEvents);
	badge->paintRequest() | rpl::start_with_next([=] {
		auto p = QPainter(badge);
		auto hq = PainterHighQualityEnabler(p);
		p.setPen(Qt::NoPen);
		p.setBrush(st::windowBgActive);
		const auto r = st::settingsPremiumNewBadgePadding.left();
		p.drawRoundedRect(badge->rect(), r, r);
	}, badge->lifetime());
	return badge;
}

} // namespace

void AddToRight(not_null<Ui::RpWidget*> parent) {
	const auto badge = CreateNewBadge(parent, tr::lng_bot_side_menu_new());

	parent->sizeValue(
	) | rpl::start_with_next([=](QSize size) {
		badge->moveToRight(
			st::mainMenuButton.padding.right(),
			(size.height() - badge->height()) / 2,
			size.width());
	}, badge->lifetime());
}

void AddAfterLabel(
		not_null<Ui::RpWidget*> parent,
		not_null<Ui::RpWidget*> label) {
	const auto badge = CreateNewBadge(
		parent,
		tr::lng_premium_summary_new_badge());

	label->geometryValue(
	) | rpl::start_with_next([=](QRect geometry) {
		badge->move(st::settingsPremiumNewBadgePosition
			+ QPoint(label->x() + label->width(), label->y()));
	}, badge->lifetime());
}

} // namespace Ui::NewBadge
/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.

For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#include "editor/editor_crop.h"

#include "ui/userpic_view.h"
#include "styles/style_editor.h"
#include "styles/style_basic.h"
#include "styles/style_dialogs.h"

namespace Editor {
namespace {

constexpr auto kETL = Qt::TopEdge | Qt::LeftEdge;
constexpr auto kETR = Qt::TopEdge | Qt::RightEdge;
constexpr auto kEBL = Qt::BottomEdge | Qt::LeftEdge;
constexpr auto kEBR = Qt::BottomEdge | Qt::RightEdge;
constexpr auto kEAll = Qt::TopEdge
	| Qt::LeftEdge
	| Qt::BottomEdge
	| Qt::RightEdge;

std::tuple<int, int, int, int> RectEdges(const QRectF &r) {
	return { r.left(),


er to -log space
            if (prior_.scale() != 0)
                score -= -prior_.at(idx) * prior_.scale();  // priors are in +log space. substract them
        }
        else
            // not sure if that make sense otherwise
            require(prior_.scale() == 0);
    }
    else {
        if (returnScoresInNegLog_)
            score = Core::Type<Mm::Score>::max;  // = score 0 in std space
        else
            score = 0;
    }
    return score;
}

Mm::FeatureScorer::Scorer TrainerFeatureScorer::getTimeIndexedScorer(u32 time) const {
    require_lt(time, buffer_.size());
    Scorer scorer(new ContextScorer(this, time, batchIteration_));
    return scorer;
}

// Must never be full. We want to support segments of any len, and we want to
// get all features in advance before we calculate the scores (to support bi-RNNs).
bool TrainerFeatureScorer::bufferFilled() const {
    return false;
}  // == cannot call addFeature() anymore
bool TrainerFeatureScorer::bufferEmpty() const {
    return currentFeature_ >= buffer_.size();
}  // == cannot call flush() anymore
u32 TrainerFeatureScorer::bufferSize() const {
    return u32(-1);
}

}  // namespace Nn
/** Copyright 2020 RWTH Aachen University. All rights reserved.
 *
 *  Licensed under the RWTH ASR 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://www.hltpr.rwth-aachen.de/rwth-asr/rwth-asr-license.html
 *
 *  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.
 */
#ifndef _CORE_RESOURCE_USAGE_INFO_HH
#define _CORE_RESOURCE_USAGE_INFO_HH

#include <Core/Types.hh>
#include <Core/XmlStream.hh>

namespace Core {
/**
 * process resource usage information
 */
class ResourceUsageInfo {
public:
    typedef u64 SizeType;
    typedef f64 TimeType;

    ResourceUsageInfo();

    /**
     * update information
     */
    void update();

    /**
     * user time used (in seconds).
     * This is the total amount of time spent executing in user mode.
     */
    TimeType userTime() const {
        return utime_;
    }
    /**
     * System time used (in seconds).
     * This is the total amount of time spent executing in kernel mode.
     */
    TimeType systemTime() const {
        return stime_;
    }
    /**
     * total time used.
     * user time plus system time.
     */
    TimeType totalTime() const {
        return utime_ + stime_;
    }
    /**
     * Maximum resident set size used (in kilobytes).
     */
    SizeType maxResidentSetSize() const {
        return maxrss_;
    }
    /**
     * page reclaims.
     * The number of page faults serviced without any I/O activity.
     */
    SizeType pageReclaims() const {
        return minflt_;
    }
    /**
     * page faults.
     * The number of page faults serviced that required I/O activity.
     */
    SizeType pageFaults() const {
        return majflt_;
    }
    /**
     * block input operations.
     * The number of times the file system had to perform input.
     */
    SizeType blockInputOps() const {
        return inblock_;
    }
    /**
     * block output operations.
     * The number of times the file system had to perform output.
     */
    SizeType blockOutput


App(_, terms) => write!(f, "{}", apps(&terms.0, &terms.1)),
      Let(_, true, u, n, terms) => {
        write!(f, "letrec {}{}: {} := {}; {}", uses(u), name(n), terms.0, terms.1, terms.2)
      }
      Let(_, false, u, n, terms) => {
        write!(f, "let {}{}: {} := {}; {}", uses(u), name(n), terms.0, terms.1, terms.2)
      }
      Slf(_, nam, bod) => write!(f, "@{} {}", name(nam), bod),
      All(_, us_, nam, terms) => write!(f, "∀{}", alls(us_, nam, &terms.0, &terms.1)),
      Ann(_, terms) => write!(f, "{} :: {}", parens(&terms.1), parens(&terms.0)),
      Dat(_, bod) => write!(f, "data {}", bod),
      Cse(_, bod) => write!(f, "case {}", bod),
      Typ(_) => write!(f, "Type"),
      Lit(_, lit) => write!(f, "{}", lit),
      LTy(_, lty) => write!(f, "{}", lty),
      Opr(_, opr) => write!(f, "{}", opr),
    }
  }
}

impl Term {
  pub fn embed(self) -> (AnonTerm, MetaTerm) {
    match self {
      Self::Var(pos, _, idx) => (
        AnonTerm::Ctor(String::from("var"), vec![AnonTerm::Vari(idx)]),
        MetaTerm::Ctor(pos, vec![MetaTerm::Leaf]),
      ),
      Self::Ref(pos, name, def, ast) => (
        AnonTerm::Ctor(String::from("ref"), vec![AnonTerm::Link(ast)]),
        MetaTerm::Ctor(pos, vec![MetaTerm::Link(name, def)]),
      ),
      Self::Lit(pos, lit) => (
        AnonTerm::Ctor(String::from("lit"), vec![AnonTerm::Data(
          lit.encode().serialize(),
        )]),
        MetaTerm::Ctor(pos, vec![MetaTerm::Leaf]),
      ),
      Self::LTy(pos, lty) => (
        AnonTerm::Ctor(String::from("lty"), vec![AnonTerm::Data(
          lty.encode().serialize(),
        )]),
        MetaTerm::Ctor(pos, vec![MetaTerm::Leaf]),
      ),
      Self::Opr(pos, opr) => (
        AnonTerm::Ctor(String::from("opr"), vec![AnonTerm::Data(
          opr.encode().serialize(),
        )]),
        MetaTerm::Ctor(pos, vec![MetaTerm::Leaf]),
      ),
      Self::Typ(pos) => (
        AnonTerm::Ctor(String::from("typ"), vec![]),
        MetaTerm::Ctor(pos, vec![]),
      ),
      Self::Lam(pos, name, body) => {
        let (anon, meta) = (*body).clone().embed();
        (
          AnonTerm::Ctor(String::from("lam"), vec![AnonTerm::Bind(Box::new(
            anon,
          ))]),
          MetaTerm::Ctor(pos, vec![MetaTerm::Bind(
            name.to_owned(),
            Box::new(meta),
          )]),
        )
      }
      Self::Slf(pos, name, body) => {
        let (anon, meta) = (*body).clone().embed();
        (
          AnonTerm::Ctor(String::from("slf"), vec![AnonTerm::Bind(Box::new(
            anon,
          ))]),
          MetaTerm::Ctor(pos, vec![MetaTerm::Bind(
            name.to_owned(),
            Box::new(meta),
          )]),
        )
      }
      Self::App(pos, terms) => {
        let (fun_anon, fun_meta) = terms.0.clone().embed();
        let (arg_anon, arg_meta) = terms.1.clone().embed();
        (
          AnonTerm::Ctor(String::from("app"


*/
/*verbose.member: exprManySiblings:<dart.core::int>[1, 2, 3, 4]*/
exprManySiblings() => [1, 2, 3, 4];

/*normal.member: exprTooManySiblings:<int>[1, 2, 3, 4, 5]*/
/*verbose.member: exprTooManySiblings:<dart.core::int>[1, 2, 3, 4, 5]*/
/*limited.member: exprTooManySiblings:<int>[...]*/
exprTooManySiblings() => [1, 2, 3, 4, 5];

/*normal|limited.member: exprPrecedence1:1.{int.unary-}().{num.*}(2).{num.+}(3.{num./}(4)).{double.-}(5)*/
/*verbose.member: exprPrecedence1:1.{dart.core::int.unary-}().{dart.core::num.*}(2).{dart.core::num.+}(3.{dart.core::num./}(4)).{dart.core::double.-}(5)*/
exprPrecedence1() => -1 * 2 + 3 / 4 - 5;

/*normal|limited.member: exprPrecedence2:1.{num.*}(2.{num.+}(3)).{num./}(4.{num.-}(5)).{double.unary-}()*/
/*verbose.member: exprPrecedence2:1.{dart.core::num.*}(2.{dart.core::num.+}(3)).{dart.core::num./}(4.{dart.core::num.-}(5)).{dart.core::double.unary-}()*/
exprPrecedence2() => -(1 * (2 + 3) / (4 - 5));

/*normal|limited.member: exprPrecedence3:b ?{int} 0 : 1.{num.+}(2)*/
/*verbose.member: exprPrecedence3:b ?{dart.core::int} 0 : 1.{dart.core::num.+}(2)*/
exprPrecedence3(bool b) => b ? 0 : 1 + 2;

/*normal|limited.member: exprPrecedence4:(b ?{int} 0 : 1).{num.+}(2)*/
/*verbose.member: exprPrecedence4:(b ?{dart.core::int} 0 : 1).{dart.core::num.+}(2)*/
exprPrecedence4(bool b) => (b ? 0 : 1) + 2;

/*member: exprAssignmentEqualsNull1:(a = b) == null*/
exprAssignmentEqualsNull1(String a, String b) => (a = b) == null;

/*member: exprAssignmentEqualsNull2:a = b == null*/
exprAssignmentEqualsNull2(bool a, String b) => a = b == null;

/*member: exprAssignmentEqualsNull3:a = b == null*/
exprAssignmentEqualsNull3(bool a, String b) => a = (b == null);

/*member: exprAssignmentEquals1:(a = b) == c*/
exprAssignmentEquals1(String a, String b, String c) => (a = b) == c;

/*member: exprAssignmentEquals2:a = b == c*/
exprAssignmentEquals2(bool a, String b, String c) => a = b == c;

/*member: exprAssignmentEquals3:a = b == c*/
exprAssignmentEquals3(bool a, String b, String c) => a = (b == c);
// Copyright (c) 2021, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

/*class: Interface:
 maxInheritancePath=1,
 superclasses=[Object]
*/
class Interface {
  /*member: Interface.implementedLateFieldDeclaredGetterSetter#cls:
   classBuilder=Interface,
   isSourceDeclaration
  */
  /*member: Interface.implementedLateFieldDeclaredGetterSetter=#cls:
   classBuilder=Interface,
   isSourceDeclaration
  */
  late int implementedLateFieldDeclaredGetterSetter;
}

/*class: Class:
 interfaces


 {
  text-align: left;
}
#drupal-off-canvas .indentation {
  float: left; /* LTR */
  width: auto;
  height: auto;
  margin: 0 3px 0 -10px; /* LTR */
  padding: 0 0 0 10px; /* LTR */
}
[dir="rtl"] #drupal-off-canvas .indentation {
  float: right;
  margin: 0 -10px 0 3px;
  padding: 0 10px 0 0;
}
/**
 * @file
 * Reset most HTML elements styles for the off-canvas dialog.
 *
 * This is a generic reset. Drupal-specific classes are reset in components.
 */

/**
 * All HTML elements that could be used in off-canvas except div, bdo, bdi,
 * data, svg, map and math.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element
 */
#drupal-off-canvas {
  & span,
  & applet,
  & object,
  & iframe,
  & h1,
  & h2,
  & h3,
  & h4,
  & h5,
  & h6,
  & p,
  & blockquote,
  & pre,
  & a,
  & abbr,
  & acronym,
  & address,
  & big,
  & button,
  & cite,
  & code,
  & del,
  & dfn,
  & em,
  & img,
  & ins,
  & kbd,
  & q,
  & s,
  & samp,
  & small,
  & strike,
  & strong,
  & sub,
  & sup,
  & tt,
  & var,
  & b,
  & u,
  & i,
  & center,
  & dl,
  & dt,
  & dd,
  & ol,
  & ul,
  & li,
  & fieldset,
  & form,
  & label,
  & legend,
  & table,
  & caption,
  & tbody,
  & tfoot,
  & thead,
  & tr,
  & th,
  & td,
  & article,
  & aside,
  & canvas,
  & details,
  & embed,
  & figure,
  & figcaption,
  & footer,
  & header,
  & hgroup,
  & main,
  & menu,
  & meter,
  & nav,
  & output,
  & progress,
  & ruby,
  & section,
  & summary,
  & time,
  & mark,
  & audio,
  & video,
  & input,
  & select,
  & textarea {
    all: initial;
    box-sizing: border-box;
    text-shadow: none;
    -webkit-font-smoothing: antialiased;
    -webkit-tap-highlight-color: initial;

    &:after,
    &:before {
      all: initial;
      box-sizing: border-box;
      text-shadow: none;
      -webkit-font-smoothing: antialiased;
      -webkit-tap-highlight-color: initial;
    }
  }
}

/* Reset size and position on elements. */
#drupal-off-canvas a,
#drupal-off-canvas abbr,
#drupal-off-canvas acronym,
#drupal-off-canvas address,
#drupal-off-canvas applet,
#drupal-off-canvas article,
#drupal-off-canvas aside,
#drupal-off-canvas audio,
#drupal-off-canvas b,
#drupal-off-canvas big,
#drupal-off-canvas blockquote,
#drupal-off-canvas body,
#drupal-off-canvas canvas,
#drupal-off-canvas caption,
#drupal-off-canvas cite,
#drupal-off-canvas code,
#drupal-off-canvas dd,
#drupal-off-canvas del,
#drupal-off-canvas dfn,
#drupal-off-can


 {
			t.Errorf("expected account ID to be OvermindReadonly, got %v", a.ResourceID())
		}
	})

	t.Run("arn:aws:elasticloadbalancing:eu-west-2:540044833068:targetgroup/lambda-rvaaio9n3auuhnvvvjmp/6f23de9c63bd4653", func(t *testing.T) {
		arn := "arn:aws:elasticloadbalancing:eu-west-2:540044833068:targetgroup/lambda-rvaaio9n3auuhnvvvjmp/6f23de9c63bd4653"

		a, err := ParseARN(arn)
		if err != nil {
			t.Error(err)
		}

		if a.Type() != "targetgroup" {
			t.Errorf("expected type to be targetgroup, got %v", a.Type())
		}
	})
}

func TestIAMWildcardMatches(t *testing.T) {
	tests := []struct {
		Name           string
		ARN            string
		ShouldMatch    []string
		ShouldNotMatch []string
	}{
		{
			Name: "ARN with no wildcards",
			ARN:  "arn:aws:iam::123456789:user/Bob",
			ShouldMatch: []string{
				"arn:aws:iam::123456789:user/Bob",
			},
			ShouldNotMatch: []string{
				"arn:aws:iam::123456789:user/Alice",
				"arn:aws:iam::123456789:role/Bob",
				"arn:aws:iam::123456789:role/Alice",
			},
		},
		{
			Name: "Complex multi-wildcard ARN",
			// The asterisk (*) character can expand to replace everything
			// within a segment, including characters like a forward slash (/)
			// that may otherwise appear to be a delimiter within a given
			// service namespace. For example, consider the following Amazon S3
			// ARN as the same wildcard expansion logic applies to all services.
			ARN: "arn:aws:s3:::amzn-s3-demo-bucket/*/test/*",
			// The wildcards in the ARN apply to all of the following objects in
			// the bucket, not only the first object listed.
			ShouldMatch: []string{
				"arn:aws:s3:::amzn-s3-demo-bucket/1/test/object.jpg",
				"arn:aws:s3:::amzn-s3-demo-bucket/1/2/test/object.jpg",
				"arn:aws:s3:::amzn-s3-demo-bucket/1/2/test/3/object.jpg ",
				"arn:aws:s3:::amzn-s3-demo-bucket/1/2/3/test/4/object.jpg",
				"arn:aws:s3:::amzn-s3-demo-bucket/1///test///object.jpg",
				"arn:aws:s3:::amzn-s3-demo-bucket/1/test/.jpg",
				"arn:aws:s3:::amzn-s3-demo-bucket//test/object.jpg",
				"arn:aws:s3:::amzn-s3-demo-bucket/1/test/",
			},
			// Consider the last two objects in the previous list. An Amazon S3
			// object name can begin or end with the conventional delimiter
			// forward slash (/) character. While / works as a delimiter, there
			// is no specific significance when this character is used within a
			// resource ARN. It i


}

void ImageProcessor::undistortPoints(
    const vector<cv::Point2f>& pts_in,
    const cv::Vec4d& intrinsics,
    const string& distortion_model,
    const cv::Vec4d& distortion_coeffs,
    vector<cv::Point2f>& pts_out,
    const cv::Matx33d &rectification_matrix,
    const cv::Vec4d &new_intrinsics) {

  if (pts_in.size() == 0) return;

  const cv::Matx33d K(
      intrinsics[0], 0.0, intrinsics[2],
      0.0, intrinsics[1], intrinsics[3],
      0.0, 0.0, 1.0);

  const cv::Matx33d K_new(
      new_intrinsics[0], 0.0, new_intrinsics[2],
      0.0, new_intrinsics[1], new_intrinsics[3],
      0.0, 0.0, 1.0);

  if (distortion_model == "radtan") {
    cv::undistortPoints(pts_in, pts_out, K, distortion_coeffs,
                        rectification_matrix, K_new);
  } else if (distortion_model == "equidistant") {
    cv::fisheye::undistortPoints(pts_in, pts_out, K, distortion_coeffs,
                                 rectification_matrix, K_new);
  } else {
    ROS_WARN_ONCE("The model %s is unrecognized, use radtan instead...",
                  distortion_model.c_str());
    cv::undistortPoints(pts_in, pts_out, K, distortion_coeffs,
                        rectification_matrix, K_new);
  }

  return;
}

vector<cv::Point2f> ImageProcessor::distortPoints(
    const vector<cv::Point2f>& pts_in,
    const cv::Vec4d& intrinsics,
    const string& distortion_model,
    const cv::Vec4d& distortion_coeffs) {

  const cv::Matx33d K(intrinsics[0], 0.0, intrinsics[2],
                      0.0, intrinsics[1], intrinsics[3],
                      0.0, 0.0, 1.0);

  vector<cv::Point2f> pts_out;
  if (distortion_model == "radtan") {
    vector<cv::Point3f> homogenous_pts;
    cv::convertPointsToHomogeneous(pts_in, homogenous_pts);
    cv::projectPoints(homogenous_pts, cv::Vec3d::zeros(), cv::Vec3d::zeros(), K,
                      distortion_coeffs, pts_out);
  } else if (distortion_model == "equidistant") {
    cv::fisheye::distortPoints(pts_in, pts_out, K, distortion_coeffs);
  } else {
    ROS_WARN_ONCE("The model %s is unrecognized, using radtan instead...",
                  distortion_model.c_str());
    vector<cv::Point3f> homogenous_pts;
    cv::convertPointsToHomogeneous(pts_in, homogenous_pts);
    cv::projectPoints(homogenous_pts, cv::Vec3d::zeros(), cv::Vec3d::zeros(), K,
                      distortion_coeffs, pts_out);
  }

  return pts_out;
}

void ImageProcessor::integrateImuData(
    Matx33f& cam0_R_p_c, Matx33f& cam1_R_p_c) {
  // Find the start and the end limit within the imu msg buffer.
  auto begin_iter = imu_msg_buffer.begin();
  while (begin_iter != imu_msg_buffer.end()) {
    if


from "./templates";

// type Templates =
//   | "model"
//   | "helper"
//   | "controller"
//   | "interface"
//   | "middleware"
//   | "routes";

const getSingularNameLowerCase = (name: string) => {
  let index = name.lastIndexOf("s");
  let newName = name.slice(0, index);

  return newName;
};

const getSingularNameUpperCase = (name: string) => {
  return name.slice(0, 1).toUpperCase() + name.slice(1);
};

export const generateFiles = async (
  outputDir: string,
  name: string,
  apiVersion: string
) => {
  return await new Promise(async (resolve, reject) => {
    let files = [
      "/controllers",
      "/controllers/helpers",
      "/interfaces",
      "/middlewares",
      "/models",
      "/routes",
    ];
    files = files.map((item) => outputDir + item);
    files.push(outputDir);
    shell.mkdir("-p", files);
    Object.keys(templates).map(async (key) => {
      const item = templates[key] as string;
      const regex = new RegExp(key, "g");
      const route = files.find((item) => regex.test(item));
      const singularName = name.endsWith("s")
        ? getSingularNameLowerCase(name)
        : name;
      await fs.writeFile(
        `${route}/${singularName}.${key}.ts`,
        item
          .replace(/NAMEL/g, singularName)
          .replace(/NAMEU/g, getSingularNameUpperCase(singularName))
          .replace(/APIVERSION/g, apiVersion)
      );
    });
    resolve("done");
  });
};
import {Component} from "@angular/core";

@Component({
    selector : 'attribute-directive',
    template : `
 Attribute Directive Demo

NgClass demo paragraph

        <button (click)="toggle()">Toggle</button>

 NgStyle directive

NgStyle demo paragraph
`,
    styles : [`.classOne{color:red}
        .classTwo{background-color:black}`]
})

export class AttributeDirectiveComponent{
    public cone = true;
    public ctwo = false;
    public style = 'Italic';
    public size = '30px';

    toggle(){
        this.cone = !this.cone;
        this.ctwo = !this.ctwo;
    }
}
// Ngrx Imports
import { ActionReducer, Action, State } from '@ngrx/store';
// Model Imports
import { Task } from '../models/task.model';
// Task Action Type Import
import { ActionTypes } from '../actions/create-form.actions';

// the initial state of the tasks
export const initialState = {
  title: '',
  status: '',
  missingFields: []
};

export const createFormReducer: ActionReducer<any> = (state = initialState, action: Action) => {
  switch (action.type) {

    case ActionTypes.UPDATE_CREATE_TASK_INPUT:
      return {
        title: action.payload.name === 'title' ? action.payload.value : state.title,
        status: action.payload.name === 'status' ? action.payload.value : state.status,
        missingFields: state.missingFields
      };

    case ActionTypes.RESET_CREATE_FORM:
      return {
        title: '',
        status: '',
        missingFields: []
      };

    case ActionTypes.SHOW_REQUIRED_FIELD_ERRORS:
      return {
        title: state.title,
        status: state.status,
        missingFields: action.payload.missingFields
      };

    // Return state if action type is unknown
    default:
      return state;
  }
};
import { CommanderStatic


Common.Router.AddOffRamp(destCCIP.OffRamp.EthAddress, destCCIP.SourceChainSelector)
		if err != nil {
			return fmt.Errorf("setting offramp as fee updater shouldn't fail %w", err)
		}

		err = destCCIP.AddRateLimitTokens(sourceCCIP.Common.BridgeTokens, destCCIP.Common.BridgeTokens)
		if err != nil {
			return fmt.Errorf("setting rate limited tokens shouldn't fail %w", err)
		}
		err = destCCIP.SyncTokensAndPools(sourceCCIP.Common.BridgeTokens)
		if err != nil {
			return fmt.Errorf("syncing tokens and pools shouldn't fail %w", err)
		}
		err = destCCIP.Common.ChainClient.WaitForEvents()
		if err != nil {
			return fmt.Errorf("waiting for events on destination contract shouldn't fail %w", err)
		}
	} else {
		destCCIP.OffRamp, err = contractDeployer.NewOffRamp(destCCIP.OffRamp.EthAddress)
		if err != nil {
			return fmt.Errorf("getting new offramp shouldn't fail %w", err)
		}
	}
	if destCCIP.ReceiverDapp == nil {
		// ReceiverDapp
		destCCIP.ReceiverDapp, err = contractDeployer.DeployReceiverDapp(false)
		if err != nil {
			return fmt.Errorf("receiverDapp contract should be deployed successfully %w", err)
		}
		err = destCCIP.Common.ChainClient.WaitForEvents()
		if err != nil {
			return fmt.Errorf("waiting for events on destination contract deployments %w", err)
		}

		log.Info().Str("Address", destCCIP.ReceiverDapp.Address()).Msg("Receiver Dapp Deployed")

		wasReceiverDappDeployed = true
	} else {
		destCCIP.ReceiverDapp, err = contractDeployer.NewReceiverDapp(destCCIP.ReceiverDapp.EthAddress)
		if err != nil {
			return fmt.Errorf("getting new receiverDapp shouldn't fail %w", err)
		}
	}
	return nil
}

func (destCCIP *DestCCIPModule) CollectBalanceRequirements() []testhelpers.BalanceReq {
	var destBalancesReq []testhelpers.BalanceReq
	for _, token := range destCCIP.Common.BridgeTokens {
		destBalancesReq = append(destBalancesReq, testhelpers.BalanceReq{
			Name:   fmt.Sprintf("BridgeToken-%s-Address-%s", token.Address(), destCCIP.ReceiverDapp.Address()),
			Addr:   destCCIP.ReceiverDapp.EthAddress,
			Getter: GetterForLinkToken(token.BalanceOf, destCCIP.ReceiverDapp.Address()),
		})
	}
	for i, pool := range destCCIP.Common.BridgeTokenPools {
		destBalancesReq = append(destBalancesReq, testhelpers.BalanceReq{
			Name:   fmt.Sprintf("BridgeToken-%s-TokenPool-%s", destCCIP.Common.BridgeTokens[i].Address(), pool.Address()),
			Addr:   pool.EthAddress,
			Getter: GetterForLinkToken(destCCIP.Common.BridgeTokens[i].BalanceOf, pool.Address()),
		})
	}
	if destCCIP.Common.FeeToken.Address() != common.HexToAddress("0x0").String() {
		destBalancesReq = append(destBalancesReq, testhelpers.BalanceReq{
			Name:   fmt.Sprintf("FeeToken-%s-Address-%s", destCCIP.Common.FeeToken.Address(), destCCIP.ReceiverDapp.Address()),
			Addr:   destCCIP.ReceiverDapp.EthAddress,
			Getter: GetterForLinkToken(destCCIP.Common.FeeToken.BalanceOf, destCCIP.ReceiverDapp.Address()),
		})
		destBalancesReq = append(destBalancesReq, testhelpers.BalanceReq{
			Name:   fmt.Sprintf("FeeToken-%s-OffRamp-%s", destCCIP.Common.FeeToken.Address(), destCCIP.OffR


r))
			local oldfence = signs_lib.old_fenceposts[node.name]
			local newsign = signs_lib.old_fenceposts_replacement_signs[node.name]

			signs_lib.delete_objects(pos)

			local oldmeta = minetest.get_meta(pos):to_table()
			minetest.set_node(pos, { name = oldfence })
			minetest.set_node(signpos, { name = newsign, param2 = new_wmdir })
			local newmeta = minetest.get_meta(signpos)
			newmeta:from_table(oldmeta)
			signs_lib.update_sign(signpos)
		end
	end
})

-- Convert widefont sign nodes to use one base node with meta flag to select wide mode

minetest.register_lbm({
	nodenames = signs_lib.old_widefont_signs,
	name = "signs_lib:convert_widefont_signs",
	label = "Convert widefont sign nodes",
	run_at_every_load = false,
	action = function(pos, node)
		local basename = string.gsub(node.name, "_widefont", "")
		minetest.swap_node(pos, { name = basename, param2 = node.param2 })
		local meta = minetest.get_meta(pos)
		meta:set_int("widefont", 1)
		signs_lib.update_sign(pos)
	end
})

-- Maintain a list of currently-loaded blocks
minetest.register_lbm({
	nodenames = { "group:sign" },
	name = "signs_lib:update_block_list",
	label = "Update list of loaded blocks, log only those with signs",
	run_at_every_load = true,
	action = function(pos, node)
		-- yeah, yeah... I know I'm hashing a block pos, but it's still just a set of coords
		local hash = minetest.hash_node_position(vector.floor(vector.divide(pos, minetest.MAP_BLOCKSIZE)))
		if not signs_lib.block_list[hash] then
			signs_lib.block_list[hash] = true
			signs_lib.totalblocks = signs_lib.totalblocks + 1
		end
	end
})

minetest.register_chatcommand("regen_signs", {
	params = "",
	privs = { server = true },
	description = S(
	"Skims through all currently-loaded sign-bearing mapblocks, clears away any entities within each sign's node space, and regenerates their text entities, if any."),
	func = function(player_name, params)
		local allsigns = {}
		local totalsigns = 0
		for b in pairs(signs_lib.block_list) do
			local blockpos = minetest.get_position_from_hash(b)
			local pos1 = vector.multiply(blockpos, minetest.MAP_BLOCKSIZE)
			local pos2 = vector.add(pos1, minetest.MAP_BLOCKSIZE - 1)
			if minetest.get_node_or_nil(vector.add(pos1, minetest.MAP_BLOCKSIZE / 2)) then
				local signs_in_block = minetest.find_nodes_in_area(pos1, pos2, { "group:sign" })
				allsigns[#allsigns + 1] = signs_in_block
				totalsigns = totalsigns + #signs_in_block
			else
				signs_lib.block_list[b] = nil -- if the block is no longer loaded, remove it from the table
				signs_lib.totalblocks = signs_lib.totalblocks - 1
			end
		end
		if signs_lib.totalblocks < 0 then signs_


// TODO: strtold
    // http://www.cplusplus.com/reference/cstdlib/strtold/
    // TODO: strtoll
    // http://www.cplusplus.com/reference/cstdlib/strtoll/

    // TODO: convert to new API
    // http://www.cplusplus.com/reference/cstdlib/strtoul/
    val strtoul = object : APIFunction("strtoul") {
        override val args = arrayOf(ArgType.Pointer, ArgType.Pointer, ArgType.Int)
        override fun exec(name: String, vararg argv: ULong): APIResult {
            val str = os.sys.readAsciiString(argv[0])
            val endptr = argv[1]

            log.config { "[0x${ra.hex8}] strtoul(str='$str' endptr=${endptr.hex8} base=${argv[2]})" }

            val item = str.trim().splitBy(whitespaces).first()

            val base = when {
                argv[2] == 0uL -> when {
                    item.startsWith("0x") -> 16
                    item.startsWith("0") && item.length != 1 -> 8
                    else -> 10
                }
                else -> argv[2].int
            }

            val pattern = when {
                base == 16 && item.startsWith("0x") -> item.substring(2)
                base == 8 && item.startsWith("0") && item.length != 1 -> item.substring(1)
                else -> item
            }

            val value = runCatching { pattern.ulong(base) }.getOrDefault(0u)

            if (endptr != nullptr) {
                val feedback = argv[0] + str.indexOf(item) + item.length
                os.abi.writePointer(endptr, feedback)
            }
            return retval(value)
        }
    }

    // TODO: strtoull
    // http://www.cplusplus.com/reference/cstdlib/strtoull/

    // --- Pseudo-random sequence generation ---
    // TODO: rand
    // http://www.cplusplus.com/reference/cstdlib/rand/
    // TODO: srand
    // http://www.cplusplus.com/reference/cstdlib/srand/

    // --- Dynamic memory management ---

    // TODO: not tested
    // http://www.cplusplus.com/reference/cstdlib/calloc/
    @APIFunc
    fun calloc(num: size_t, size: size_t): VoidPointer {
        log.finest { "[0x${ra.hex8}] calloc(num=$num size=$size)" }
        val address = sys.allocateClean((num * size).int)
        return VoidPointer(sys, address)
    }

    // REVIEW: not tested
    // http://www.cplusplus.com/reference/cstdlib/free/
    @APIFunc
    fun free(ptr: VoidPointer) {
        log.finest { "[0x${ra.hex8}] free(ptr=0x$ptr)" }

        // REVIEW: Different exception
        if (ptr.isNotNull && !sys.free(ptr.address))
            throw GeneralException("[0x${ra.hex8}] free() of unknown address: 0x${ptr.address.hex8}")
    }

    // REVIEW: check size
    // REVIEW: exception operating
    // REVIEW: not tested
    // http://www.cplusplus.com/reference/cstdlib/malloc/
    @APIFunc
    fun malloc(size: size_t): VoidPointer {
        log.finest { "[0x${ra.hex8}] malloc(size=$size)" }
        val address = sys.allocate(size.int)
        return VoidPointer(sys, address)
    }

    // REVIEW: not tested
    // http://www.cplusplus.com/reference/cstdlib/realloc/
    @APIFunc
    fun realloc(ptr: VoidPointer, size: size_t): VoidPointer {
        log.finest { "[0x${ra.hex8}] realloc(ptr=$ptr size=$size)" }

        if (size.equals(0))


CssValue('border')).toContain('none');
      expect(addButton.getCssValue('padding')).toBe('5px 10px');
      expect(addButton.getCssValue('border-radius')).toBe('4px');
    });

  });

  describe('Progressive note search', () => {

    beforeAll(() => browser.get(''));

    it(`searches for 'Ma'`, async () => {
      getPageElts().searchBox.sendKeys('Ma');
      browser.sleep(1000);

      expect(getPageElts().searchResults.count()).toBe(4);
    });

    it(`continues search with 'g'`, async () => {
      getPageElts().searchBox.sendKeys('g');
      browser.sleep(1000);
      expect(getPageElts().searchResults.count()).toBe(2);
    });

    it(`continues search with 'e' and gets ${targetNote.text}`, async () => {
      getPageElts().searchBox.sendKeys('n');
      browser.sleep(1000);
      let page = getPageElts();
      expect(page.searchResults.count()).toBe(1);
      let note = page.searchResults.get(0);
      expect(note.getText()).toEqual(targetNote.text);
    });

    it(`navigates to ${targetNote.text} details view`, async () => {
      let note = getPageElts().searchResults.get(0);
      expect(note.getText()).toEqual(targetNote.text);
      note.click();

      let page = getPageElts();
      expect(page.noteDetail.isPresent()).toBeTruthy('shows note detail');
      let note2 = await Note.fromDetail(page.noteDetail);
      expect(note2.id).toEqual(targetNote.id);
      expect(note2.text).toEqual(targetNote.text.toUpperCase());
    });
  });

  async function dashboardSelectTargetNote() {
    let targetNoteElt = getPageElts().topNotes.get(targetNoteDashboardIndex);
    expect(targetNoteElt.getText()).toEqual(targetNote.text);
    targetNoteElt.click();
    browser.waitForAngular(); // seems necessary to gets tests to pass for toh-pt6

    let page = getPageElts();
    expect(page.noteDetail.isPresent()).toBeTruthy('shows note detail');
    let note = await Note.fromDetail(page.noteDetail);
    expect(note.id).toEqual(targetNote.id);
    expect(note.text).toEqual(targetNote.text.toUpperCase());
  }

  async function updateNoteTextInDetailView() {
    // Assumes that the current view is the note details view.
    addToNoteText(textSuffix);

    let page = getPageElts();
    let note = await Note.fromDetail(page.noteDetail);
    expect(note.id).toEqual(targetNote.id);
    expect(note.text).toEqual(newNoteText.toUpperCase());
  }

});

function addToNoteText(text: string): promise.Promise<void> {
  let input = element(by.css('input'));
  return input.sendKeys(text);
}

function expectHeading(hLevel: number, expectedText: string): void {
    let hTag = `h${hLevel}`;
    let hText = element(by.css(hTag)).getText();
    expect(hText).toEqual(expectedText, hTag);
};

function getNoteAEltById(id: number): ElementFinder {
  let spanForId = element(by.cssContainingText('li span.badge', id.toString()));
  return spanForId.element(by.xpath('..'));
}

function getNoteLiEltById(id: number): ElementFinder {
  let spanForId = element(by.cssContainingText('li span.badge', id.toString()));
  return spanForId.element(by.xpath('../..'));
}

async function toNoteArray(allNotes: ElementArrayFinder): Promise<Note[]> {
  let promisedNotes = await allNotes.map(Note.fromLi);
  // The cast is necessary to get around issuing with the signature of Promise.all()
  return


APcc:
		m68k_pc_offset += (dp->size == sz_long) ? 4 : 2;
		break;
	case i_RTR:
		/* do nothing, just for coverage debugging */
		break;
	/* TODO: handle EXG instruction */
	}

	/* Handle A-Traps better */
	if ((real_opcode & 0xf000) == 0xa000) {
		handled = true;
	}

	/* Handle EmulOps better */
	if ((real_opcode & 0xff00) == 0x7100) {
		handled = true;
		ru->rmask = 0xffff;
		ru->wmask = 0;
	}

	if (dp->suse && !handled)
		ru_fill_ea(ru, dp->sreg, (amodes)dp->smode, (wordsizes)dp->size, 0);

	if (dp->duse && !handled)
		ru_fill_ea(ru, dp->dreg, (amodes)dp->dmode, (wordsizes)dp->size, 1);

	if (rw_dest)
		ru->rmask |= ru->wmask;

	handled = handled || dp->suse || dp->duse;

	/* Mark all registers as used/written if the instruction may trap */
	if (may_trap(opcode)) {
		handled = true;
		ru->rmask = 0xffff;
		ru->wmask = 0xffff;
	}

	if (!handled) {
		jit_abort("ru_fill: %04x = { %04x, %04x }",
				  real_opcode, ru->rmask, ru->wmask);
	}
}
#endif

/********************************************************************
 * register allocation per block logging                            *
 ********************************************************************/

static uae_s8 vstate[VREGS];
static uae_s8 vwritten[VREGS];
static uae_s8 nstate[N_REGS];

#define L_UNKNOWN -127
#define L_UNAVAIL -1
#define L_NEEDED -2
#define L_UNNEEDED -3

#if USE_MATCH
static inline void big_to_small_state(bigstate * /* b */, smallstate * s)
{
  int i;

  for (i = 0; i < VREGS; i++)
	s->virt[i] = vstate[i];
  for (i = 0; i < N_REGS; i++)
	s->nat[i] = nstate[i];
}

static inline int callers_need_recompile(bigstate * /* b */, smallstate * s)
{
  int i;
  int reverse = 0;

  for (i = 0; i < VREGS; i++) {
	if (vstate[i] != L_UNNEEDED && s->virt[i] == L_UNNEEDED)
	  return 1;
	if (vstate[i] == L_UNNEEDED && s->virt[i] != L_UNNEEDED)
	  reverse++;
  }
  for (i = 0; i < N_REGS; i++) {
	if (nstate[i] >= 0 && nstate[i] != s->nat[i])
	  return 1;
	if (nstate[i] < 0 && s->nat[i] >= 0)
	  reverse++;
  }
  if (reverse >= 2 && USE_MATCH)
	return 1;	/* In this case, it might be worth recompiling the
				 * callers */
  return 0;
}
#endif

static inline void log_startblock(void)
{
	int i;

	for (i = 0; i < VREGS; i++) {
		vstate[i] = L_UNKNOWN;
		v


means no limit) |
| `CLOSESPIDER_ERRORCOUNT` | integer | `0` | 发生的错误数量，超过后关闭爬虫（0表示不限制） </br> Number of errors after which the spider will be closed (0 means no limit) |

### 爬虫设置 | Spider Settings

| 设置 / Setting | 类型 / Type | 默认值 / Default | 描述 / Description |
|---------------|------------|-----------------|-------------------|
| `DEPTH_LIMIT` | integer | `0` | 爬取的最大深度（0表示不限制） </br> The maximum depth to crawl (0 means no limit) |
| `DEPTH_PRIORITY` | integer | `0` | 深度优先级调整 </br> Depth priority adjustment |

### 日志设置 | Logging Settings

| 设置 / Setting | 类型 / Type | 默认值 / Default | 描述 / Description |
|---------------|------------|-----------------|-------------------|
| `LOG_ENABLED` | boolean | `True` | 是否启用日志 </br> Whether to enable logging |
| `LOG_LEVEL` | string | `'DEBUG'` | 日志级别 </br> Logging level |
| `LOG_FILE` | string | `None` | 日志文件路径 </br> Log file path |
| `LOG_STDOUT` | boolean | `False` | 是否将日志输出到标准输出 </br> Whether to log to standard output |
| `LOG_ENCODING` | string | `'utf-8'` | 日志文件编码 </br> Log file encoding |
| `LOG_FORMAT` | string |  | 日志格式 </br> Log format |

### 数据库设置 | Database Settings
| 设置 / Setting | 类型 / Type | 默认值 / Default | 描述 / Description |
|---------------|------------|-----------------|-------------------|
| `REDIS_ARGS` | dict | `{}` | Redis连接参数 </br> Redis connection parameters |
| `MONGO_ARGS` | dict | `{}` | MongoDB连接参数 </br> MongoDB connection parameters |
| `MYSQL_ARGS` | dict | `{}` | MySQL连接参数 </br> MySQL connection parameters |
| `PG_ARGS` | dict | `{}` | PostgreSQL连接参数 </br> PostgreSQL connection parameters |

## 示例 | Examples
### 基本设置示例 | Basic Settings Example

```python
# settings.py

# 基本设置 | Basic settings
BOT_NAME = 'myproject'
SPIDER_MODULES = ['myproject.spiders']
NEWSPIDER_MODULE = 'myproject.spiders'
USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'

# 并发和限制 | Concurrency and limits
CONCURRENT_REQUESTS = 32
CONCURRENT_REQUESTS_PER_DOMAIN = 16
DOWNLOAD_DELAY = 0.5
RANDOMIZE_DOWNLOAD_DELAY = True
DEPTH_LIMIT = 3  # 限制爬取深度为3 | Limit crawling depth to 3

# 下载处理程序 | Download handlers
DOWNLOAD_HANDLERS_TYPE = "httpx"

# 调度器设置 | Scheduler settings
DUPEFILTER_CLASS = 'aioscrapy.dupefilters.redis.RedisBloomDupeFilter'  # 使用Redis布隆过滤器 | Use Redis bloom filter
SCHEDULER_QUEUE_CLASS = 'aioscrapy.queue.redis.SpiderPriorityQueue'  # 使用Redis优先级队列 | Use Redis priority queue
SCHEDULER_SERIAL


 = gen_anchoring_keys(4);
    let redeem_script = btc::RedeemScript::from_pubkeys(&pub_keys, 3).compressed(Network::Testnet);

    let tx = dummy_anchoring_tx(&redeem_script);
    let pub_key = &pub_keys[0];
    let btc_signature = tx.sign_input(&redeem_script, 0, &priv_keys[0]);

    assert_eq!(
        *btc_signature.last().unwrap(),
        SigHashType::All.as_u32() as u8
    );
    assert!(tx.verify_input(&redeem_script, 0, &pub_key, &btc_signature));
}

#[test]
fn test_tx_verify_incorrect_signature() {
    let (pub_keys, priv_keys) = gen_anchoring_keys(4);
    let redeem_script = btc::RedeemScript::from_pubkeys(&pub_keys, 3).compressed(Network::Testnet);

    let tx = dummy_anchoring_tx(&redeem_script);
    let pub_key = &pub_keys[0];
    let mut btc_signature = tx.sign_input(&redeem_script, 0, &priv_keys[0]);
    btc_signature[8] = btc_signature[8].wrapping_add(63);

    assert!(!tx.verify_input(&redeem_script, 0, &pub_key, &btc_signature,));
}

/// Verifies that non-strict DER signatures do not pass verification
/// See https://github.com/bitcoin/bips/blob/master/bip-0066.mediawiki
#[test]
fn test_tx_verify_non_strict_der_signature() {
    let (pub_keys, priv_keys) = gen_anchoring_keys(4);
    let redeem_script = btc::RedeemScript::from_pubkeys(&pub_keys, 3).compressed(Network::Testnet);

    let tx = dummy_anchoring_tx(&redeem_script);
    let pub_key = &pub_keys[0];

    let btc_signature_1 = tx.sign_input(&redeem_script, 0, &priv_keys[0]);
    let mut btc_signature_2 = btc_signature_1.clone();
    // Set an incorrect length of the DER-encoded sequence in the signature
    btc_signature_2[1] = btc_signature_2[1].wrapping_add(1);

    assert!(btc_signature_1 != btc_signature_2);
    assert!(tx.verify_input(&redeem_script, 0, &pub_key, &btc_signature_1,));
    assert!(!tx.verify_input(&redeem_script, 0, &pub_key, &btc_signature_2,));
}

#[test]
fn test_tx_verify_sighash_type_wrong() {
    let (pub_keys, priv_keys) = gen_anchoring_keys(4);
    let redeem_script = btc::RedeemScript::from_pubkeys(&pub_keys, 3).compressed(Network::Testnet);

    let tx = dummy_anchoring_tx(&redeem_script);
    let pub_key = &pub_keys[0];
    let mut btc_signature = tx.sign_input(&redeem_script, 0, &priv_keys[0]);
    *btc_signature.last_mut().unwrap() = SigHashType::Single.as_u32() as u8;

    assert!(tx.verify_input(&redeem_script, 0, &pub_key, &btc_signature));
}

// rpc tests. Works through `rpc` by given env variables.
// See the `anchoring_client` method on top of this file.
#[cfg(feature = "rpc_tests")]
mod rpc {
    use super::*;

    use bitcoin::network::constants::Network;
    use bitcoin::util::base58::ToBase58;
    use bitcoinrpc;

    use exonum::helpers::{self, Height};
    use exonum::crypto::{hash, Hash};

    use details::rpc::{AnchoringRpcConfig, BitcoinRelay, RpcClient};
    use details::btc::transactions::{AnchoringTx, FundingTx, TransactionBuilder};
    use details::


 null, y: -5 },
      { x: 'c', y: -4 },
      { x: 'c', y: -3 },
      { x: 'b', y: -2 },
      { x: 'b', y: -2 },
      { x: 'a', y: -0 },
    ];

    const result = source.sort(sortBy('y'));

    // Assert
    expect(result).toEqual(expected);
  });
});

describe('sortBy(prop, prop) ', () => {
  it('sorts an array of objects by multiple properties (ascending, ascending)', () => {
    // Arrange
    const source = [
      { x: 'b', y: 2 },
      { x: 'a', y: 4 },
      { x: 'b', y: 1 },
      { x: 'c', y: 2 },
      { x: 'c', y: 2 },
      { x: 'c', y: 1 },
      { x: 'b', y: 3 },
      { x: 'å', y: 8 },
    ];

    const expected = [
      { x: 'a', y: 4 },
      { x: 'å', y: 8 },
      { x: 'b', y: 1 },
      { x: 'b', y: 2 },
      { x: 'b', y: 3 },
      { x: 'c', y: 1 },
      { x: 'c', y: 2 },
      { x: 'c', y: 2 },
    ];

    const result = source.sort(sortBy('x', 'y'));

    // Assert
    expect(result).toEqual(expected);
  });

  it('sorts an array of objects by multiple properties (descending, ascending)', () => {
    // Arrange
    const source = [
      { x: 'b', y: 2 },
      { x: 'a', y: 4 },
      { x: 'b', y: 1 },
      { x: 'c', y: 2 },
      { x: 'c', y: 2 },
      { x: 'c', y: 1 },
      { x: 'b', y: 3 },
      { x: 'å', y: 8 },
    ];

    const expected = [
      { x: 'c', y: 1 },
      { x: 'c', y: 2 },
      { x: 'c', y: 2 },
      { x: 'b', y: 1 },
      { x: 'b', y: 2 },
      { x: 'b', y: 3 },
      { x: 'å', y: 8 },
      { x: 'a', y: 4 },
    ];

    const result = source.sort(sortBy('-x', 'y'));

    // Assert
    expect(result).toEqual(expected);
  });

  it('sorts an array of objects by multiple properties (ascending, descending)', () => {
    // Arrange
    const source = [
      { x: 'b', y: 2 },
      { x: 'a', y: 4 },
      { x: 'b', y: 1 },
      { x: 'c', y: 2 },
      { x: 'c', y: 2 },
      { x: 'c', y: 1 },
      { x: 'b', y: 3 },
      { x: 'å', y: 8 },
    ];

    const expected = [
      { x: 'a', y: 4 },
      { x: 'å', y: 8 },
      { x: 'b', y: 3 },
      { x: 'b', y: 2 },
      { x: 'b', y: 1 },
      { x: 'c', y: 2 },
      { x: 'c', y: 2 },
      { x: 'c', y: 1 },
    ];

    const result = source.sort(sortBy('x', '-y'));

    // Assert
    expect(result).to


Only opening blocs can have parameters", arrow);
      }
      let identifiers = parseSequence(parseIdentifier, "parameter name");
      if (! identifiers) {
        throw new ParseError("Expected parameter list", curLoc);
      }
      let type: "local" | "global" = arrow.text == "->" ? "local" : "global";
      return ast.TemplateParamList(arrow, type, identifiers);
    }
  }

  /**
   */
  function completeBloc(bloc: ast.Bloc, mods: BlocMods, params?: ast.TemplateParamList) {
    // Only possibilities at this point are: open, open+implicit, close, and nothing
    if (mods.open) {
      // Add bloc to template
      stack.bloc.contents.children.push(bloc);

      // Now parsing this bloc's contents
      bloc.contents = ast.Template(curLoc, params);
      let id = mods.implicit ? null : bloc.expression;
      stack.push(bloc as ContainerBloc, id);
    }
    else if (mods.close) {
      // Finished parsing contents; go back to previous template
      stack.pop(bloc.expression);
    }
    else {
      // Add bloc to template, continue parsing same template
      stack.bloc.contents.children.push(bloc);
    }
  }

  /**
   */
  function completeDefinition(defn: ast.Definition, mods: BlocMods, params?: ast.TemplateParamList) {
    // Only possibilities at this point are: open, open+implicit, and nothing

    if (stack.bloc.type == "Definition") {
      throw new ParseError("Bloc property may not contain nested properties", defn);
    }
    if (stack.bloc.type == "RootBloc") {
      throw new ParseError("Root bloc may not contain properties", defn);
    }

    // Add definition to current bloc
    if (stack.bloc.properties) {
      stack.bloc.properties.push(defn);
    }
    else {
      stack.bloc.properties = [ defn ];
    }

    if (mods.open) {
      // Now parsing this bloc's contents
      defn.contents = ast.Template(curLoc, params);
      let id = mods.implicit ? null : defn.target;
      stack.push(defn as ContainerBloc, id);
    }
  }

  /**
   */
  function parseExpression(): Maybe<ast.Expression> {
    let valStack: Stack<ast.Expression> = [];
    let opStack: Stack<Token> = [];

    let primary = parsePrimary();
    if (primary) {
      Stack.push(valStack, primary);
      let op = parseBinary();
      while (op) {
        primary = parsePrimary();
        if (primary) {
          while (opStack.top && precedences[opStack.top.text] >= precedences[op.text]) {
            let op = Stack.pop(opStack);
            let right = Stack.pop(valStack);
            let left = Stack.pop(valStack);
            Stack.push(valStack, ast.BinaryOperation(op, left, op.text, right));
          }

          Stack.push(opStack, op);
          Stack.push(valStack, primary);
        }
        else {
          throw new ParseError('Expected operand', curLoc);
        }

        op = parseBinary();
      }

      while (opStack.top) {
        let op = Stack.pop(opStack);
        let right = Stack.pop(valStack);
        let left = Stack.pop(valStack);
        Stack.push(valStack, ast.BinaryOperation(op, left, op.text, right));
      }

      return Stack.pop(valStack);
    }
  }

  /**
   */
  function parseBinary(): Maybe<Token> {
    skipWs();
    let binop = match(/[*\/%+]|-(?!>)|<=?|>=?|[!=]=|&&|\|\|?/y);
    if (binop) {
      let token = Token(curLoc, binop[0]);
      advance();
      return token


ZPPP = aRenderer.aoBrightnessXZNN = aRenderer.aoBrightnessXZNP = aRenderer.aoBrightnessXZPN = aRenderer.aoBrightnessXZPP = aRenderer.aoBrightnessYZNN = aRenderer.aoBrightnessYZNP = aRenderer.aoBrightnessYZPN = aRenderer.aoBrightnessYZPP = aRenderer.brightnessBottomLeft = aRenderer.brightnessBottomRight = aRenderer.brightnessTopLeft = aRenderer.brightnessTopRight = aBrightness;}
		}
		/** Side = 1 */
		public static void prepareRenderYPos(short[] aRGBa, boolean aAllowAlpha, boolean aUseConstantBrightness, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, int aBrightness) {
			if (aRGBa == null) aRGBa = UNCOLOURED;
			Tessellator.instance.setColorRGBA((int)(UT.Code.bind8(aRGBa[0]) * 1.0F), (int)(UT.Code.bind8(aRGBa[1]) * 1.0F), (int)(UT.Code.bind8(aRGBa[2]) * 1.0F), aAllowAlpha?UT.Code.bind8(aRGBa[3]):255);
			Tessellator.instance.setBrightness(aBrightness);
			if (aRenderer.enableAO) applyAmbientOcclusionYPos(aRGBa, aUseConstantBrightness, aRenderer, aBlock, aX, aY, aZ, aBrightness);// else {aRenderer.aoLightValueScratchXYNN = aRenderer.aoLightValueScratchXYNP = aRenderer.aoLightValueScratchXYPN = aRenderer.aoLightValueScratchXYPP = aRenderer.aoLightValueScratchXYZNNN = aRenderer.aoLightValueScratchXYZNNP = aRenderer.aoLightValueScratchXYZNPN = aRenderer.aoLightValueScratchXYZNPP = aRenderer.aoLightValueScratchXYZPNN = aRenderer.aoLightValueScratchXYZPNP = aRenderer.aoLightValueScratchXYZPPN = aRenderer.aoLightValueScratchXYZPPP = aRenderer.aoLightValueScratchXZNN = aRenderer.aoLightValueScratchXZNP = aRenderer.aoLightValueScratchXZPN = aRenderer.aoLightValueScratchXZPP = aRenderer.aoLightValueScratchYZNN = aRenderer.aoLightValueScratchYZNP = aRenderer.aoLightValueScratchYZPN = aRenderer.aoLightValueScratchYZPP = aRenderer.aoBrightnessXYNN = aRenderer.aoBrightnessXYNP = aRenderer.aoBrightnessXYPN = aRenderer.aoBrightnessXYPP = aRenderer.aoBrightnessXYZNNN = aRenderer.aoBrightnessXYZNNP = aRenderer.aoBrightnessXYZNPN = aRenderer.aoBrightnessXYZNPP = aRenderer.aoBrightnessXYZPNN = aRenderer.aoBrightnessXYZPNP = aRenderer.aoBrightnessXYZPPN = aRenderer.aoBrightnessXYZPPP = aRenderer.aoBrightnessXZNN = aRenderer.aoBrightnessXZNP = aRenderer.aoBrightnessXZPN = aRenderer.aoBrightnessXZPP = aRenderer.aoBrightnessYZNN = aRenderer.aoBrightnessYZNP = aRenderer.aoBrightnessYZPN = aRenderer.aoBrightnessYZPP = aRenderer.brightnessBottomLeft = aRenderer.brightnessBottomRight = aRenderer.brightnessTopLeft = aRenderer.brightnessTopRight = aBrightness;}
		}
		/** Side = 0 */
		public static void prepareRenderYNeg(short[] aRGBa, boolean aAllowAlpha, boolean aUseConstantBrightness, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, int aBrightness) {
			if (aRGBa == null) aRGB


163-.175-.297-.369-.298-.43-.001-.061-.13-.237-.286-.39-.156-.152-.283-.314-.283-.358 0-.044-.156-.172-.344-.287-.189-.115-.342-.272-.342-.349-.002-.374-.258-1.025-.403-1.025-.094 0-.225-.227-.315-.544-.08-.286-.124-.417-.178-.445zM58 55.248c-.065.041-.09.125-.053.185.098.164.168.132.168-.075 0-.1-.052-.15-.116-.11zm1.43.182c-.096-.01-.174.044-.174.171 0 .097-.051.175-.114.175s-.114.083-.114.184c0 .1-.178.26-.397.354-.407.176-.61.577-.473.943.037.101-.009.34-.105.53-.17.34-.142.752.082 1.2.114.23.293.256.69.1.216-.084.32-.295.532-1.088.144-.542.31-1.106.367-1.255.139-.357.131-.81-.015-1.093-.07-.134-.183-.21-.279-.221zm-1.07.017c-.039-.008-.075-.004-.098.021-.046.048-.01.135.081.193.214.136.308.035.136-.143a.248.248 0 00-.118-.071zm30.442 2.097c-.167 0-.057.244.238.526.317.303.602.391.602.187 0-.114-.705-.713-.84-.713zm-27.718.235c-.063 0-.113.055-.113.12 0 .064.05.117.113.117a.118.118 0 00.116-.117.12.12 0 00-.116-.12zm20.91 4.005c.066 0 .09.053.052.118-.04.065-.094.117-.122.117-.028 0-.05-.052-.05-.117s.053-.118.12-.118zm9.121.04c-.03-.01-.055-.01-.067.003-.046.047.041.323.195.613.245.462.261.556.126.78-.134.22-.129.275.03.395.283.214.221.31-.172.268-.302-.031-.385.022-.562.359a2.324 2.324 0 01-.613.678c-.562.394-.849.987-.478.987.105 0 .14.082.1.235-.074.294-.046.294.515-.015.326-.18.477-.349.524-.592.04-.208.166-.379.325-.44.143-.054.249-.13.236-.17-.054-.165.262-.742.383-.7.159.055.634-.543.547-.689-.034-.057.012-.102.102-.102.17 0 .34-.438.236-.61-.032-.055-.185-.065-.338-.026-.192.05-.278.022-.28-.088-.005-.19-.593-.806-.809-.885zm-6.671 2.017c-.574-.003-.61.07-.348.715.09.225.226.409.303.409.269 0 .56-.39.56-.754-.001-.353-.018-.367-.515-.37z" color="currentColor"/></svg>';
  static const String world_map_alt_o =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="100" height="100" preserveAspectRatio="xMidYMid meet" viewBox="0 0 100 100"><path fill="currentColor" d="M2.5 12.5A2.5 2.5 0 000 15v70a2.5 2.5 0 002.5 2.5h95A2.5 2.5 0 00100 85V15a2.5 2.5 0 00-2.5-2.5h-95zm92.988 4.49V17H39.754c1.189.371 1.58.91


, ĝe kiuj estas aplikata* *puno de morto, estas signo de progresado de l’ civilizacio? *

“Æu vi povas dubi pri tio? Æu via Spirito ne indignas, legante la rakonton pri la homaj disbuĝadoj, iam farataj en la nomo de justeco kaj eĝ, ofte, honore al Dio; pri la turmentegoj, kiujn oni igis sperti kondamniton, eĝ akuzaton, por eltiri el li, per troaj suferoj, la konfeson de krimo, kiuj li, ofte, ne faris? Nu! Se vi estus tiam vivinta, ĝio ĝi þajnus al vi tute natura, kaj eble, se vi estus juĝanto, vu estus farinta tion saman. Tiel, kio þajnis justa en iu tempo, tio þajnas barbara en alia. Nur la diaj leĝoj estas eternaj; la homaj þanĝiĝas kun la progresado; ili ankoraŭ þanĝiĝos plu, ĝis ili harmonios kun la diaj leĝoj.”

*764. Jesuo diris: Æiuj, kiuj glavon prenas, per glavo* *pereos (19). Æu tiuj vortoj ne konfirmas la egalan* *repunon, kaj ĝu la morto, diktita al murdinto, ne estas* *la apliko de tiu puno? *

“Gardu vin! Vi tute eraras pri la senco de tiuj vortoj, *kiel pri tiu de multaj aliaj*. Egala repuno estas juĝo de Dio; neniu alia, ol Li mem, ĝin aplikas. Vi ĝiuj konstante ricevas tiun punon, ĝar vi estas punataj pro viaj eraroj, dum ĝi tiu aŭ *dum alia vivo*; kiu igis siajn similulojn suferi, tiu iam troviĝos en situacio, kie li ankaŭ suferos tion saman, kion li igis aliajn elporti: jen la senco de l’ vortoj de Jesuo. Æu li ne diris al vi ankaŭ: Pardonu viajn malamikojn? Kaj, ĝu li ne instruis vin peti Dion pardoni viajn ofendojn tiel, kiel vi pardonas viajn

ofendantojn, tio estas, *samgrade*, kiel vi konsentas pardonon? Komprenu bone tion.”

( 1 9 ) Mateo, ĝap. 26, par. 52. – *La Trad. *

LEØO DE DETRU ADO

*765. Kion ni pensu pri puno de morto, diktita en la* *nomo de Dio? *

“Tio estas eksidi sur la seĝon de Dio por mem juĝi.

Kiuj tiel kondutas, tiuj montras, kiel nekapablaj ili estas kompreni Dion, kaj ke ili devas ankoraŭ elpagi multe da kulpoj. Puno de morto estas krimo, kiam aplikata en la nomo de Dio; kaj kiuj ĝin diktas, tiuj respondas por ĝi, kiel ankaŭ por aliaj mortigoj.”

______________

ÆAPITRO VII

**VI – LEØO DE SOCIO**

*1. Neceso de la societa vivo. - 2. Izolvivado. Silentpromeso. – 3. Familioligiloj. *

## **Neceso de la societa vivo**

*766. Æu la societa vivo troviĝas en la Naturo? *

“Certe; Dio kreis la homon, por ke ĝi tiu vivu en

societo. Li ne senutile dotis la homon per paro


} else {
                hcaInfo.AthType = (ushort)(hcaInfo.Version < 0x0200 ? 1 : 0);
            }
            // LOOP
            v = stream.PeekUInt32LE();
            if (MagicValues.IsMagicMatch(v, MagicValues.LOOP)) {
                LoopHeader header;
                stream.Read(out header);
                hcaInfo.LoopStart = DereToreHelper.SwapEndian(header.LoopStart);
                hcaInfo.LoopEnd = DereToreHelper.SwapEndian(header.LoopEnd);
                hcaInfo.LoopR01 = DereToreHelper.SwapEndian(header.R01);
                hcaInfo.LoopR02 = DereToreHelper.SwapEndian(header.R02);
                hcaInfo.LoopFlag = true;
            } else {
                hcaInfo.LoopStart = 0;
                hcaInfo.LoopEnd = 0;
                hcaInfo.LoopR01 = 0;
                hcaInfo.LoopR02 = 0x400;
                hcaInfo.LoopFlag = false;
            }
            // CIPH
            v = stream.PeekUInt32LE();
            if (MagicValues.IsMagicMatch(v, MagicValues.CIPH)) {
                CipherHeader header;
                stream.Read(out header);
                hcaInfo.CipherType = (CipherType)DereToreHelper.SwapEndian(header.Type);
            } else {
                hcaInfo.CipherType = CipherType.NoChipher;
            }
            // RVA
            v = stream.PeekUInt32LE();
            if (MagicValues.IsMagicMatch(v, MagicValues.RVA)) {
                RvaHeader header;
                stream.Read(out header);
                hcaInfo.RvaVolume = DereToreHelper.SwapEndian(header.Volume);
            } else {
                hcaInfo


],i.3i)}1B;1t e.4g.cM:1a.1j.7D(t,n.aF.2H,!1);1B;1t e.4g.iB:1a.1j.7D(t,n.3W.2H,!0)}1a.1j.2v=r}n.qV=!0},t.1e.9z=1b(e,t){t.5p(1b(t,n,r){r.qE(e,n)},1a)},t}();e.v6=t})(2c||(2c={}));1c 2c;(1b(e){1c t=1b(){1b e(){}1d e.r7="CN+/",e.d2=1b(n){if(n<64)1d e.r7.dW(n);3K ul(n+": 2g a 64 AQ 4k")},e.ta=1b(n){if(n.1n===1)1d e.r7.9H(n);3K ul(\'"\'+n+\'" 8F 8h 1n 1\')},e}(),n=1b(){1b e(){}1d e.d2=1b(n){n<0?n=(-n<<1)+1:n<<=1;1c r="";do{1c i=n&31;n>>=5,n>0&&(i|=32),r+=t.d2(i)}3q(n>0);1d r},e.Ax=1b(n){1c r=0,i=!1,s=0;1w(1c o=0;o<n.1n;o++){1c u=t.ta(n[o]);o===0?((u&1)===1&&(i=!0),r=u>>1&15):r|=(u&31)<<s,s+=o==0?4:5;if((u&32)!==32)1d{4k:i?-r:r,zz:n.E9(o+1)}}3K 1h 2k(\'Ds 4k "\'+n+\'" zr 5F a D3 CJ\')},e}();e.iR=n})(2c||(2c={}));1c 2c;(1b(e){1c t=1b(){1b e(e){1a.4c=-1,1a.iQ=-1}1d e}();e.wN=t;1c n=1b(){1b t(t,n,r,i){1a.wg=r,1a.n0=i,1a.dG=1h 2T,1a.gb=-1,1a.iU=e.iV(n,!1,!0),1a.un=e.iV(t,!1,!0)}1d t.iW=".5p",t.ws=1b(t,n){if(n.iQ!==-1){1c r=t[n.iQ];if(r.iN===n.iN&&r.iM===n.iM)1d!1}1d!0},t.re=1b(r){1c i=r[0];i.wg.3D("//@ AP="+i.iU+t.iW);1c s=i.n0,o="",u=[],a=0,f=0,l=0,c=0,h=0,p=!1;1w(1c d=0;d<r.1n;d++){i=r[d];if(i.dG){1c v=u.1n;u.4b(i.un);1c m=i.dG;1w(1c g=0,y=m.1n;g<y;g++){1c b=m[g];if(!t.ws(m,b))3P;if(f!==b.iN){3q(f<b.iN)a=0,o+=";",f+


local HUDMAP = {}
HUDMAP.Map = "gm_construct"
HUDMAP.Material = "paris/maps/gm_construct/gm_construct_main"
HUDMAP.ScaleX = 0.3523
HUDMAP.ScaleY = 0.3584
HUDMAP.Translate = Vector(-1699.3,1535,0)

HUDMAP.UseZones = true
HUDMAP.Zones = {}
HUDMAP.Zones["MAIN"] = {
    Material = "paris/maps/gm_construct/gm_construct_main",
    ScaleX = 0.3523,
    ScaleY = 0.3584,
    Translate = Vector(-1699.3,1535,0),
    Zoom = 0.7,
}
HUDMAP.Zones["LOWER"] = {
    Material = "paris/maps/gm_construct/gm_construct_below",
    ScaleX = 0.3523,
    ScaleY = 0.3584,
    Translate = Vector(-1699.3,1535,0),
    Zoom = 0.7,
    InsideZones


" aria-label="Star Barqawiz/Tamagotchi on GitHub">Star

Tamagotchi

Give Identity to Your AI

        <button onclick="window.location.href='cat.html'">Cat</button>
        <button onclick="window.location.href='plant.html'">Plant</button>
        <button onclick="window.location.href='eyes.html'">Eyes</button>
        <button onclick="window.location.href='notion.html'">Notion</button>

<!DOCTYPE html>

  <meta charset="utf-8">
  <meta name="generator" content="pandoc">
  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
  $for(author-meta)$
  <meta name="author" content="$author-meta$">
  $endfor$
  $if(date-meta)$
  <meta name="dcterms.date" content="$date-meta$">
  $endif$
  <title>$if(title-prefix)$$title-prefix$ - $endif$$pagetitle$</title>

  $if(quotes)$

  $endif$
  $for(css)$
    <link rel="stylesheet" href="$css$">
  $endfor$
  $for(header-includes)$
    $header-includes$
  $endfor$

      $if(qrcode)$

      $endif$

        $firstname$
        $lastname$

$title$

    $if(photo)$

    $endif$

      $if(phone)$
      $if(settings.protect-phone)$
      $if(privatecv)$

$phone$

      $endif$
      $else$

$phone$

      $endif$
      $endif$

      $if(mobile)$
      $if(settings.protect-mobile)$
      $if(privatecv)$

$mobile$

      $endif$
      $else$

$mobile$

      $endif$
      $endif$

      $if(fax)$
      $if(settings.protect-fax)$
      $if(privatecv)$

$fax$

      $endif$
      $else$

$fax$

      $endif$
      $endif$

      $if(email)$
      $if(settings.protect-email)$
      $if(privatecv)$

$email$</l


, "lid")));
                watchingAnchor.setAvatar((String) XposedHelpers.getObjectField(liveRoomAnchorModel, "avatar"));
                isWatchingLive = true;
            }

            protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                super.afterHookedMethod(param);
            }
        });

    }

    private Object bluedUIHttpResponse;
    private Object grpcMsgSender;
    private TextView leaveLiveMsgSend;

    public void grpcMsgSenderHook() {
        Object Any = XposedHelpers.findClass("com.google.protobuf.Any", classLoader);
        XposedHelpers.findAndHookMethod("com.blued.android.module.live_china.msg.GrpcMsgSender$2", classLoader, "onReceive", Any, new XC_MethodHook() {
            @Override
            protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                super.beforeHookedMethod(param);
                Object any = param.args[0];
                Class<?> LiveMessage = XposedHelpers.findClass("cn.irisgw.live.LiveMessage", classLoader);
                boolean isLiveMessage = (boolean) XposedHelpers.callMethod(any, "is", LiveMessage);
                if (isLiveMessage) {

                    Object liveMessage = XposedHelpers.callMethod(any, "unpack", LiveMessage);
                    // 处理 LiveMessage
                    if (liveMessage != null) {
                        SettingItem settingItem = SQLiteManagement.getInstance().getSettingByFunctionId(SettingsViewCreator.REC_HEW_HORN);
                        liveMessageTime = System.currentTimeMillis();
                        Log.d("BluedHook", "收到消息->直播间消息，liveMessageTime：" + liveMessageTime);
                        Object msgExtra = XposedHelpers.callMethod(liveMessage, "getExtra");
                        Log.d("BluedHook", "收到消息->直播间消息，类型：" + XposedHelpers.callMethod(msgExtra, "getTypeUrl"));
                        int typeValue = (int) XposedHelpers.callMethod(liveMessage, "getTypeValue");
                        if (typeValue == 27) {
                            //进入直播间
                            if (msgExtra != null) {
                                Class<?> JoinLiveExtra = XposedHelpers.findClass("cn.irisgw.live.JoinLiveExtra", classLoader);
                                boolean isJoinLiveExtra = (boolean) XposedHelpers.callMethod(msgExtra, "is", JoinLiveExtra);
                                if (isJoinLiveExtra) {
                                    Object profile = XposedHelpers.callMethod(liveMessage, "getProfile");
                                    String name = (String) XposedHelpers.callMethod(profile, "getName");
                                    Log.i("BluedHook", "收到消息->直播间消息：" + name + " 进入直播间");
                                }
                            }
                        }
                        if (typeValue == 28) {
                            //离开直播间
                            Class<?> LeaveLiveExtra = XposedHelpers.findClass(" cn.irisgw.live.LeaveLiveExtra", classLoader);
                            boolean isLeaveLiveExtra = (boolean) XposedHelpers.callMethod(msgExtra, "is", LeaveLiveExtra);
                            if (isLeaveLiveExtra) {
                                Object profile = XposedHelpers.callMethod(liveMessage, "getProfile");
                                String name = (String) XposedHelpers.callMethod(profile, "getName");
                                Log.i("BluedHook", "收到消息->直播间消息：" + name + " 退出了直播间");
                                if (settingItem.isSwitchOn()) {
                                    ModuleTools.showBluedToast(name + " 退出了直播间");
                                }
                                if (leaveLiveMsgSend != null && (boolean) leaveLiveMsgSend.getTag() && isWatchingLive) {
                                    LiveMsgSendManagerHook.getInstance().startSendMsg(name + " 退出了直播间");
                                    Log.d("BluedHook", "收到消息->直播间消息：" + name + " 退出了直播间，并发送到公屏。");
                                }


666-.667 1.079-1.335 1.384-2.126.296-.765.499-1.636.558-2.913.06-1.28.072-1.687.072-4.947s-.015-3.667-.072-4.947c-.06-1.277-.262-2.149-.558-2.913-.306-.789-.718-1.459-1.384-2.126C21.319 1.347 20.651.935 19.86.63c-.765-.297-1.636-.499-2.913-.558C15.667.012 15.26 0 12 0zm0 2.16c3.203 0 3.585.016 4.85.071 1.17.055 1.805.249 2.227.415.562.217.96.477 1.382.896.419.42.679.819.896 1.381.164.422.36 1.057.413 2.227.057 1.266.07 1.646.07 4.85s-.015 3.585-.074 4.85c-.061 1.17-.256 1.805-.421 2.227-.224.562-.479.96-.899 1.382-.419.419-.824.679-1.38.896-.42.164-1.065.36-2.235.413-1.274.057-1.649.07-4.859.07-3.211 0-3.586-.015-4.859-.074-1.171-.061-1.816-.256-2.236-.421-.569-.224-.96-.479-1.379-.899-.421-.419-.69-.824-.9-1.38-.165-.42-.359-1.065-.42-2.235-.045-1.26-.061-1.649-.061-4.844 0-3.196.016-3.586.061-4.861.061-1.17.255-1.814.42-2.234.21-.57.479-.96.9-1.381.419-.419.81-.689 1.379-.898.42-.166 1.051-.361 2.221-.421 1.275-.045 1.65-.06 4.859-.06l.045.03zm0 3.678c-3.405 0-6.162 2.76-6.162 6.162 0 3.405 2.76 6.162 6.162 6.162 3.405 0 6.162-2.76 6.162-6.162 0-3.405-2.76-6.162-6.162-6.162zM12 16c-2.21 0-4-1.79-4-4s1.79-4 4-4 4 1.79 4 4-1.79 4-4 4zm7.846-10.405c0 .795-.646 1.44-1.44 1.44-.795 0-1.44-.646-1.44-1.44 0-.794.646-1.439 1.44-1.439.793-.001 1.44.645 1.44 1.439z" />
  </symbol>
</svg>

<svg xmlns="http://www.w3.org/2000/svg" style="display: none;">
  <symbol id="icon-youtube" viewBox="0 0 24 24">
    <title>YouTube</title>
    <path class="a" d="M23.495 6.205a3.007 3.007 0 0 0-2.088-2.088c-1.87-.501-9.396-.501-9.396-.501s-7.507-.01-9.396.501A3.007 3.007 0 0 0 .527


", "842", "865", "1600", "2200"], "xaxis": "x", "y": [0.03487016084361688, 0.02832629592672832, 0.01436574916135262, 0.007616424745440708, 0.006093323933310338, 0.006053976150686714, 0.006470242843162746, 0.005426802655127027, 0.00589580036832765, 0.0037491137650897156, 0.002909931048003532], "yaxis": "y"}, {"customdata": [[0.00032606676869508596], [0.0008850922829854358], [0.0008044920478143773], [0.0005432450041775679], [0.0004186308865377488], [0.00048755527891659737], [0.000526095982793903], [0.000484770907097481], [0.0005902513108392486], [0.00036468158054895434], [0.0003194188808906597]], "hovertemplate": "Attribute=12-12-20 16PCC
Column=Image
Band (nm)=%{x}
Reflectance=%{y}
Reflectance Std=%{customdata[0]}<extra></extra>", "legendgroup": "12-12-20 16PCC", "line": {"color": "peru", "dash": "solid"}, "mode": "lines", "name": "12-12-20 16PCC", "orientation": "v", "showlegend": true, "type": "scatter", "x": ["440", "490", "560", "665", "705", "740", "783", "842", "865", "1600", "2200"], "xaxis": "x", "y": [0.024253660933358394, 0.02058882720817047, 0.017596088691092443, 0.008054162083917623, 0.005829735461781517, 0.005014344902967014, 0.005001987186899718, 0.0038926443148579967, 0.004474061764218962, 0.001624659171915789, 0.0010362891084883857], "yaxis": "y"}, {"customdata": [[0.0013123693748345318], [0.001046549969822093], [0.0008666344357352188], [0.0005977610602348015], [0.0005232229001941791], [0.0005288955674636399], [0.0006314574882042014], [0.0005788693681879248], [0.0006512463495569654], [0.0003672497391784865], [0.00033585466126161075]], "hovertemplate": "Attribute=13-12-18 16PCC
Column=Image
Band (nm)=%{x}
Reflectance=%{y}
Reflectance Std=%{customdata[0]}<extra></extra>", "legendgroup": "13-12-18 16PCC", "line": {"color": "antiquewhite", "dash": "solid"}, "mode": "lines", "name": "13-12-18 16PCC", "orientation": "v", "showlegend": true, "type": "scatter", "x": ["440", "490", "560", "665", "705", "740", "783", "842", "865", "1600", "2200"], "xaxis": "x", "y": [0.02738246588053377, 0.018973122483353942, 0.006596841642939184, 0.00326960628009667, 0.0022654900394006826, 0.0027323440686038694, 0.0031037138979045802, 0.002267209364254594, 0.0025741895757622115, 0.0009126659103565


Assert.AreEqual(expectedArray2, centroids);
        }

        [TestMethod]
        public void TestCalculateSpectralCentroidsInOneSecondBlocksOnRealRecording()
        {
            var recording = new WavReader(TestAsset);
            var config = new SpectrogramSettings();
            var amplitudeSpectrogram = new AmplitudeSpectrogram(config, recording);

            var centroids = SpectralCentroid.CalculateSpectralCentroidsInOneSecondSegments(amplitudeSpectrogram);


import random as r

# range = list(input("Range : "))
# min=range[0]
# max=range[1]

compGuss=r.randint(1,100)
user_target=0
while user_target!=compGuss:
    user_target=int(input("Enter Number: "))
    if(user_target<compGuss):
        print("U enterd lower Number, U should enter higher Number!")
    elif(user_target>compGuss):
        print("U enterd Higher Number, U should enter lower Number!")
    else:
        print("Hurry! , U gussed Coorect Number.")