*/
    Variant = 0x107,
}

export namespace WaterLevelRegPack {
    /**
     * Pack format for 'level' data.
     */
    export const Level = "u0.16"

    /**
     * Pack format for 'level_error' data.
     */
    export const LevelError = "u0.16"

    /**
     * Pack format for 'variant' data.
     */
    export const Variant = "u8"
}

// Service Weight Scale constants
export const SRV_WEIGHT_SCALE = 0x1f4d5040

export enum WeightScaleVariant { // uint8_t
    Body = 0x1,
    Food = 0x2,
    Jewelry = 0x3,
}

export enum WeightScaleReg {
    /**
     * Read-only kg u16.16 (uint32_t). The reported weight.
     *
     * ```
     * const [weight] = jdunpack<[number]>(buf, "u16.16")
     * ```
     */
    Weight = 0x101,

    /**
     * Read-only kg u16.16 (uint32_t). The estimate error on the reported reading.
     *
     * ```
     * const [weightError] = jdunpack<[number]>(buf, "u16.16")
     * ```
     */
    WeightError = 0x106,

    /**
     * Read-write kg u16.16 (uint32_t). Calibrated zero offset error on the scale, i.e. the measured weight when nothing is on the scale.
     * You do not need to subtract that from the reading, it has already been done.
     *
     * ```
     * const [zeroOffset] = jdunpack<[number]>(buf, "u16.16")
     * ```
     */
    ZeroOffset = 0x80,

    /**
     * Read-write u16.16 (uint32_t). Calibrated gain on the weight scale error.
     *
     * ```
     * const [gain] = jdunpack<[number]>(buf, "u16.16")
     * ```
     */
    Gain = 0x81,

    /**
     * Constant kg u16.16 (uint32_t). Maximum supported weight on the scale.
     *
     * ```
     * const [maxWeight] = jdunpack<[number]>(buf, "u16.16")
     * ```
     */
    MaxWeight = 0x105,

    /**
     * Constant kg u16.16 (uint32_t). Minimum recommend weight on the scale.
     *
     * ```
     * const [minWeight] = jdunpack<[number]>(buf, "u16.16")
     * ```
     */
    MinWeight = 0x104,

    /**
     * Constant kg u16.16 (uint32_t). Smallest, yet distinguishable change in reading.
     *
     * ```
     * const [weightResolution] = jdunpack<[number]>(buf, "u16.16")
     * ```
     */
    WeightResolution = 0x108,

    /**
     * Constant Variant (uint8_t). The type of physical scale
     *
     * ```
     * const [variant] = jdunpack<[WeightScaleVariant]>(buf, "u8")
     * ```
     */
    Variant = 0x107,
}

export namespace WeightScaleRegPack {
    /**
     * Pack format for 'weight' data.
     */
    export const Weight = "u16.16"

    /**
     * Pack format for 'weight_error' data.
     */
    export const WeightError = "u16.16"

    /**
     * Pack format for 'zero_offset' data.
     */
    export const ZeroOffset = "u16.16"

    /**
     * Pack format for 'gain' data.
     */
    export const Gain = "u16.16"

    /**
     * Pack format for 'max_weight' data.
     */
    export const MaxWeight = "u16.16"

    /**
     * Pack format for 'min_weight' data.
     */
    export const MinWeight = "u16.16"

    /**
     * Pack format for 'we


cy.get('.modal__content button').contains('Preview').click()
		cy.get('.file_import__preview tbody tr', { timeout: 20000 }).should('have.length', 3)

		cy.intercept({ method: 'POST', url: '**/apps/tables/importupload/table/*'}).as('importUploadReq')
		cy.get('.modal__content button').contains('Import').click()
		cy.wait('@importUploadReq')
		cy.get('[data-cy="importResultColumnsFound"]', { timeout: 20000 }).should('contain.text', '2')
		cy.get('[data-cy="importResultColumnsMatch"]').should('contain.text', '3')
		cy.get('[data-cy="importResultColumnsCreated"]').should('contain.text', '0')
		cy.get('[data-cy="importResultRowsInserted"]').should('contain.text', '0')
		cy.get('[data-cy="importResultRowsUpdated"]').should('contain.text', '1')
		cy.get('[data-cy="importResultParsingErrors"]').should('contain.text', '0')
		cy.get('[data-cy="importResultRowErrors"]').should('contain.text', '0')
	})

})

describe('Import csv from Files file action', () => {

	before(function () {
		cy.createRandomUser().then(user => {
			localUser = user
			cy.login(localUser)
			cy.uploadFile('test-import.csv', 'text/csv')
		})
	})

	beforeEach(function () {
		cy.login(localUser)
		cy.visit('apps/files/files')
	})

	it('Import to new table', () => {
		cy.get('[data-cy-files-list-row-name="test-import.csv"] [data-cy-files-list-row-actions] .action-item button').click()
		cy.get('[data-cy-files-list-row-action="import-to-tables"]').click()

		cy.intercept({
			method: 'POST',
			url: '**/apps/tables/import/table/*'
		}).as('importNewTableReq')
		cy.get('[data-cy="fileActionImportButton"]').click({ force: true })
		cy.wait('@importNewTableReq').its('response.statusCode').should('equal', 200)

		cy.get('[data-cy="importResultColumnsFound"]').should('contain.text', '4')
		cy.get('[data-cy="importResultColumnsMatch"]').should('contain.text', '0')
		cy.get('[data-cy="importResultColumnsCreated"]').should('contain.text', '4')
		cy.get('[data-cy="importResultRowsInserted"]').should('contain.text', '3')
		cy.get('[data-cy="importResultParsingErrors"]').should('contain.text', '0')
		cy.get('[data-cy="importResultRowErrors"]').should('contain.text', '0')
	})

	it('Import to existing table', () => {
		cy.get('[data-cy-files-list-row-name="test-import.csv"] [data-cy-files-list-row-actions] .action-item button').click()
		cy.get('[data-cy-files-list-row-action="import-to-tables"]').click()

		cy.get('.modal__content [data-cy="importAsNewTableSwitch"] input').uncheck({ force: true })
		cy.get('[data-cy="selectExistingTableDropdown"]').type('Welcome to Nextcloud Tables!')
		cy.get('.name-parts').click()

		cy.intercept({
			method: 'POST',
			url: '**/apps/tables/import/table/*'
		}).as('importExistingTableReq')
		cy.get('[data-cy="fileActionImportButton"]').click({force: true})
		cy.wait('@importExistingTableReq').its('response.statusCode').should('equal', 200)

		cy.get('[data-cy="importResultColumnsFound"]').should('contain.text'


的地址。
5. 新增 `contrib/sdk/httpclient` 组件，用于本次版本新增的 `gf gen ctrl` 命令生成的 `HTTP SDK` 代码文件依赖库。
6. 新增 `contrib/trace/otlpgrpc` 及 `contrib/trace/otlphttp` 组件，用以实现基于 `OpenTelemetry` 的链路跟踪统一对接组件。

## 开发工具

1. 新增 `gf gen ctrl` 命令，用于编译 `api` 定义目录，自动生成规范的 `controller`、 `HTTP SDK` 代码： [接口规范-gen ctrl](../docs/开发工具/代码生成-gen/接口规范-gen%20ctrl.md)
2. 改进 `gf gen dao` 命令，新增 `TypeMapping` 特性，开发者可自定义数据表字段类型与生成的 `Go` 实体数据结构属性类型映射，并且可以方便引入第三方包类型（如 `decimal` 包以支持高精度类型）： [数据规范-gen dao](../docs/开发工具/代码生成-gen/数据规范-gen%20dao.md)
3. 改进 `gf gen enums` 命令，其中的 `Prefix` 参数改为 `Prefixes`，以支持多个生成枚举类型的包前缀指定： [枚举维护-gen enums](../docs/开发工具/代码生成-gen/枚举维护-gen%20enums.md)
4. 改进 `gf gen service` 命令：
    - 生成的 `service` 文件中，增加方法注释生成。
    - 当生成的 `service` 文件中存在 `import` 冲突时，自动生成 `import alias`。
5. 改进命令行封装，暴露 `gfcmd.Command` 类型，便于开发者可以继承扩展自定义命令行功能。
6. 改进 `gf docker` 命令，将构建文件参数设置为非必须（考虑兼容），未来将会只用于 `Docker` 构建，不再耦合二进制构建功能。如果有完整构建需求，建议未来结合 `gf build` 功能共同使用。并更新项目工程模板的 `make image` 命令，使用 `gf build+gf docker` 命令实现。
7. 改进 `gf init` 命令，修复在部分场景下初始化项目覆盖已存在的 `.git/.gitignore` 目录及文件问题或权限报错问题。
8. 改进 `gf up` 命令，修复在部分场景下的框架版本更新问题，以及在 `windows` 系统下的下载安装问题。
9. 改进 `gf version` 命令，修复在部分场景下的框架版本识别问题。
10. 修复 `gf gen pbentity` 命令，生成的 `proto` 文件实体数据结构的 `float32/float64/[]byte` 类型修改为 `float/double/bytes` 类


ampa.content

import android.util.Log
import top.rootu.lampa.App
import top.rootu.lampa.BuildConfig
import top.rootu.lampa.helpers.Prefs.REC
import top.rootu.lampa.models.LampaCard
import top.rootu.lampa.models.LampaRec

class Recs : LampaProviderI() {
    override fun get(): LampaContent {
        return LampaContent(Recs.get())
    }

    companion object {
        fun get(): List<LampaCard> {
            val lst = mutableListOf<LampaCard>()
            val recommendations = App.context.REC ?: return lst // Handle null case
            // Apply filters, ensure uniqueness, and shuffle
            val filtered = recommendations
                .filterAll(generateFilters())
                .distinctBy { it.id }
                .shuffled()
            // Log results in debug mode
            if (BuildConfig.DEBUG) {
                Log.d(
                    "Recs",
                    "Total recommendations: ${recommendations.size} | Filtered: ${filtered.size}"
                )
            }
            // Convert filtered recommendations to LampaCard and add to the list
            filtered.forEach { recommendation ->
                lst.add(recommendation.toLampaCard())
            }
            return lst
        }

        private fun generateFilters(): List<(LampaRec) -> Boolean> = listOf(
            // { it.genre_ids?.contains("16") != true }, // Exclude Animation
            { it.vote_average?.let { rating -> rating > 6 } == true }, // Rating > 6
            { it.popularity?.let { pop -> pop > 4 } == true } // Popularity > 4
        )

        private fun <T> List<T>.filterAll(filters: List<(T) -> Boolean>): List<T> =
            filter { item -> filters.all { filter -> filter(item) } }
    }
}package top.rootu.lampa.models

import top.rootu.lampa.tmdb.TMDB
import java.util.Locale

const val LAMPA_CARD_KEY = "lampaCardJSON" // Used in Intents and PlayStateManager

data class Favorite(
    val card: List<LampaCard>?,
    val like: List<String>?,
    val wath: List<String>?,
    val book: List<String>?,
    val history: List<String>?, //["KP_573840", 345887, 156022]
    val look: List<String>?,
    val viewed: List<String>?,
    val scheduled: List<String>?,
    val continued: List<String>?,
    val thrown: List<String>?
)

data class CubBookmark(
    val id: Int?,
    val cid: Int?,
    val card_id: String?, // "92830", "0a88d69f-6f33-49aa-91db-ee6e0c3fdff1"
    val type: String?, // "history", "book", "wath"
//    val data: String?, // "{\"id\":212344,\"source\":\"ivi\",\"title\"..."
    val data: LampaCard?, // Object
    val profile: Int?,
    val time: Long? // 0, 1650748577390
)

//data class TimeTable(
//    val id: Int?,
//    val season: Int?,
//    val episodes: Episodes?,
//    val scanned: Int?,
//    val scanned_time: Long?,
//)

//data class Episodes(
//    val air_date: String?,
//    val season_number: Int?,
//    val episode_number: Int?,
//    val name: String?,
//    val still_path: String?
//)

// TODO: implement type adapters for fields like id
// https://stackoverflow.com/questions/27626355/gson-deserializing-with-changing-field-types
// https://proandroiddev.com/safe-parsing-kotlin-data-classes-with-gson-4d560fe3cdd2
data class LampaCard(
    var source: String?, // "KP","tmdb","cub","ivi","okko" etc
    var type: String?, // "movie","tv","Scripted" etc
    val id: String?, // "KP_1227897","84958","0a88d69f-6f33-49aa-91db-ee6e0c3fdff1"
    val name: String?, // "Топ Гир: Лучшее",
    val original_name: String?, // "Top Gear: Best of",
    val title: String?, // "Топ Гир: Лучшее",


lass="comment-reply-link" href="#comment-20092" data-commentid="20092" data-postid="28497" data-belowelement="comment-20092" data-respondelement="respond" data-replyto="Reply to Natalya Drozhzhin" aria-label="Reply to Natalya Drozhzhin">Reply

Gerline<time data-get-timeago="2024-10-09T17:11:22-05:00" datetime="2024-10-09T17:11:22-05:00">Oct 9, 2024</time>

Hi, I have a family of dumpling lovers and for the first time I decided to make it and came across this recipe. I used the dough recipe but used my own filling just like some of the commenters but not too far from the original recipe. It turned out to taste amazing. I used a dumpling mold which worked great and looked so great that it looked like store bought. Unfortunately I cannot attach a picture otherwise I would have shown it to you guys. For those that might be interested in the mold I used, jnhuy 6.6'' Baozi Maker
 Thank you for sharing your recipe, I appreciate it.

Show More

3LikeReply

Syrr Willborn<a href


        throw Error(`Huh? -- Don't know where to place this ${entry}`);
      }
    });
    range.setValues(values);
  }
}

namespace SheetsManager {
  type Sheet = GoogleAppsScript.Spreadsheet.Sheet;
  export interface Item {
    /** The date range covered by this set of sheets. */
    from: Date;
    until: Date;
    /** this contains the schedule and is the main UI element. */
    scheduleSheet: Sheet;
    /** This contains the result of the SCHEDULECOUNT function for the regular slots */
    workSheet: Sheet;
    /** This contains the result of the SCHEDULECOUNT function for the doodle slots */
    doodleSheet: Sheet;
  }

  interface ItemInProgress {
    from: Date;
    until: Date;
    scheduleSheet?: Sheet;
    workSheet?: Sheet;
    doodleSheet?: Sheet;
  }

  const nameRegex = RegExp(
    "^(S|D|W) ([0-9]{4}-[0-9]{2}-[0-9]{2}) ([0-9]{4}-[0-9]{2}-[0-9]{2})$"
  );

  function makeSheetName(kind: "S" | "D" | "W", from: Date, until: Date) {
    const fromS = DateUtils.toISODate(from);
    const untilS = DateUtils.toISODate(until);
    const res = `${kind} ${fromS} ${untilS}`;
    Logger.log(res);
    return res;
  }

  /** Create a new set of sheets and do their layout. */
  export function create(from: Date, until: Date): Item {
    const s = SpreadsheetApp.getActiveSpreadsheet();
    const scheduleSheetName = makeSheetName("S", from, until);
    const workSheetName = makeSheetName("W", from, until);
    const doodleSheetName = makeSheetName("D", from, until);
    const scheduleSheet = s.insertSheet(scheduleSheetName);
    const workSheet = s.insertSheet(workSheetName);
    const doodleSheet = s.insertSheet(doodleSheetName);
    SheetLayouter.setup(scheduleSheet, workSheet, doodleSheet, from, until);
    return { from, until, scheduleSheet, workSheet, doodleSheet };
  }

  /** Return the active item (aka the one that is currently selected). */
  export function getActiveItem(): Item | undefined {
    const ss = SpreadsheetApp.getActive();
    const sheet = ss.getActiveSheet();
    const r = parseSheetName(sheet.getName());
    if (r === undefined) {
      return undefined;
    }
    const scheduleSheet = ss.getSheetByName(
      makeSheetName("S", r.from, r.until)
    );
    const doodleSheet = ss.getSheetByName(makeSheetName("D", r.from, r.until));
    const workSheet = ss.getSheetByName(makeSheetName("W", r.from, r.until));
    return {
      from: r.from,
      until: r.until,
      scheduleSheet,
      doodleSheet,
      workSheet,
    };
  }

  function parseSheetName(
    s: string
  ): { from: Date; until: Date; kind: "S" | "D" | "W" } | undefined {
    const m = nameRegex.exec(s);
    if (m !== null) {
      const from = new Date(m[2]);
      const until = new Date(m[3]);
      const kind = m[1] as "S" | "D" | "W";
      return { from, until, kind };
    }
    return undefined;
  }

  export function validateAndList(): Item[] {
    const items: Record<string, ItemInProgress> = {};
    const s = SpreadsheetApp.getActiveSpreadsheet();
    const sheets = s.getSheets();
    sheets.forEach((s) => {
      const name = s.getName();
      const m = name


[String] or a [Uri].
///
/// For POSIX and Windows styles, [uri] must be a `file:` URI. For the URL
/// style, this will just convert [uri] to a string.
///
///     // POSIX
///     p.fromUri('file:///path/to/foo') // -> '/path/to/foo'
///
///     // Windows
///     p.fromUri('file:///C:/path/to/foo') // -> r'C:\path\to\foo'
///
///     // URL
///     p.fromUri('https://dart.dev/path/to/foo')
///       // -> 'https://dart.dev/path/to/foo'
///
/// If [uri] is relative, a relative path will be returned.
///
///     p.fromUri('path/to/foo'); // -> 'path/to/foo'
String fromUri(Object? uri) => context.fromUri(uri!);

/// Returns the URI that represents [path].
///
/// For POSIX and Windows styles, this will return a `file:` URI. For the URL
/// style, this will just convert [path] to a [Uri].
///
///     // POSIX
///     p.toUri('/path/to/foo')
///       // -> Uri.parse('file:///path/to/foo')
///
///     // Windows
///     p.toUri(r'C:\path\to\foo')
///       // -> Uri.parse('file:///C:/path/to/foo')
///
///     // URL
///     p.toUri('https://dart.dev/path/to/foo')
///       // -> Uri.parse('https://dart.dev/path/to/foo')
///
/// If [path] is relative, a relative URI will be returned.
///
///     p.toUri('path/to/foo') // -> Uri.parse('path/to/foo')
Uri toUri(String path) => context.toUri(path);

/// Returns a terse, human-readable representation of [uri].
///
/// [uri] can be a [String] or a [Uri]. If it can be made relative to the
/// current working directory, that's done. Otherwise, it's returned as-is. This
/// gracefully handles non-`file:` URIs for [Style.posix] and [Style.windows].
///
/// The returned value is meant for human consumption, and may be either URI-
/// or path-formatted.
///
///     // POSIX at "/root/path"
///     p.prettyUri('file:///root/path/a/b.dart'); // -> 'a/b.dart'
///     p.prettyUri('https://dart.dev/'); // -> 'https://dart.dev'
///
///     // Windows at "C:\root\path"
///     p.prettyUri('file:///C:/root/path/a/b.dart'); // -> r'a\b.dart'
///     p.prettyUri('https://dart.dev/'); // -> 'https://dart.dev'
///
///     // URL at "https://dart.dev/root/path"
///     p.prettyUri('https://dart.dev/root/path/a/b.dart'); // -> r'a/b.dart'
///     p.prettyUri('file:///root/path'); // -> 'file:///root/path'
String prettyUri(Object? uri) => context.prettyUri(uri!);
// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import '../characters.dart' as chars;
import '../internal_style.dart';
import '../utils.dart';

/// The style for URL paths.
class UrlStyle extends InternalStyle {
  @override
  final name = 'url';
  @override
  final separator = '/';
  final separators = const ['/'];

  // Deprecated properties.

  @override
  final separatorPattern = RegExp(r'/');
  @override
  final needsSeparatorPattern = RegExp(r'(^[a-zA-Z][-+.a-zA-Z\d]*://|[^/])$');
  @override
  final rootPattern = RegExp(r'[a-zA-Z][-+.a-zA-Z\


"""
Determine when dev tests should be skipped by regular users.

Some tests are only intended to be tested during development right
before performing a release.  These do not test core functionality
of `cytoolz` and may be skipped.  These tests are only run if the
following conditions are true:

    - toolz is installed
    - toolz is the correct version
    - cytoolz is a release version
"""
import sys
import cytoolz

istest = lambda func: setattr(func, '__test__', True) or func
nottest = lambda func: setattr(func, '__test__', False) or func

try:
    import toolz
    do_toolz_tests = True
except ImportError:
    do_toolz_tests = False

if do_toolz_tests:
    do_toolz_tests = toolz.__version__.startswith(cytoolz.__toolz_version__)
    do_toolz_tests &= '+' not in cytoolz.__version__

# Decorator used to skip tests for developmental versions of CyToolz.
# Also, skip these tests on PyPy, which may handle docs differently.
if do_toolz_tests and sys.implementation.name != "pypy":
    dev_skip_test = istest
else:
    dev_skip_test = nottest


-support-ohio-voters-preliminary-exit-poll" title="Abortion Access Receives Broad Support from Ohio Voters, Indicates Preliminary Exit Poll" data-src="https://www.publishedreporter.com/wp-content/uploads/2023/11/Abortion-Vote_001-86x64.jpg" data-bs-srcset="{"baseurl":"https:\/\/www.publishedreporter.com\/wp-content\/uploads\/2023\/11\/","sizes":{"86":"Abortion-Vote_001-86x64.jpg","210":"Abortion-Vote_001-210x136.jpg","867":"Abortion-Vote_001.jpg"}}"						class="img-holder" href="https://www.publishedreporter.com/2023/11/07/abortion-access-receives-broad-support-from-ohio-voters-indicates-preliminary-exit-poll/">

			Abortion Access Receives Broad Support from Ohio Voters,…

							<time class="post-published updated"
				                         datetime="2023-11-07T21:35:15-05:00">Nov 7, 2023</time>

				<a  alt="David-Axelrod-Predicts-Biden’s-2024-Exit-As-Poll-Reveals-Trump’s-Lead-In-Crucial-Swing-States" title="David Axelrod Predicts Biden’s 2024 Exit as Poll Reveals Trump’s Lead in 5 Crucial Swing States" data-src="https://www.publishedreporter.com/wp-content/uploads/2023/11/Biden-86x64.jpg" data-bs-srcset="{"baseurl":"https:\/\/www.publishedreporter.com\/wp-content\/uploads\/2023\/11\/","sizes":{"86":"Biden-86x64.jpg","210":"Biden-210x136.jpg","640":"Biden.jpg"}}"						class="img-holder" href="https://www.publishedreporter.com/2023/11/07/david-axelrod-predicts-bidens-2024-exit-as-poll-reveals-trumps-lead-in-5-crucial-swing-states/">

			David Axelrod Predicts Biden’s 2024 Exit as Poll…

							<time class="post-published updated"
				                         datetime="2023-11-07T13:12:29-05:00">Nov 7, 2023</time>

	<div


65204 },
{ "Asia/Vladivostok", 65203 },
{ "Asia/Yakutsk", 65202 },
{ "Asia/Yangon", 65201 },
{ "Asia/Yekaterinburg", 65200 },
{ "Asia/Yerevan", 65199 },
{ "Atlantic/Azores", 65198 },
{ "Atlantic/Bermuda", 65197 },
{ "Atlantic/Canary", 65196 },
{ "Atlantic/Cape_Verde", 65195 },
{ "Atlantic/Faeroe", 65194 },
{ "Atlantic/Faroe", 65193 },
{ "Atlantic/Jan_Mayen", 65192 },
{ "Atlantic/Madeira", 65191 },
{ "Atlantic/Reykjavik", 65190 },
{ "Atlantic/South_Georgia", 65189 },
{ "Atlantic/St_Helena", 65188 },
{ "Atlantic/Stanley", 65187 },
{ "Australia/ACT", 65186 },
{ "Australia/Adelaide", 65185 },
{ "Australia/Brisbane", 65184 },
{ "Australia/Broken_Hill", 65183 },
{ "Australia/Canberra", 65182 },
{ "Australia/Currie", 65181 },
{ "Australia/Darwin", 65180 },
{ "Australia/Eucla", 65179 },
{ "Australia/Hobart", 65178 },
{ "Australia/LHI", 65177 },
{ "Australia/Lindeman", 65176 },
{ "Australia/Lord_Howe", 65175 },
{ "Australia/Melbourne", 65174 },
{ "Australia/NSW", 65173 },
{ "Australia/North", 65172 },
{ "Australia/Perth", 65171 },
{ "Australia/Queensland", 65170 },
{ "Australia/South", 65169 },
{ "Australia/Sydney", 65168 },
{ "Australia/Tasmania", 65167 },
{ "Australia/Victoria", 65166 },
{ "Australia/West", 65165 },
{ "Australia/Yancowinna", 65164 },
{ "BET", 65163 },
{ "BST", 65162 },
{ "Brazil/Acre", 65161 },
{ "Brazil/DeNoronha", 65160 },
{ "Brazil/East", 65159 },
{ "Brazil/West", 65158 },
{ "CAT", 65157 },
{ "CET", 65156 },
{ "CNT", 65155 },
{ "CST", 65154 },
{ "CST6CDT", 65153 },
{ "CTT", 65152 },
{ "Canada/Atlantic", 65151 },
{ "Canada/Central", 65150 },
{ "Canada/East-Saskatchewan", 65149 },
{ "Canada/Eastern", 65148 },
{ "Canada/Mountain", 65147 },
{ "Canada/Newfoundland", 65146 },
{ "Canada/Pacific", 65145 },
{ "Canada/Saskatchewan", 65144 },
{ "Canada/Yukon", 65143 },
{ "Chile/Continental", 65142 },
{ "Chile/EasterIsland", 65141 },
{ "Cuba", 65140 },
{ "EAT", 65139 },
{ "ECT", 65138 },
{ "EET", 65137 },
{ "EST", 65136 },
{ "EST5EDT", 65135 },
{ "Egypt", 65134 },
{ "Eire", 65133 },
{ "Etc/GMT", 65132 },
{ "Etc/GMT+0", 65131 },
{ "Etc/GMT+1", 65130 },
{ "Etc/GMT+10", 65129 },
{ "Etc/GMT+11", 65128 },
{ "Etc/GMT+12", 65127 },
{ "Etc/GMT+2", 65126 },
{ "Etc/GMT+3", 65125 },
{ "Etc/GMT+4", 65124 },
{ "Etc/GMT+5", 65123 },
{ "Etc/GMT+6", 65122 },
{ "Etc/GMT+7", 65121 },
{ "Etc/GMT+8",


ݵĲתΪTParameter(ʹas)executeAction
        /// </remarks>
        public TParameter Parameter
        {
            get => _parameter;
            set
            {
                if (_parameter == value)
                    return;

                _parameter = value;
                Detect= value as INotifyPropertyChanged;
                RaisePropertyChanged(nameof(Parameter));
            }
        }

        /// <summary>
        ///     Ƿæ
        /// </summary>
        public bool IsBusy => false;

        /// <summary>
        ///     ǰ״̬
        /// </summary>
        public CommandStatus Status => CommandStatus.None;

        #endregion

        #region ʵ

        /// <summary>
        ///     ڵôʱõķ
        /// </summary>
        /// <param name="parameter">󶨴ݵĲ(Parameter,Ч)</param>
        /// <remarks>
        ///     ParameterΪ,ִʱԴӰ󶨴ݵĲ,ʹParameterΪexecuteAction
        ///     ParameterΪ,֮ǰһ,Ӱ󶨴ݵĲתΪTParameter(ʹas)executeAction
        /// </remarks>
        void ICommand.Execute(object parameter)
        {
            _executeAction(Parameter ?? parameter as TParameter);
        }

        /// <summary>
        ///     ȷǷ䵱ǰ״ִ̬еķ
        /// </summary>
        /// <returns>
        ///     ִдΪ trueΪ false
        /// </returns>
        /// <param name="parameter">ʹõݡҪݣöΪ null</param>
        bool ICommand.CanExecute(object parameter)
        {
            return CanExecute(parameter as TParameter);
        }

        /// <summary>
        ///     ִ״̬仯¼
        /// </summary>
        public event EventHandler CanExecuteChanged;

        /// <summary>
        ///     ڵôʱõķ
        /// </summary>
        /// <param name="parameter">ݵĲ(ʹParameter,Ҳʹ)</param>
        public void Execute(TParameter parameter)
        {
            _executeAction(parameter);
        }

        /// <summary>
        ///     ִз
        /// </summary>
        /// <remarks>
        ///     ParameterΪ,ִʱԴӰ󶨴ݵĲ,ʹParameterΪexecuteAction
        ///     ParameterΪ,ʹnullΪexecuteAction
        /// </remarks>
        public void Execute()
        {
            _executeAction(Parameter);
        }

        /// <summary>
        ///     Ƿִ
        /// </summary>
        /// <param name="parameter"></param>
        /// <returns></returns>
        public bool CanExecute(TParameter parameter)
        {
            return _canExecuteAction == null || _canExecuteAction(Parameter ?? parameter);
        }

        /// <summary>
        ///     ִ״̬仯¼
        /// </summary>
        private void OnCanExecuteChanged()
        {
            if (CanExecuteChanged != null)
            {
                CanExecuteChanged(this, EventArgs.Empty);
            }
        }

        /// <summary>
        ///     ִ״̬仯¼
        /// </summary>
        public void RaiseCanExecuteChanged()
        {
            OnCanExecuteChanged();
        }

        #endregion

        /// <summary>
        ///     ޸¼(Ϊձʾɾ)
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged
        {
            add
            {
                propertyChanged -= value;
                propertyChanged += value;
            }
            remove => propertyChanged -= value;
        }

        /// <summary>
        ///     ޸¼
        /// </summary>
        private event PropertyChangedEventHandler propertyChanged;

        /// <summary>
        ///     ޸¼(ֹģʽӰ)
        /// </summary>
        /// <param name="propertyName"></param>
        private void RaisePropertyChanged(string propertyName)
        {
            if (propertyChanged == null)


 != nil {
			logs.Errorf("fail to delete rule, err: %v, ids: %v, rid: %s", err, domain, cts.Kit.Rid)
			return nil, err
		}
	}

	if err := svc.lblSync(cts.Kit, tcloudAdpt, lb, []string{listener.CloudID}); err != nil {
		// 调用同步的方法内会打印错误，这里只标记调用方
		logs.Errorf("fail to sync listener for delete rule, req: %+v, rid: %s", req, cts.Kit.Rid)
		return nil, err
	}

	return nil, nil
}

func (svc *clbSvc) lblSync(kt *kit.Kit, adaptor tcloud.TCloud, lb *corelb.BaseLoadBalancer, cloudIDs []string) error {
	syncClient := synctcloud.NewClient(svc.dataCli, adaptor)
	opt := &synctcloud.SyncListenerOption{
		BizID:     lb.BkBizID,
		LBID:      lb.ID,
		CloudLBID: lb.CloudID,
	}
	param := &synctcloud.SyncBaseParams{
		AccountID: lb.AccountID,
		Region:    lb.Region,
		CloudIDs:  cloudIDs,
	}
	_, err := syncClient.Listener(kt, param, opt)
	if err != nil {
		logs.Errorf("sync listener of lb(%s) failed, err: %v, rid: %s", lb.CloudID, err, kt.Rid)
		return err
	}
	return nil
}
/*
 * TencentBlueKing is pleased to support the open source community by making
 * 蓝鲸智云 - 混合云管理平台 (BlueKing - Hybrid Cloud Management System) available.
 * Copyright (C) 2022 THL A29 Limited,
 * a Tencent company. All rights reserved.
 * Licensed under the MIT License (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at http://opensource.org/licenses/MIT
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * We undertake not to change the open source license (MIT license) applicable
 *
 * to the current version of the project delivered to anyone in the future.
 */

package cvm

import (
	"fmt"
	"net/http"

	synctcloud "hcm/cmd/hc-service/logics/res-sync/tcloud"
	"hcm/cmd/hc-service/service/capability"
	typecvm "hcm/pkg/adaptor/types/cvm"
	"hcm/pkg/api/core"
	dataproto "hcm/pkg/api/data-service/cloud"
	protocvm "hcm/pkg/api/hc-service/cvm"
	"hcm/pkg/criteria/enumor"
	"hcm/pkg/criteria/errf"
	"hcm/pkg/dal/dao/tools"
	"hcm/pkg/logs"
	"hcm/pkg/rest"
)

func (svc *cvmSvc) initTCloudCvmService(cap *capability.Capability) {
	h := rest.NewHandler()

	h.Add("BatchCreateTCloudCvm", http.MethodPost, "/vendors/tcloud/cvms/batch/create", svc.BatchCreateTCloudCvm)
	h.Add("InquiryPriceTCloudCvm", http.MethodPost, "/vendors/tcloud/cvms/prices/inquiry", svc.InquiryPriceTCloud


/* $ Parameters */

/*     None. */

/* $ Exceptions */

/*     1) An error is signaled if the file cannot be parsed */
/*        successfully. */

/* $ Files */

/*     None. */

/* $ Particulars */

/*     None. */

/* $ Examples */

/*     None. */

/* $ Restrictions */

/*     None. */

/* $ Literature_References */

/*     None. */

/* $ Author_and_Institution */

/*     M.J. Spencer   (JPL) */

/* $ Version */

/* -    Beta Version 1.1.0, 17-JAN-2014 (BVS) */

/*        Increased LINLEN from 120 to 350 (350 = 300 characters for */
/*        value consistent with VALLEN in CPARSE_2 and the main program */
/*        + 50 more characters for the keyword name, =, and blanks.) */

/*        Increased maximum counts of child values in KWDS* from 300 to */
/*        1000 for all values. */

/*        Saved all variables. */

/* -    Beta Version 1.0.0, 26-JAN-1994 (MJS) */

/* -& */

/*     SPICELIB functions */

/*     Other functions */

/*     Local parameters */

/*     Local variables */

/*     Save all. */

/*     Initial values */

/*     Standard SPICE error handling. */

    if (return_()) {
	return 0;
    } else {
	chkin_("RDCMD", (ftnlen)5);
    }

/*     Initialize the parser. */

    ssizec_(&c__20, tabsym, (ftnlen)32);
    ssizei_(&c__20, tabptr);
    ssizec_(&c__20, tabval, (ftnlen)32);
    syputc_("HEAD", kwds1, &c__2, tabsym, tabptr, tabval, (ftnlen)4, (ftnlen)
	    32, (ftnlen)32, (ftnlen)32);
    syputc_("SPK_KERNEL", kwds2, &c__5, tabsym, tabptr, tabval, (ftnlen)10, (
	    ftnlen)32, (ftnlen)32, (ftnlen)32);
    syputc_("SOURCE_SPK_KERNEL", kwds3, &c__3, tabsym, tabptr, tabval, (
	    ftnlen)17, (ftnlen)32, (ftnlen)32, (ftnlen)32);
    syputc_("BEGIN_TIME", kwds4, &c__1, tabsym, tabptr, tabval, (ftnlen)10, (
	    ftnlen)32, (ftnlen)32, (ftnlen)32);
    initcp_(tabsym, tabptr, tabval, "HEAD", (ftnlen)32, (ftnlen)32, (ftnlen)4)
	    ;

/*     Open the command file, and parse its contents */

    txtopr_(cmdfil, &unit, cmdfil_len);
    eof = FALSE_;
    err = FALSE_;
    while(! eof && ! err) {
	ci__1.cierr = 1;
	ci__1.ciend = 1;
	ci__1.ciunit = unit;
	ci__1.cifmt = "(A)";
	iostat = s_rsfe(&ci__1);
	if (iostat != 0) {
	    goto L100001;
	}
	iostat = do_fio(&c__1, line, (ftnlen)350);
	if (iostat != 0) {
	    goto L100001;
	}
	iostat = e_rsfe();
L100001:
	eof = iostat != 0;
	evalcp_(line, &eof, cmdsym, cmdptr, cmdval, &err, (ftnlen)350,
		cmdsym_len, cmdval_len);
    }
    if (err) {
	cperr_(reason, &linnum, (ftnlen)160);
	repmi_(reason, "#", &linnum, reason, (ftnlen)160, (ftnlen)1, (ftnlen)
		160);
	prefix_(":", &c__1, reason, (ftnlen)1, (ftnlen)160);
	prefix_(cmdfil, &c__0, reason, cmdfil_len, (ftnlen)160);
	setmsg_(reason, (ftnlen)160);
	sigerr_("SPICE(CMDPARSEERROR)", (ftnlen)20);
	chkout_("RDCMD", (ftnlen)5);
	return 0;
    }
    chkout_("RDCMD", (ftnlen)5);
    return 0;
} /* rdcmd_ */


document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License".
  </p>
 </body>
</html>
<html>
 <head>
  <title>
   天津市资本家的思想动态 - 1955-12-12 - CCRD 中国当代政治运动史数据库
  </title>
  <link href="../../../../Emblem_of_the_PCP-Shining_Path.svg.ico" rel="icon" type="image/x-icon"/>
 </head>
 <body>
  <meta content="天津市资本家的思想动态" property="title"/>
  <meta content="1955-12-12" property="date"/>
  <meta content="" property="authors"/>
  <script type="application/ld+json">
   {"title": "\u5929\u6d25\u5e02\u8d44\u672c\u5bb6\u7684\u601d\u60f3\u52a8\u6001", "date": "1955-12-12", "authors": [], "contents": [{"text": "\u5929\u6d25\u5e02\u8d44\u672c\u5bb6\u7684\u601d\u60f3\u52a8\u6001", "type": "title"}, {"text": "\u3010\u5929\u6d25\u5206\u793e\u5341\u4e8c\u65e5\u8baf\u3011\u5929\u6d25\u5e02\u7edd\u5927\u591a\u6570\u8d44\u672c\u5bb6\u4e0d\u4ec5\u8ba4\u8bc6\u5230\u800c\u4e14\u5df2\u7ecf\u611f\u53d7\u5230\u5168\u4e1a\u5408\u8425\u5df2\u662f\u5927\u52bf\u6240\u8d8b\uff0c\u52bf\u6240\u5fc5\u81f3\u3002\u4ed


= fixture;
    }

    [Fact]
    public void TestEnableBucketLifecycleManagement()
    {
        var enableBucketLifecycleManagementSample = new EnableBucketLifecycleManagementSample();
        var disableBucketLifecycleManagementSample = new DisableBucketLifecycleManagementSample();

        // Enable bucket lifecycle management.
        var bucket = enableBucketLifecycleManagementSample.EnableBucketLifecycleManagement(_fixture.BucketNameGeneric);
        _fixture.SleepAfterBucketCreateUpdateDelete();
        Assert.Contains(bucket.Lifecycle.Rule, r => r.Condition.Age == 100 && r.Action.Type == "Delete");

        // Disable bucket lifecycle management.
        disableBucketLifecycleManagementSample.DisableBucketLifecycleManagement(_fixture.BucketNameGeneric);
        _fixture.SleepAfterBucketCreateUpdateDelete();
    }
}


Settings.Save();
		}

		[TearDown]
		public void Cleanup()
		{
			var dir = Path.GetDirectoryName(m_UserSettingsRepo.path);
			if(Directory.Exists(dir))
				Directory.Delete(dir);
		}

		[Test]
		public void ProjectUserSettings_IsCreatedAtCorrectPath()
		{
			var expectedPath = $"UserSettings/Packages/{k_PackageName}/Settings.json";
			Assert.That(m_UserSettingsRepo.path, Is.EqualTo(expectedPath));
			Assert.That(File.Exists(expectedPath));
		}
	}
}


note: string;
    deleted: boolean;
    createdAt: number;
    updatedAt: number;
}

class Break {

    public id: number;
    public userId: string;
    public from = ko.observable<moment.Moment>();
    public to = ko.observable<moment.Moment>();
    public adjustment: number;
    public note: string;
    public deleted: boolean;

    constructor(i?: BreakEntityData) {
        if (i) {
            this.id = i.id;
            this.userId = i.userId;
            this.from(moment(i.from, "X"));
            this.to(moment(i.to, "X"));
            this.adjustment = i.adjustment;
            this.note = i.note;
            this.deleted = i.deleted;
        }
    }

    public txtPeriod = ko.pureComputed<string>(() => {
        let period = this.from().format("YYYY-MM-DD");
        period += " ";
        period += this.from().format("HH:mm");
        period += " – ";
        period += this.to().format("HH:mm");
        return period;
    });

    public txtDuration = ko.pureComputed<string>(() => {
        let totalMinutes = this.to().diff(this.from(), "minutes");
        let minutes = totalMinutes % 60;
        let hours = (totalMinutes - minutes) / 60;
        return `${hours}:${minutes < 10 ? "0" + minutes : minutes}`;
    });

}

class BreaksViewModel {

    public breaks = ko.observableArray<Break>();
    private $newDialog: JQuery;
    public calendar: JQuery = undefined;
    public newBreakInput = {
        from: ko.observable<string>("2016-10-10 14:20"),
        to: ko.observable<string>("2016-10-10 15:20"),
        note: ko.observable<string>(),
        txtAdjustment: ko.observable<string>()
    };

    constructor() {
        // axios.defaults.baseURL = "http://localhost:8080/";
        axios.defaults.baseURL = "https://timetracker-160918.appspot.com/";
        axios.defaults.timeout = 1000;

        this.fetch();
        // this.$newDialog = $("#newBreak").dialog({
        //     position: {
        //         my: "center", at: "center", of: window
        //     },
        //     modal: true,
        //     show: { effect: "scale", duration: 100 },
        //     create: (event, ui) => {

        //     },
        //     close: (event, ui) => console.log(event, ui),
        //     resizable: false,
        //     title: "TimeTracker",
        //     closeOnEscape: true
        // });
    }

    public fetch = () => {
        axios.get("list")
            .then(response => {
                this.breaks(response.data.map(item => new Break(item)));
                console.log(response.data);
            })
            .catch(function (error) {
                console.log(error);
            });
    }

    public cmdClose() {
        this.$newDialog.dialog("close");
    }

    public cmdSave() {

        let newBreak = <BreakEntityData>{};

        newBreak.userId = "timetracker";

        let from = moment(this.newBreakInput.from(), "YYYY-MM-DD HH:mm", true);
        let to = moment(this.newBreakInput.to(), "YYYY-MM-DD HH:mm", true);

        if (from.isValid() && to.isValid() && from.isBefore(to)) {
            newBreak.from = Number(from.format("X"));
            newBreak.to = Number(to.format("X"));
            newBreak.userId = "timetracker";


121,'pitaya',FALSE)",
        "insert into table0(device,time,num,bigNum,floatNum,str,bool) values('d2',41536000000,12,2146483648,45.231,'strawberry',FALSE)",
        "insert into table0(device,time,num,bigNum,floatNum,str,bool) values('d2',41536000020,14,2907483648,231.34,'cherry',FALSE)",
        "insert into table0(device,time,num,bigNum,floatNum,str,bool) values('d2',41536900000,13,2107483648,54.12,'lychee',TRUE)",
        "insert into table0(device,time,num,bigNum,floatNum,str,bool) values('d2',51536000000,15,3147483648,235.213,'watermelon',TRUE)"
      };

  @BeforeClass
  public static void setUp() throws Exception {
    EnvFactory.getEnv().getConfig().getDataNodeCommonConfig().setSortBufferSize(1024 * 1024L);
    EnvFactory.getEnv().initClusterEnvironment();
    insertData();
  }

  @AfterClass
  public static void tearDown() throws Exception {
    EnvFactory.getEnv().cleanClusterEnvironment();
  }

  private static void insertData() {
    try (Connection connection = EnvFactory.getEnv().getTableConnection();
        Statement statement = connection.createStatement()) {

      for (String sql : sql1) {
        statement.execute(sql);
      }
      for (String sql : sql2) {
        statement.execute(sql);
      }
    } catch (Exception e) {
      e.printStackTrace();
      fail(e.getMessage());
    }
    // sessionInsertData1();
    // sessionInsertData2();
  }

  // ordinal data
  public static final String[][] RES =
      new String[][] {
        {"0", "3", "2947483648", "231.2121", "coconut", "false"},
        {"20", "2", "2147483648", "434.12", "pineapple", "true"},
        {"40", "1", "2247483648", "12.123", "apricot", "true"},
        {"80", "9", "2147483646", "43.12", "apple", "false"},
        {"100", "8", "2147483964", "4654.231", "papaya", "true"},
        {"31536000000", "6", "2147483650", "1231.21", "banana", "true"},
        {"31536000100", "10", "3147483648", "231.55", "pumelo", "false"},
        {"31536000500", "4", "2147493648", "213.1", "peach", "false"},
        {"31536001000", "5", "2149783648", "56.32", "orange", "false"},
        {"31536010000", "7", "2147983648", "213.112", "lemon", "true"},
        {"31536100000", "11", "2147468648", "54.121", "pitaya", "false"},
        {"41536000000", "12", "2146483648", "45.231", "strawberry", "false"},
        {"41536000020", "14", "2907483648", "231.34", "cherry", "false"},
        {"41536900000", "13", "2107483648", "54.12", "lychee", "true"},
        {"51536000000", "15", "3147483648", "235.213", "watermelon", "true"},
      };

  private void checkHeader(ResultSetMetaData resultSetMetaData, String[] title)
      throws SQLException {
    for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
      assertEquals(title[i - 1], resultSetMetaData.getColumnName(i));
    }
  }

  private void testNormalOrderBy(String sql, int[] ans) {
    try (Connection connection = EnvFactory.getEnv().getTableConnection();


ompressionStream:i,useWebWorkers:a,Deflate:o,Inflate:l,CompressionStream:h,DecompressionStream:d,workerScripts:_}=n;if(re("baseURL",t),re("chunkSize",e),re("maxWorkers",r),re("terminateWorkerTimeout",s),re("useCompressionStream",i),re("useWebWorkers",a),o&&(oe.CompressionStream=new nn(o)),l&&(oe.DecompressionStream=new nn(l)),re("CompressionStream",h),re("DecompressionStream",d),_!==$){const{deflate:m,inflate:g}=_;if((m||g)&&(oe.workerScripts||(oe.workerScripts={})),m){if(!Array.isArray(m))throw new Error("workerScripts.deflate must be an array");oe.workerScripts.deflate=m}if(g){if(!Array.isArray(g))throw new Error("workerScripts.inflate must be an array");oe.workerScripts.inflate=g}}}function re(n,t){t!==$&&(oe[n]=t)}function Ns(){return"application/octet-stream"}const kn=[];for(let n=0;n<256;n++){let t=n;for(let e=0;e<8;e++)t&1?t=t>>>1^3988292384:t=t>>>1;kn[n]=t}class Ue{constructor(t){this.crc=t||-1}append(t){let e=this.crc|0;for(let r=0,s=t.length|0;r<s;r++)e=e>>>8^kn[(e^t[r])&255];this.crc=e}get(){return~this.crc}}class Cn extends TransformStream{constructor(){let t;const e=new Ue;super({transform(r,s){e.append(r),s.enqueue(r)},flush(){const r=new Uint8Array(4);new DataView(r.buffer).setUint32(0,e.get()),t.value=r}}),t=this}}function Ps(n){if(typeof TextEncoder>"u"){n=unescape(encodeURIComponent(n));const t=new Uint8Array(n.length);for(let e=0;e<t.length;e++)t[e]=n.charCodeAt(e);return t}else return new TextEncoder().encode(n)}const Y={concat(n,t){if(n.length===0||t.length===0)return n.concat(t);const e=n[n.length-1],r=Y.getPartial(e);return r===32?n.concat(t):Y._shiftRight(t,r,e|0,n.slice(0,n.length-1))},bitLength(n){const t=n.length;if(t===0)return 0;const e=n[t-1];return(t-1)*32+Y.getPartial(e)},clamp(n,t){if(n.length*32<t)return n;n=n.slice(0,Math.ceil(t/32));const e=n.length;return t=t&31,e>0&&t&&(n[e-1]=Y.partial(t,n[e-1]&2147483648>>t-1,1)),n},partial(n,t,e){return n===32?t:(e?t|0:t<<32-n)+n*1099511627776},getPartial(n){return Math.round(n/1099511627776)||32},_shiftRight(n,t,e,r){for(r===void 0&&(r=[]);t>=32;t-=32)r.push(e),e=0;if(t===0)return r.concat(n);for(let a=0;a<n.length;a++)r.push(e|n[a]>>>t),e=n[a]<<32-t;const s=n.length?n[n.length-1]:0,i=Y.getPartial(s);return r.push(Y.partial(t+i&


Set()
        set.clone(constraintLayout)

        if (feature.isSeparating && feature.state == FoldingFeature.State.HALF_OPENED && feature.orientation == FoldingFeature.Orientation.HORIZONTAL) {
            set.setGuidelinePercent(R.id.hinge_top, 0.5f)
            set.setGuidelinePercent(R.id.hinge_bottom, 0.5f)
            callViewModel.halfOpenedFolded.value = true
        } else {
            set.setGuidelinePercent(R.id.hinge_top, 0f)
            set.setGuidelinePercent(R.id.hinge_bottom, 1f)
            callViewModel.halfOpenedFolded.value = false
        }

        set.applyTo(constraintLayout)
    }
}
/*
 * Copyright (c) 2010-2023 Belledonne Communications SARL.
 *
 * This file is part of linphone-android
 * (see https://www.linphone.org).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
package org.linphone.ui.assistant.model

import android.text.SpannableString
import android.text.Spanned
import android.text.style.ClickableSpan
import android.view.View
import androidx.annotation.UiThread
import androidx.lifecycle.MutableLiveData
import java.util.regex.Pattern
import org.linphone.LinphoneApplication.Companion.coreContext
import org.linphone.R
import org.linphone.core.tools.Log
import org.linphone.utils.AppUtils
import org.linphone.utils.Event

class AcceptConditionsAndPolicyDialogModel
    @UiThread
    constructor() {
    companion object {
        private const val TAG = "[Accept Terms & Policy Dialog Model]"
    }

    val message = MutableLiveData<SpannableString>()

    val dismissEvent = MutableLiveData<Event<Boolean>>()

    val conditionsAcceptedEvent = MutableLiveData<Event<Boolean>>()

    val generalTermsClickedEvent = MutableLiveData<Event<Boolean>>()

    val privacyPolicyClickedEvent = MutableLiveData<Event<Boolean>>()

    init {
        val generalTerms = AppUtils.getString(R.string.assistant_dialog_general_terms_label)
        val privacyPolicy = AppUtils.getString(R.string.assistant_dialog_privacy_policy_label)
        val label = coreContext.context.getString(
            R.string.assistant_dialog_general_terms_and_privacy_policy_message,
            generalTerms,
            privacyPolicy
        )
        val spannable = SpannableString(label)

        val termsMatcher = Pattern.compile(generalTerms).matcher(label)
        if (termsMatcher.find()) {
            val clickableSpan: ClickableSpan = object : ClickableSpan() {
                override fun onClick(widget: View) {
                    Log.i("$TAG Clicked on general terms link")
                    generalTermsClickedEvent.value = Event(true)
                }
            }
            spannable.setSpan(
                clickableSpan,
                termsMatcher.start(0),
                termsMatcher.end(),
                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
            )
        }

        val policyMatcher = Pattern.compile(privacyPolicy).matcher(label)
        if (policyMatcher.find()) {
            val clickableSpan: ClickableSpan = object : ClickableSpan() {
                override fun onClick(widget: View) {
                    Log.i("$TAG Clicked on privacy policy link")


 calculate all possible Box Dimensions based on a base Box
 *
 * @param possibleBasicBoxDimensions Possible Box Dimensions of the base Box
 * @param basicBox the base Box
 */
export function calculatePossibleUserBoxDimensions(shelf: Shelf, processingArea: ProcessingArea, basicBox: Box, rangeSteps: number[]) {
	const heights: number[] = [];
	const widths: number[] = [];
	const shelfHeight = shelf.height ? shelf.height : 0;
	const shelfWidth = shelf.width ? shelf.width : 0;

	rangeSteps.forEach((step) => {
		const height = basicBox.height * step;
		const width = basicBox.width * step;
		if (basicBox.height * step <= shelfHeight) heights.push(height);
		if (basicBox.width * step <= shelfWidth) widths.push(width);
	})
	return {
		heights: heights,
		widths: widths,
		depth: basicBox.depth,
	};
}

export function updatBoxDimensions(box: Box, newBoxDimesnions: BoxDimensions): void {
	box.possibleBoxDimensions = newBoxDimesnions;
}

export function boxDimensionValid(box: Box, boxDimensions: BoxDimensions): boolean {
	return boxDimensions.heights.includes(box.height) && boxDimensions.widths.includes(box.width);
}

export function updateBoxGridPosition(boxes: Box[], changedBox: Box) {
	boxes.forEach((box) => {
			if (box.id === changedBox.id) {
				box.x = changedBox.x;
				box.y = changedBox.y;
			}
	});
}

export function updateBoxSize(boxes: Box[], changedBox: Box) {
	boxes.forEach((box) => {
		if (box.id === changedBox.id) {
			if (changedBox.w > box.possibleBoxDimensions.widths.length) {
				console.error('Box does not for the given Box Dimensions(width)');
				return false;
			}
			if (changedBox.h > box.possibleBoxDimensions.heights.length) {
				console.error('Box does not for the given Box Dimensions(height)');
				return false;
			}
			box.width = box.possibleBoxDimensions.widths[changedBox.w - 1];
			box.height = box.possibleBoxDimensions.heights[changedBox.h - 1];
		}
	});
}

function getRandomInt(min, max) {
	min = Math.ceil(min);
	max = Math.floor(max);
	return Math.floor(Math.random() * (max - min)) + min;
}
import { SIZE, DIFFICULTY, IPropsPoint } from "./interface";

export const generateMine = (
  size: SIZE,
  level: DIFFICULTY,
  excluding: IPropsPoint[]
): IPropsPoint[] => {
  let mineCount = Math.floor(size ** 2 * level);
  let mineArray: IPropsPoint[] = [];

  while (mineArray.length < mineCount) {
    const x = Math.floor(Math.random() * size);
    const y = Math.floor(Math.random() * size);
    // try to put in a mine to the list
    const hasMine = (newMine: IPropsPoint) => (existMine: IPropsPoint) =>
      JSON.stringify(newMine) === JSON.stringify(existMine);
    const _mine = { x, y };
    if (!mineArray.find(hasMine(_mine)) && !excluding.find(hasMine(_mine))) {
      mineArray = [...mineArray, _mine];
    }
  }
  return mineArray;
};
const hamburger = document.querySelector('#hamburger') as HTMLDivElement;
const navContainer = document.querySelector('#navContainer') as HTMLDivElement;
const menuNav = document.querySelector('#menu') as HTMLElement;
let mainMenuOpen = false;
console.log('hello');

hamburger.addEventListener('click', (event) => {
  console.log(event.target);

  event.stopPropagation();
  // first time clicked
  if (m


46,402.437844 C757.578391,479.920712 607.447225,269.722256 190.38822,482.974654 C138.041293,509.751885 93.0794406,548.236279 53.824385,592.643155 C-67.7741113,730.200199 3.80142434,0.393364122 3.80142434,0.393364122 C3.80142434,0.393364122 1544.69072,-68.3837606 1526.71958,3.31021109 Z"></path><path fill-opacity="0.25" fill="white" d="M1210.97005,541.850857 C190.62187,541.850857 -214.084572,541.850857 -3.14927284,541.850857 C-3.14927284,541.850857 192.098802,267.584342 422.336047,194.15422 C591.822846,140.099386 854.700848,255.998265 1210.97005,541.850857 Z"></path><rect width="600" height="800" fill="url(#gradient-fade)"></rect><defs><linearGradient id="gradient-fade" x1="0" y1="0" x2="400" y2="0" gradientUnits="userSpaceOnUse"><stop stop-color="white"></stop><stop offset="1" stop-color="white" stop-opacity="0"></stop></linearGradient></defs></svg>

<form method="POST" novalidate="" style="display:flex">

1

Kontaktdaten

2

Lieferart</li


using Unity.Entities;
using UnityEngine;

namespace RMC.DOTS.Systems.SpawnGrid
{
    public class SpawnGridComponentAuthoring : MonoBehaviour
    {
        public GameObject Prefab;
        public Transform FromPosition;
        public Transform ToPosition;

        [Range(1, 1000)]
        public int Rows = 1;

        [Range(1, 1000)]
        public int Columns = 1;

        [Range(1, 1000)]
        public int Floors = 1;

        public class SpawnGridComponentAuthoringBaker : Baker<SpawnGridComponentAuthoring>
        {
            public override void Bake(SpawnGridComponentAuthoring authoring)
            {
                Entity entity = GetEntity(TransformUsageFlags.Dynamic);

                if (authoring.Prefab == null ||
                    authoring.Fr


ber=if ($_.DiskNumber -eq $null) { 4294967295 } else { $_.DiskNumber };
	ResourcePoolName=$_.PoolName;
	SupportPersistentReservations=$_.SupportPersistentReservations;
	MaximumIops=$_.MaximumIops;
	MinimumIops=$_.MinimumIops;
	QosPolicyId=$_.QosPolicyId;
	OverrideCacheAttributes=$_.WriteHardeningMethod;
}})

if ($vmHardDiskDrivesObject) {
	$vmHardDiskDrives = ConvertTo-Json -InputObject $vmHardDiskDrivesObject
	$vmHardDiskDrives
} else {
	"[]"
}
`))

func (c *ClientConfig) GetVmHardDiskDrives(ctx context.Context, vmName string) (result []api.VmHardDiskDrive, err error) {
	result = make([]api.VmHardDiskDrive, 0)

	err = c.WinRmClient.RunScriptWithResult(ctx, getVmHardDiskDrivesTemplate, getVmHardDiskDrivesArgs{
		VmName: vmName,
	}, &result)

	return result, err
}

type updateVmHardDiskDriveArgs struct {
	VmName              string
	ControllerNumber    int32
	ControllerLocation  int32
	VmHardDiskDriveJson string
}

var updateVmHardDiskDriveTemplate = template.Must(template.New("UpdateVmHardDiskDrive").Parse(`
$ErrorActionPreference = 'Stop'
Import-Module Hyper-V
$vmHardDiskDrive = '{{.VmHardDiskDriveJson}}' | ConvertFrom-Json

$vmHardDiskDrivesObject = @(Get-VM -Name '{{.VmName}}*' | ?{$_.Name -eq '{{.VmName}}' } | Get-VMHardDiskDrive -ControllerLocation {{.ControllerLocation}} -ControllerNumber {{.ControllerNumber}} )

if (!$vmHardDiskDrivesObject){
	throw "VM hard disk drive does not exist - {{.ControllerLocation}} {{.ControllerNumber}}"
}

$SetVmHardDiskDriveArgs = @{}
$SetVmHardDiskDriveArgs.VmName=$vmHardDiskDrivesObject.VmName
$SetVmHardDiskDriveArgs.ControllerType=$vmHardDiskDrivesObject.ControllerType
$SetVmHardDiskDriveArgs.ControllerLocation=$vmHardDiskDrivesObject.ControllerLocation
$SetVmHardDiskDriveArgs.ControllerNumber=$vmHardDiskDrivesObject.ControllerNumber
$SetVmHardDiskDriveArgs.ToControllerLocation=$vmHardDiskDrive.ControllerLocation
$SetVmHardDiskDriveArgs.ToControllerNumber=$vmHardDiskDrive.ControllerNumber
$SetVmHardDiskDriveArgs.Path=$vmHardDiskDrive.Path
if ($vmHardDiskDrive.DiskNumber -lt 4294967295){
	$SetVmHardDiskDriveArgs.DiskNumber=$vmHardDiskDrive.DiskNumber
}
if ($vmHardDiskDrivesObject.ResourcePoolName -ne $vmHardDiskDrive.ResourcePoolName) {
	if ($vmHardDiskDrive.ResourcePoolName) {
		$SetVmHardDiskDriveArgs.ResourcePoolName=$vmHardDiskDrive.ResourcePoolName
	} else {
		throw "Unable to remove resource pool $($vmHardDiskDrive.ResourcePoolName) from hard disk drive $(ConvertTo-Json -InputObject $vmHardDiskDrivesObject)"
	}
}
$SetVmHardDiskDriveArgs.SupportPersistentReservations=$vmHardDiskDrive.SupportPersistentReservations
$SetVmHardDiskDriveArgs.MaximumIops=$vmHardDiskDrive.MaximumIops
$SetVmHardDiskDriveArgs.MinimumIops=$vmHardDiskDrive.MinimumIops
$SetVmHardDiskDriveArgs.QosPolicyId=$vmHardDiskDrive.QosPolicyId
$SetVmHardDiskDriveArgs.OverrideCacheAttributes=$vmHardDiskDrive.OverrideCacheAttributes
$SetVmHardDiskDriveArgs.AllowUnverifiedPaths=$true

Set-VMHardDiskDrive @SetVmHardDiskDriveArgs

`))

func (c *ClientConfig) UpdateVmHardDiskDrive(
	ctx context.Context,
	vmName string,
	controllerNumber int32,
	controllerLocation int32,
	controllerType api.ControllerType,
	toControllerNumber int32,
	toControllerLocation int32,


ntry_DoNotUse, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::proto3::TestMap_StringMapEntry_DoNotUse, key_),
  PROTOBUF_FIELD_OFFSET(::proto3::TestMap_StringMapEntry_DoNotUse, value_),
  0,
  1,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::proto3::TestMap, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::proto3::TestMap, _impl_.bool_map_),
  PROTOBUF_FIELD_OFFSET(::proto3::TestMap, _impl_.int32_map_),
  PROTOBUF_FIELD_OFFSET(::proto3::TestMap, _impl_.int64_map_),
  PROTOBUF_FIELD_OFFSET(::proto3::TestMap, _impl_.uint32_map_),
  PROTOBUF_FIELD_OFFSET(::proto3::TestMap, _impl_.uint64_map_),
  PROTOBUF_FIELD_OFFSET(::proto3::TestMap, _impl_.string_map_),
  PROTOBUF_FIELD_OFFSET(::proto3::TestNestedMap_BoolMapEntry_DoNotUse, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::proto3::TestNestedMap_BoolMapEntry_DoNotUse, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::proto3::TestNestedMap_BoolMapEntry_DoNotUse, key_),
  PROTOBUF_FIELD_OFFSET(::proto3::TestNestedMap_BoolMapEntry_DoNotUse, value_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::proto3::TestNestedMap_Int32MapEntry_DoNotUse, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::proto3::TestNestedMap_Int32MapEntry_DoNotUse, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::proto3::TestNestedMap_Int32MapEntry_DoNotUse, key_),
  PROTOBUF_FIELD_OFFSET(::proto3::TestNestedMap_Int32MapEntry_DoNotUse, value_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::proto3::TestNestedMap_Int64MapEntry_DoNotUse, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::proto3::TestNestedMap_Int64MapEntry_DoNotUse, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::proto3::TestNestedMap_Int64MapEntry_DoNotUse, key_),
  PROTOBUF_FIELD_OFFSET(::proto3::TestNestedMap_Int64MapEntry_DoNotUse, value_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::proto3::TestNestedMap_Uint32MapEntry_DoNotUse, _has_bits_),
  PROTOBUF_FIELD_


%23FFF' d='M10.032 6.584l13.456 8.28a1.333 1.333 0 0 1 0 2.272l-13.456 8.28A1.333 1.333 0 0 1 8 24.281V7.719a1.333 1.333 0 0 1 2.032-1.135z'/%3E%3C/svg%3E")}.page_video .video_opr .opr_inner_fl .switch.switch_off .btn_opr{background-image:url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24'%3E%3Cpath fill='%23FFF' fill-rule='evenodd' d='M7 5h2c.552 0 1 .418 1 .933v12.134c0 .515-.448.933-1 .933H7c-.552 0-1-.418-1-.933V5.933C6 5.418 6.448 5 7 5zm8 0h2c.552 0 1 .418 1 .933v12.134c0 .515-.448.933-1 .933h-2c-.552 0-1-.418-1-.933V5.933c0-.515.448-.933 1-.933z'/%3E%3C/svg%3E")}.page_video .video_opr .opr_inner_fl .played_time,.page_video .video_opr .opr_inner_fl .total_time{display:inline-block;vertical-align:middle;color:#fff;font-weight:500;font-size:12px;min-width:auto}.page_video .video_opr .opr_inner_fr .screenSize_control{display:inline-block;vertical-align:middle;padding:2px 0 2px 20px;-webkit-appearance:none;-webkit-tap-highlight-color:rgba(0,0,0,0)}.page_video .video_opr .opr_inner_fr .screenSize_control .icon_control{overflow:hidden;line-height:999em;display:inline-block;vertical-align:middle;width:24px;height:24px;background-size:cover;background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg width='24' height='24' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M21 15v5a1 1 0 01-1 1h-5v-2h4v-4h2zM9 3v2H5v4H3V4a1 1 0 011-1h5zm8.584 2H15V3h5a1 1 0 011 1v5h-2V6.414l-4.366 4.364-1.414-1.414L17.584 5zM6.416 18.998H9v2H4a1 1 0 01-1-1v-5h2v2.587l4.366-4.365 1.414 1.414-4.364 4.364z' fill-rule='evenodd' fill='%23FFF'/%3E%3C/svg%3E")}.page_video .video_opr .play_mode{display:none;-webkit-box-flex:1;width:32px;text-align:center;padding-right:12px;position:relative}.page_video .video_opr .play_mode .btn_mode{text-align:center;color:#fff;font-size:12px;font-weight:700}.page_video .video_opr .play_mode .btn_mode.current{color:#09bb07}.page_video .video_opr .play_mode .pop_mode_select{position:absolute;bottom:31px;text-align:center;background-color:#242424;border-radius:5px;-moz-border-radius:5px;-webkit-border-radius:5px;width:62px;display:none;left:-15px}.page_video .video_opr .play_mode .pop_mode_select .clarity{display:inline-block;padding:2px 0;width:62px}.page_video .video_opr .play_mode .pop_mode_select .clarity .clarity_item{border-bottom:1px solid #3e3e3e;padding:11px 0;width:62px;c


) : Vec_WrdEntryP(p->vSims, p->nWords*(iVar0 - nVars));
            word * pDiv1 = iVar1 < nVars ? (word *)Vec_PtrEntry(p->vDivs, iVar1) : Vec_WrdEntryP(p->vSims, p->nWords*(iVar1 - nVars));
            word * pDiv  = Vec_WrdEntryP(p->vSims, p->nWords*i/2);
            if ( iVar0 < iVar1 )
                Abc_TtAndCompl( pDiv, pDiv0, Abc_LitIsCompl(iLit0), pDiv1, Abc_LitIsCompl(iLit1), p->nWords );
            else if ( iVar0 > iVar1 )
            {
                assert( !Abc_LitIsCompl(iLit0) );
                assert( !Abc_LitIsCompl(iLit1) );
                Abc_TtXor( pDiv, pDiv0, pDiv1, p->nWords, 0 );
            }
            else assert( 0 );
        }
        pDivRes = Vec_WrdEntryP( p->vSims, p->nWords*(Vec_IntSize(p->vGates)/2-1) );
    }
    if ( Abc_LitIsCompl(iTopLit) )
        RetValue = !Abc_TtIntersectOne(p->pSets[1], 0, pDivRes, 0, p->nWords) && !Abc_TtIntersectOne(p->pSets[0], 0, pDivRes, 1, p->nWords);
    else
        RetValue = !Abc_TtIntersectOne(p->pSets[0], 0, pDivRes, 0, p->nWords) && !Abc_TtIntersectOne(p->pSets[1], 0, pDivRes, 1, p->nWords);
    if ( pFunc ) Abc_TtCopy( pFunc, pDivRes, p->nWords, Abc_LitIsCompl(iTopLit) );
    return RetValue;
}

#if 0
/**Function*************************************************************

  Synopsis    [Construct AIG manager from gates.]

  Description []

  SideEffects []

  SeeAlso     []

***********************************************************************/
int Gia_ManConstructFromMap( Gia_Man_t * pNew, Vec_Int_t * vGates, int nVars, Vec_Int_t * vUsed, Vec_Int_t * vCopy, int fHash )
{
    int i, iLit0, iLit1, iLitRes, iTopLit = Vec_IntEntryLast( vGates );
    assert( Vec_IntSize(vUsed) == nVars );
    assert( Vec_IntSize(vGates) > 1 );
    assert( Vec_IntSize(vGates) % 2 == 1 );
    assert( Abc_Lit2Var(iTopLit)-nVars == Vec_IntSize(vGates)/2-1 );
    Vec_IntClear( vCopy );
    Vec_IntForEachEntryDouble( vGates, iLit0, iLit1, i )
    {
        int iVar0 = Abc_Lit2Var(iLit0);
        int iVar1 = Abc_Lit2Var(iLit1);
        int iRes0 = iVar0 < nVars ? Vec_IntEntry(vUsed, iVar0) : Vec_IntEntry(vCopy, iVar0 - nVars);
        int iRes1 = iVar1 < nVars ? Vec_IntEntry(vUsed, iVar1) : Vec_IntEntry(vCopy, iVar1 - nVars);
        if ( iVar0 < iVar1 )
        {
            if ( fHash )
                iLitRes = Gia_ManHashAnd( pNew, Abc_LitNotCond(iRes0, Abc_LitIsCompl(iLit0)), Abc_LitNotCond(iRes1, Abc_LitIsCompl(iLit1)) );
            else
                iLitRes = Gia_ManAppendAnd( pNew, Abc_LitNotCond(iRes0, Abc_LitIsCompl(iLit0)), Abc_LitNo


xF001F001,0xF001F001,0xF001F001,0xFF01F001
	.word 0x01F001F0,0x01F001F0,0x01F001F0,0x01F001F0,0xF001F0FF,0xF001F001,0xF001F001,0xF001F001
	.word 0x01F0FF01,0x01F001F0,0x01F001F0,0x01F001F0,0xF0FF01F0,0xF001F001,0xF001F001,0xF001F001
	.word 0xFF01F001,0x01F001F0,0x01F001F0,0x01F001F0,0x01F001F0,0x6901F0B6,0x059012F0,0xE812F066
	.word 0x0505057F

	.section .rodata
	.align	2
	.global photo_disaster_flattenedPal		@ 32 unsigned chars
	.hidden photo_disaster_flattenedPal
photo_disaster_flattenedPal:
	.hword 0x7C1F,0x6ED3,0x4D69,0x6F7A,0x258F,0x3504,0x3EB2,0x5E0D
	.hword 0x1D9E,0x73DE,0x3355,0x637B,0x3254,0x0000,0x0000,0x0000

@}}BLOCK(photo_disaster_flattened)


<char> value)
        {
            const char nullChar = (char)0x0000;

            int start = 0;
            while (start < value.Length)
            {
                if (!char.IsWhiteSpace(value[start]) && value[start] != nullChar)
                {
                    break;
                }
                start++;
            }

            int end = value.Length - 1;
            while (end >= start)


RangeFunc(context.Background(), 20, 1)
		c.Assert(err, IsNil)

		s.checkDestroyRangeReq(c, sendReqCh, ranges, stores)

		// The first delete range task should be still here since it didn't success.
		se = createSession(s.gcWorker.store)
		remainingRanges, err := loadRangesFunc(se, 20)
		se.Close()
		c.Assert(err, IsNil)
		c.Assert(remainingRanges, DeepEquals, ranges[:1])

		failKey = nil
		failStore = nil

		// Delete the remaining range again.
		err = deleteRangeFunc(context.Background(), 20, 1)
		c.Assert(err, IsNil)
		s.checkDestroyRangeReq(c, sendReqCh, ranges[:1], stores)

		se = createSession(s.gcWorker.store)
		remainingRanges, err = loadRangesFunc(se, 20)
		se.Close()
		c.Assert(err, IsNil)
		c.Assert(len(remainingRanges), Equals, 0)
	}

	test(false)
	// Change the order because the first range is the last successfully deleted.
	ranges = append(ranges[1:], ranges[0])
	test(true)
}

func (s *testGCWorkerSuite) TestDeleteRangesFailure(c *C) {
	s.testDeleteRangesFailureImpl(c, failRPCErr)
	s.testDeleteRangesFailureImpl(c, failNilResp)
	s.testDeleteRangesFailureImpl(c, failErrResp)
}

type SentReq struct {
	req  *tikvrpc.Request
	addr string
}

// checkDestroyRangeReq checks whether given sentReq matches given ranges and stores.
func (s *testGCWorkerSuite) checkDestroyRangeReq(c *C, sendReqCh chan SentReq, expectedRanges []util.DelRangeTask, expectedStores []*metapb.Store) {
	sentReq := make([]SentReq, 0, len(expectedStores)*len(expectedStores))
Loop:
	for {
		select {
		case req := <-sendReqCh:
			sentReq = append(sentReq, req)
		default:
			break Loop
		}
	}

	sort.Slice(sentReq, func(i, j int) bool {
		cmp := bytes.Compare(sentReq[i].req.UnsafeDestroyRange().StartKey, sentReq[j].req.UnsafeDestroyRange().StartKey)
		return cmp < 0 || (cmp == 0 && sentReq[i].addr < sentReq[j].addr)
	})

	sortedRanges := append([]util.DelRangeTask{}, expectedRanges...)
	sort.Slice(sortedRanges, func(i, j int) bool {
		return bytes.Compare(sortedRanges[i].StartKey, sortedRanges[j].StartKey) < 0
	})

	for rangeIndex := range sortedRanges {
		for storeIndex := range expectedStores {
			i := rangeIndex*len(expectedStores) + storeIndex
			c.Assert(sentReq[i].addr, Equals, expectedStores[storeIndex].Address)
			c.Assert(kv.Key(sentReq[i].req.UnsafeDestroyRange().GetStartKey()), DeepEquals,
				sortedRanges[rangeIndex].StartKey)
			c.Assert(kv.Key(sentReq[i].req.UnsafeDestroyRange().GetEndKey()), DeepEquals,
				sortedRanges[rangeIndex].EndKey)
		}
	}
}

type testGCWorkerClient struct {
	tikv.Client
	unsafeDestroyRangeHandler handler
}

type handler = func(addr string, req *tikvrpc.Request) (*tikvrpc.Response, error)

func (c *testGCWorkerClient) SendRequest(ctx context.Context, addr string, req *tikvrpc.Request, timeout time.Duration) (*tikvrpc.Response, error) {
	if req.Type == tikvrpc.CmdUn


coding="async" loading="lazy" width="300" height="424" class="thumbimage multimediaViewerScrollSet" srcset="https://moegirl.icu/media/thumb/23497392.png/450px-23497392.png 1.5x, https://moegirl.icu/media/thumb/23497392.png/600px-23497392.png 2x" data-file-width="1000" data-file-height="1414">

画师ジョンディー所创作的芙兰朵露

目击者报告

有时大大方方地潜入红魔馆，会遇到妹妹。不刺激她的话，能够无事通过。难得我是潜入来的，还是希望她不要出现。（雾雨魔理沙）

真是可怕的自私报告。

那对翼大概飞不起来吧。（博丽灵梦）

的确如此。（×3　没事，大家不是没翅膀也照样飞吗？）

有次去参加红魔馆聚会，一眼瞄到二小姐在馆内徘徊的影子。好可怕。从外形可以辨明，她很少参加聚会呢。（匿名）

像恐怖电影一样。

对策

基本上不会碰到，所以要注意的事也不多。不过须得时刻谨记，红魔馆内是有两名吸血鬼的。

就算姐姐蕾米莉亚不在家，也不能以为馆内没吸血鬼了而潜入进去。

她的能力谜团很多，能破坏到什么程度？有效距离是？有效范围是？等等都不明。<br


 > 3 {
				break
			}
			b0, b2 := bj&mask32, bj>>32

			off := 4 * (i + j)
			buff[off+0] += a0 * b0
			buff[off+1] += a1 * b0
			buff[off+2] += a2*b0 + a0*b2
			buff[off+3] += a3*b0 + a1*b2
			buff[off+4] += a2 * b2
			buff[off+5] += a3 * b2
		}
	}

	for i := uint(1); i < 4; i++ {
		shift := 16 * i

		var head, carry uint64
		for j := uint(0); j < 4; j++ {
			block := 4 * j

			xi := buff[block]
			yi := (buff[block+i] << shift) + head
			zi := xi + yi + carry
			buff[block] = zi
			carry = (xi&yi | (xi|yi)&^zi) >> 63

			head = buff[block+i] >> (64 - shift)
		}
	}

	return [4]uint64{buff[0], buff[4], buff[8], buff[12]}
}

func gfpMul(c, a, b *gfP) {
	T := mul(*a, *b)
	m := halfMul([4]uint64{T[0], T[1], T[2], T[3]}, np)
	t := mul([4]uint64{m[0], m[1], m[2], m[3]}, p2)

	var carry uint64
	for i, Ti := range T {
		ti := t[i]
		zi := Ti + ti + carry
		T[i] = zi
		carry = (Ti&ti | (Ti|ti)&^zi) >> 63
	}

	*c = gfP{T[4], T[5], T[6], T[7]}
	gfpCarry(c, carry)
}
package bn256

func lineFunctionAdd(r, p *twistPoint, q *curvePoint, r2 *gfP2) (a, b, c *gfP2, rOut *twistPoint) {
	// See the mixed addition algorithm from "Faster Computation of the
	// Tate Pairing", http://arxiv.org/pdf/0904.0854v3.pdf
	B := (&gfP2{}).Mul(&p.x, &r.t)

	D := (&gfP2{}).Add(&p.y, &r.z)
	D.Square(D).Sub(D, r2).Sub(D, &r.t).Mul(D, &r.t)

	H := (&gfP2{}).Sub(B, &r.x)
	I := (&gfP2{}).Square(H)

	E := (&gfP2{}).Add(I, I)
	E.Add(E, E)

	J := (&gfP2{}).Mul(H, E)

	L1 := (&gfP2{}).Sub(D, &r.y)
	L1.Sub(L1, &r.y)

	V := (&gfP2{}).Mul(&r.x, E)

	rOut = &twistPoint{}
	rOut.x.Square(L1).Sub(&rOut.x, J).Sub(&rOut.x, V).Sub(&rOut.x, V)

	rOut.z.Add(&r.z, H).Square(&rOut.z).Sub(&rOut.z, &r.t).Sub(&rOut.z, I)

	t := (&gfP2{}).Sub(V, &rOut.x)
	t.Mul(t, L1)
	t2 := (&gfP2{})


d05509bb78f122c">alpha_ptr(nullptr), beta_ptr(nullptr) {

  237

  238     }

  239

  240     CUTLASS_HOST_DEVICE

  241     Params(

  242       ElementCompute const *alpha_ptr,

  243       ElementCompute const *beta_ptr

  244     ): alpha(0), beta(0), alpha_ptr(alpha_ptr), beta_ptr(beta_ptr) {

  245

  246     }

  247   };
<div class


.deathScriptedExplodeDelay) then
			self.deathScriptedExplodeSound:Play(self.Pos);
			self.MissionCritical = false;
			for att in self.Attachables do
				att.MissionCritical = false;
			end

			self.activity:SendMessage("Refinery_RefineryS10FinalBossExploded");

			self:GibThis();

			CameraMan:AddScreenShake(25, self.Pos);
		elseif self.deathScriptedMidBurnDone ~= true and self.deathScriptedTimer:IsPastSimMS(self.deathScriptedMidBurnDelay) then
			self.deathScriptedMidBurnDone = true;
			-- played via BurstSound
			--self.deathScriptedMidBurnSound:Play(self.Pos);

			local offset = Vector(0, -3)

			local emitterB = CreateAEmitter("Browncoat Boss Scripted Death Burn")
			emitterB.InheritedRotAngleOffset = math.pi/2;
			self.Jetpack:AddAttachable(emitterB);

			ToAttachable(emitterB).ParentOffset = offset
		end

		if self.deathScriptedMidBurnDone then
			CameraMan:AddScreenShake(0.8, self.Pos);
		end
	end

	-- DEBUG SHOCKWAVE ABILITY

	local debugTrigger = UInputMan:KeyPressed(Key.O);

	if debugTrigger then
		self.abilityShockwaveTrigger = true;
		self.abilityShockwaveJumpPacked = false;
	end

	if self.abilityShockwaveOngoing then
		if not self.abilityShockwaveJumpPacked and self.abilityShockwaveTimer:IsPastSimMS(self.abilityShockwaveJumpPackDelay) then
			self.abilityShockwaveJumpPacked = true;

			-- Old actual jetpack method
			--self.Jetpack.NegativeThrottleMultiplier = self.jumpPackDefaultNegativeMult * 1.3;
			--self.Jetpack.PositiveThrottleMultiplier = self.jumpPackDefaultPositiveMult * 1.3;

			self.controller:SetState(Controller.BODY_JUMPSTART, true)
			self.controller:SetState(Controller.B


    val stats: Statistics = this.evaluator.evaluate()

      this.logValidationEnd(stats)

      if (stats.accuracy > this.counter.bestAccuracy)
        this.counter.bestAccuracy = stats.accuracy
      else
        bestModel = false
    }

    if (bestModel) {

      this.dumpModel()

      if (this.verbose)
        println("Model saved to \"${this.modelFilename}\"")
    }
  }

  /**
   * Method to call every new epoch.
   * In turn it calls the same method of the [optimizers].
   */
  protected fun newEpoch() {
    this.counter.newEpoch()
    this.optimizers.forEach { it.newEpoch() }
  }

  /**
   * Method to call every new batch.
   * In turn it calls the same method of the [optimizers].
   */
  protected fun newBatch() {
    this.counter.newBatch()
    this.optimizers.forEach { it.newBatch() }
  }

  /**
   * Method to call every new example.
   * In turn it calls the same method of the [optimizers].
   */
  protected fun newExample() {
    this.counter.newExample()
    this.optimizers.forEach { it.newExample() }
  }

  /**
   * Log when training starts.
   */
  private fun logTrainingStart(epochIndex: Int) {

    if (this.verbose) {

      this.timer.reset()

      println("\nEpoch ${epochIndex + 1} of ${this.epochs}")
      println("\nStart training...")
    }
  }

  /**
   * Log when training ends.
   */
  private fun logTrainingEnd() {

    if (this.verbose) {
      println("Elapsed time: %s".format(this.timer.formatElapsedTime()))
    }
  }

  /**
   * Log when validation starts.
   */
  private fun logValidationStart() {

    if (this.verbose) {

      val evaluationExamples: Iterable<ExampleType> = this.evaluator!!.examples

      this.timer.reset()

      if (evaluationExamples is Collection<*>)
        println("\nValidate on ${evaluationExamples.size} examples...")
      else
        println("\nValidate model...")
    }
  }

  /**
   * Log when validation ends.
   *
   * @param stats the evaluation statistics
   */
  private fun logValidationEnd(stats: Statistics) {

    if (this.verbose) {

      println("Elapsed time: %s".format(this.timer.formatElapsedTime()))

      println("\nStatistics:")
      println(stats)

      if (stats.accuracy > this.counter.bestAccuracy)
        println("\nNEW BEST ACCURACY!")
    }
  }
}
/*
 * Copyright 2018-2024 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.ktorm.ksp.compiler.generator

import com.squareup.kotlinpoet.*
import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
import com.squareup.kotlinpoet.ksp.KotlinPoetKspPreview
import com.squareup.kotlinpoet.ksp.toClassName
import org.ktorm.dsl.AliasRemover
import org.ktorm.entity.EntitySequence
import org.ktorm.expression.ColumnAssignmentExpression
import org.ktorm.expression.UpdateExpression
import org.ktorm.ksp.compiler.util._type
import org.ktorm.ksp.spi.TableMetadata

@OptIn(KotlinPoetKspPreview::class)
internal object UpdateFunctionGenerator {

    fun generate(table:


hort[] data = SafeCast.toShortArray(NBTMapper.toTagValue(map.get("data")), null);

		int[] packed = new int[4096];

		for (int i = 0; i < 4096; i++) {
			short d = data == null ? 0 : data[i];
			packed[i] = BlockFullState.getPacked(blocks[i], d);
		}

		// Just use the non-compressed format.  The engine will compress the chunks over time.

		palette = new int[0];
		int[] packetBlockArray = packed;
		int packedWidth = 16;

		map.put(new IntArrayTag("palette", palette));
		map.put(new IntTag("packedWidth", packedWidth));
		map.put(new IntArrayTag("packedBlockArray", packetBlockArray));

		return map;
	}

	/**
	 * Version 3 to version 4 conversion
	 *
	 * Extra field for custom lighting added, so no conversion needed.
	 */
	private static CompoundMap convertV3V4(CompoundMap map) {
		return map;
	}

	/**
	 * Version 3 to version 4 conversion
	 *
	 * Old lighting fields depreciated, so no conversion needed.
	 */
	private static CompoundMap convertV4V5(CompoundMap map) {
		return map;
	}
}
/*
 * This file is part of Spout.
 *
 * Copyright (c) 2011 Spout LLC <http://www.spout.org/>
 * Spout is licensed under the Spout License Version 1.
 *
 * Spout 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.
 *
 * In addition, 180 days after any changes are published, you can use the
 * software, incorporating those changes, under the terms of the MIT license,
 * as described in the Spout License Version 1.
 *
 * Spout 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,
 * the MIT license and the Spout License Version 1 along with this program.
 * If not, see <http://www.gnu.org/licenses/> for the GNU Lesser General Public
 * License and see <http://spout.in/licensev1> for the full license, including
 * the MIT license.
 */
package org.spout.engine.scheduler.parallel;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.spout.api.Spout;
import org.spout.api.geo.cuboid.Region;
import org.spout.api.scheduler.Task;
import org.spout.api.scheduler.TickStage;
import org.spout.engine.scheduler.SpoutTask;
import org.spout.engine.scheduler.SpoutTaskManager;
import org.spout.engine.world.SpoutRegion;

public class ParallelTaskInfo {
	public static final ParallelTaskInfo[] EMPTY_ARRAY = new ParallelTaskInfo[0];
	private final Set<RegionIdPair> children = new HashSet<>();
	private final Map<SpoutRegion, SpoutTask> regions = new HashMap<>();
	private final SpoutTask task;
	private boolean alive = true;

	public ParallelTaskInfo(SpoutTask task) {
		this.task = task;
	}

	public synchronized boolean add(SpoutRegion region) {
		if (regions.containsKey(region)) {
			return false;
		}

		if (!alive) {
			return false;
		}

		SpoutTask newTask = task.getRegionTask(


     {
                name = "q",
                type = "SPFLOAT",
                description ="Q of the filter. sqrt(0.5) is no resonance.",
                default = 0.707
            },
            {
                name = "mode",
                type = "SPFLOAT",
                description ="EQ mode. 0 = peak, 1 = low shelving, 2 = high shelving",
                default = 0
            },
        }
    },

    modtype = "module",

    description = [[Parametric Equalizer
This is an implementation of Zoelzer's parametric equalizer filter.]],

    ninputs = 1,
    noutputs = 1,

    inputs = {
        {
            name = "input",
            description = "Signal input."
        },
    },

    outputs = {
        {
            name = "out",
            description = "Signal output."
        },
    }

}


 reproduce the above copyright notice, this list of conditions and
	the following disclaimer in the documentation and/or other materials provided with the distribution.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
*/

#include "cinder/app/linux/AppImplLinux.h"
#include "cinder/app/linux/AppLinux.h"
#include "cinder/app/linux/WindowImplLinux.h"

#include "cinder/Log.h"

#include <iostream>
#include <unistd.h>

namespace cinder { namespace app {

class GlfwCallbacks {
public:

	static std::map<GLFWwindow*, std::pair<AppImplLinux*,WindowRef>> sWindowMapping;
	static KeyEvent sKeyEvent;
	static bool sCapsLockDown, sNumLockDown, sScrollLockDown;

	static void registerWindowEvents( GLFWwindow *glfwWindow, AppImplLinux* cinderAppImpl, const WindowRef& cinderWindow ) {
		sWindowMapping[glfwWindow] = std::make_pair( cinderAppImpl, cinderWindow );

		::glfwSetWindowSizeCallback( glfwWindow, GlfwCallbacks::onWindowSize );
		::glfwSetWindowPosCallback( glfwWindow, GlfwCallbacks::onWindowMove );
		::glfwSetKeyCallback( glfwWindow, GlfwCallbacks::onKeyboard );
		::glfwSetCharCallback( glfwWindow, GlfwCallbacks::onCharInput );
		::glfwSetCursorPosCallback( glfwWindow, GlfwCallbacks::onMousePos );
		::glfwSetMouseButtonCallback( glfwWindow, GlfwCallbacks::onMouseButton );
		::glfwSetScrollCallback( glfwWindow, GlfwCallbacks::onMouseWheel );
		::glfwSetDropCallback( glfwWindow, GlfwCallbacks::onFileDrop );
	}

	static void unregisterWindowEvents( GLFWwindow *glfwWindow ) {
		sWindowMapping.erase( glfwWindow );
	}

	static void onError( int error, const char* description ) {
		std::cout << "(glfw:error): error=" << error << ", desc=" << description << std::endl;
	}

	static void onWindowSize( GLFWwindow* glfwWindow, int width, int height ) {
		auto iter = sWindowMapping.find( glfwWindow );
		if( sWindowMapping.end() != iter ) {
			auto& cinderAppImpl = iter->second.first;
			auto& cinderWindow = iter->second.second;
			cinderAppImpl->setWindow( cinderWindow );

			cinderWindow->emitResize();
		}
	}

	static void onWindowMove( GLFWwindow* glfwWindow, int xpos, int ypos ) {
		auto iter = sWindowMapping.find( glfwWindow );
		if( sWindowMapping.end() != iter ) {
			auto& cinderAppImpl = iter->second.first;
			auto& cinderWindow = iter->second.second;
			cinderAppImpl->setWindow( cinderWindow );

			cinderWindow->emitMove();
		}
	}

	//! Translates GLFW \a mods into ci::KeyEvent modifier values
	static int extractKeyModifiers( int mods )
	{
		uint32_t modifiers = 0;
		if( mods & GLFW_MOD_SHIFT ) {
			modifiers |= KeyEvent::SHIFT_DOWN;
		}
		if


background-position:-199px -39px}.jstree-default-dark-small .jstree-checkbox-disabled{opacity:.8;filter:url("data:image/svg+xml;utf8,<svg xmlns=\'http://www.w3.org/2000/svg\'><filter id=\'jstree-grayscale\'><feColorMatrix type=\'matrix\' values=\'0.3333 0.3333 0.3333 0 0 0.3333 0.3333 0.3333 0 0 0.3333 0.3333 0.3333 0 0 0 0 0 1 0\'/></filter></svg>#jstree-grayscale");filter:gray;-webkit-filter:grayscale(100%)}.jstree-default-dark-small>.jstree-striped{background-size:auto 36px}.jstree-default-dark-small.jstree-rtl .jstree-node{background-image:url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAACAQMAAAB49I5GAAAABlBMVEUAAAAdHRvEkCwcAAAAAXRSTlMAQObYZgAAAAxJREFUCNdjAAMOBgAAGAAJMwQHdQAAAABJRU5ErkJggg==");background-position:100% 1px;background-repeat:repeat-y}.jstree-default-dark-small.jstree-rtl .jstree-last{background:transparent}.jstree-default-dark-small.jstree-rtl .jstree-open>.jstree-ocl{background-position:-135px -39px}.jstree-default-dark-small.jstree-rtl .jstree-closed>.jstree-ocl{background-position:-103px -39px}.jstree-default-dark-small.jstree-rtl .jstree-leaf>.jstree-ocl{background-position:-71px -39px}.jstree-default-dark-small.jstree-rtl>.jstree-no-dots .jstree-node,.jstree-default-dark-small.jstree-rtl>.jstree-no-dots .jstree-leaf>.jstree-ocl{background:transparent}.jstree-default-dark-small.jstree-rtl>.jstree-no-dots .jstree-open>.jstree-ocl{background-position:-39px -39px}.jstree-default-dark-small.jstree-rtl>.jstree-no-dots .jstree-closed>.jstree-ocl{background-position:-7px -39px}.jstree-default-dark-small .jstree-themeicon-custom{background-color:transparent;background-image:none;background-position:0 0}.jstree-default-dark-small>.jstree-container-ul .jstree-loading>.jstree-ocl{background:url("throbber.gif") center center no-repeat}.jstree-default-dark-small .jstree-file{background:url("32px.png") -103px -71px no-repeat}.jstree-default-dark-small .jstree-folder{background:url("32px.png") -263px -7px no-repeat}.jstree-default-dark-small>.jstree-container-ul>.jstree-node{margin-left:0;margin-right:0}#jstree-dnd.jstree-default-dark-small{line-height:18px;padding:0 4px}#jstree-dnd.jstree-default-dark-small .jstree-ok,#jstree-dnd.jstree-default-dark-small .jstree-er{background-image:url("32px.png");background-repeat:no-repeat;background-color:transparent}#jstree-dnd.jstree-default-dark-small i{background:transparent;width:18px;height:18px;line-height:18px}#jstree-dnd.jstree-default-dark-small .jstree-ok{background-position:-7px -71px}#jstree-dnd.jstree-default-dark-small .jstree-er{ba


reEqual(cloudOrganizationValue, parsedArgs[cloudOrganizationKey]);

            Assert.IsTrue(parsedArgs.ContainsKey(accessTokenKey));
            Assert.AreEqual(accessTokenValue, parsedArgs[accessTokenKey]);
        }
    }
}


ent, function to call, arguments to pass, and frequency
 *	  of the event.
 * Output: None
 * Side Effects: Adds the event to the event list within +- 1/3 of the
 *	         specified frequency.
 */
struct ev_entry *
rb_event_addish(const char *name, EVH * func, void *arg, time_t delta_ish)
{
	if(delta_ish >= 3.0)
	{
		const time_t two_third = (2 * delta_ish) / 3;
		delta_ish = two_third + ((rand() % 1000) * two_third) / 1000;
		/*
		 * XXX I hate the above magic, I don't even know if its right.
		 * Grr. -- adrian
		 */
	}
	return rb_event_add(name, func, arg, delta_ish);
}

void
rb_run_event(struct ev_entry *ev)
{
	rb_strlcpy(last_event_ran, ev->name, sizeof(last_event_ran));
	ev->func(ev->arg);
	if(!ev->frequency)
	{
		rb_io_unsched_event(ev);
		rb_dlinkDelete(&ev->node, &event_list);
		rb_free(ev);
		return;
	}
	ev->when = rb_current_time() + ev->frequency;
	if((ev->when < event_time_min) || (event_time_min == -1))
		event_time_min = ev->when;
}

/*
 * void rb_event_run(void)
 *
 * Input: None
 * Output: None
 * Side Effects: Runs pending events in the event list
 */
void
rb_event_run(void)
{
	rb_dlink_node *ptr, *next;
	struct ev_entry *ev;

	if(rb_io_supports_event())
		return;

	event_time_min = -1;
	RB_DLINK_FOREACH_SAFE(ptr, next, event_list.head)
	{
		ev = ptr->data;
		if(ev->when <= rb_current_time())
		{
			rb_strlcpy(last_event_ran, ev->name, sizeof(last_event_ran));
			ev->func(ev->arg);

			/* event is scheduled more than once */
			if(ev->frequency)
			{
				ev->when = rb_current_time() + ev->frequency;
				if((ev->when < event_time_min) || (event_time_min == -1))
					event_time_min = ev->when;
			}
			else
			{
				rb_dlinkDelete(&ev->node, &event_list);
				rb_free(ev);
			}
		}
		else
		{
			if((ev->when < event_time_min) || (event_time_min == -1))
				event_time_min = ev->when;
		}
	}
}

void
rb_event_io_register_all(void)
{
	rb_dlink_node *ptr;
	struct ev_entry *ev;

	if(!rb_io_supports_event())
		return;

	RB_DLINK_FOREACH(ptr, event_list.head)
	{
		ev = ptr->data;
		rb_io_sched_event(ev, ev->next);
	}
}

/*
 * void rb_event_init(void)
 *
 * Input: None
 * Output: None
 * Side Effects: Initializes the event system.
 */
void
rb_event_init(void)
{
	rb_strlcpy(last_event_ran, "NONE", sizeof(last_event_ran));
}

void
rb_dump_events(void (*func) (char *, void *), void *ptr)
{
	int len;
	char buf[512];
	rb_dlink_node *dptr;
	struct ev_entry *ev;
	len = sizeof(buf);

	rb_snprintf(buf, len, "Last event to run: %s", last_event_ran);
	func(buf, ptr);

	rb_strlcpy(buf, "Operation                    Next Execution", len);
	func(buf, ptr);

	RB_DLINK_FOREACH(dptr, event_list.head)
	{
		ev = dptr->data;
		rb_snprintf(buf, len, "%-28s %-4ld seconds", ev->name,
			    ev->when - (long)rb_current_time());
		func(buf, ptr);
	}
}

/*
 * void rb_set_back_events(time_t by)
 * Input: Time to set back events by.
 * Output: None.
 * Side-effects: Sets back all events by "by" seconds.
 */
void
rb_set_back_events(time_t by)
{
	rb_dlink_node *ptr;
	struct ev_entry *ev;
	RB_DLINK_FOREACH(ptr, event_list.head)
	{
		ev = ptr->data;
		if(ev->when > by)
			ev->when -= by;
		else
			ev->when = 0;
	}
}

void
rb_event_update(struct ev_entry *ev, time_t freq)
{
	if(ev == NULL)
		return;

	ev->frequency = freq;

	/* update when its scheduled to run if its higher
	 * than the new frequency
	 */
	if((rb_current_time() + freq) < ev->when)
		ev->when = rb_current_time() + freq;
	return;
}

time_t
rb_event_next(void)
{
	return event_time_min;
}


ap = map[UICommandStatusDisplayTyp]string{
	0: "STATUS",
	1: "WARNING",
	2: "ERROR",
}

func (e UICommandStatusDisplayTyp) String() string {
	if v, ok := UICommandStatusDisplayTypRevMap[e]; ok {
		return v
	}
	return fmt.Sprintf("%v", int(e))
}

type UICommandStatusActionTyp int

const (
	UICommandStatusActionTyp_APPSETTINGS UICommandStatusActionTyp = 0
)

func (o UICommandStatusActionTyp) DeepCopy() UICommandStatusActionTyp { return o }

var UICommandStatusActionTypMap = map[string]UICommandStatusActionTyp{
	"APPSETTINGS": 0,
}

var UICommandStatusActionTypRevMap = map[UICommandStatusActionTyp]string{
	0: "APPSETTINGS",
}

func (e UICommandStatusActionTyp) String() string {
	if v, ok := UICommandStatusActionTypRevMap[e]; ok {
		return v
	}
	return fmt.Sprintf("%v", int(e))
}

type UIBotCommandsUpdateStatusTyp int

const (
	UIBotCommandsUpdateStatusTyp_UPTODATE UIBotCommandsUpdateStatusTyp = 0
	UIBotCommandsUpdateStatusTyp_UPDATING UIBotCommandsUpdateStatusTyp = 1
	UIBotCommandsUpdateStatusTyp_FAILED   UIBotCommandsUpdateStatusTyp = 2
	UIBotCommandsUpdateStatusTyp_BLANK    UIBotCommandsUpdateStatusTyp = 3
)

func (o UIBotCommandsUpdateStatusTyp) DeepCopy() UIBotCommandsUpdateStatusTyp { return o }

var UIBotCommandsUpdateStatusTypMap = map[string]UIBotCommandsUpdateStatusTyp{
	"UPTODATE": 0,
	"UPDATING": 1,
	"FAILED":   2,
	"BLANK":    3,
}

var UIBotCommandsUpdateStatusTypRevMap = map[UIBotCommandsUpdateStatusTyp]string{
	0: "UPTODATE",
	1: "UPDATING",
	2: "FAILED",
	3: "BLANK",
}

func (e UIBotCommandsUpdateStatusTyp) String() string {
	if v, ok := UIBotCommandsUpdateStatusTypRevMap[e]; ok {
		return v
	}
	return fmt.Sprintf("%v", int(e))
}

type UIBotCommandsUpdateSettings struct {
	Settings map[string]keybase1.TeamBotSettings `codec:"settings" json:"settings"`
}

func (o UIBotCommandsUpdateSettings) DeepCopy() UIBotCommandsUpdateSettings {
	return UIBotCommandsUpdateSettings{
		Settings: (func(x map[string]keybase1.TeamBotSettings) map[string]keybase1.TeamBotSettings {
			if x == nil {
				return nil
			}
			ret := make(map[string]keybase1.TeamBotSettings, len(x))
			for k, v := range x {
				kCopy := k
				vCopy := v.DeepCopy()
				ret[kCopy] = vCopy
			}
			return ret
		})(o.Settings),
	}
}

type UIBotCommandsUpdateStatus struct {
	Typ__      UIBotCommandsUpdateStatusTyp `codec:"typ" json:"typ"`
	Uptodate__ *UIBotCommandsUpdateSettings `codec:"uptodate,omitempty" json:"uptodate,omitempty"`
}

func (o *UIBotCommandsUpdateStatus) Typ() (ret UIBotCommandsUpdateStatusTyp, err error) {
	switch o.Typ__ {
	case UIBotCommandsUpdateStatusTyp_UPTODATE:
		if o.Uptodate__ == nil {
			err = errors.New("unexpected nil value for Uptodate__")
			return ret, err
		}
	}
	return o.Typ__, nil
}

func (o UIBotCommandsUpdateStatus) Uptodate() (res UIBotCommandsUpdateSettings) {
	if o.Typ__ != UIBotCommandsUpdateStatus


BY_POT, ActionVector.stdCaller, ActionTweak.randByMultiply(ActionVector.from(0.0, 1, 1, 1))),
    TN_HU_IP_CALLER_VS_RAISE_OC_1(PokerSituation.TN_HU_IP_CALLER_VS_RAISE, FeatureSchema.ACTION, FeatureSchema.DIFF_AMOUNT_BY_POT, ActionVector.stdCaller),
    TN_HU_IP_CALLER_VS_RAISE_OC_1_A(PokerSituation.TN_HU_IP_CALLER_VS_RAISE, FeatureSchema.ACTION, FeatureSchema.DIFF_AMOUNT_BY_POT, ActionVector.stdCaller),
    TN_HU_IP_CALLER_VS_RAISE_OC_1_A_FD(PokerSituation.TN_HU_IP_CALLER_VS_RAISE, FeatureSchema.ACTION, FeatureSchema.DIFF_AMOUNT_BY_POT, ActionVector.stdCaller),
    TN_HU_IP_CALLER_VS_RAISE_OC_1_A_SD(PokerSituation.TN_HU_IP_CALLER_VS_RAISE, FeatureSchema.ACTION, FeatureSchema.DIFF_AMOUNT_BY_POT, ActionVector.stdCaller),
    TN_HU_IP_CALLER_VS_RAISE_OC_1_FD(PokerSituation.TN_HU_IP_CALLER_VS_RAISE, FeatureSchema.ACTION, FeatureSchema.DIFF_AMOUNT_BY_POT, ActionVector.stdCaller),
    TN_HU_IP_CALLER_VS_RAISE_OC_1_SD(PokerSituation.TN_HU_IP_CALLER_VS_RAISE, FeatureSchema.ACTION, FeatureSchema.DIFF_AMOUNT_BY_POT, ActionVector.stdCaller),
    TN_HU_IP_CALLER_VS_RAISE_OC_2(PokerSituation.TN_HU_IP_CALLER_VS_RAISE, FeatureSchema.ACTION, FeatureSchema.DIFF_AMOUNT_BY_POT, ActionVector.stdCaller),
    TN_HU_IP_CALLER_VS_RAISE_OC_2_AX(PokerSituation.TN_HU_IP_CALLER_VS_RAISE, FeatureSchema.ACTION, FeatureSchema.DIFF_AMOUNT_BY_POT, ActionVector.stdCaller),
    TN_HU_IP_CALLER_VS_RAISE_OC_2_AX_FD(PokerSituation.TN_HU_IP_CALLER_VS_RAISE, FeatureSchema.ACTION, FeatureSchema.DIFF_AMOUNT_BY_POT, ActionVector.stdCaller),
    TN_HU_IP_CALLER_VS_RAISE_OC_2_AX_SD(PokerSituation.TN_HU_IP_CALLER_VS_RAISE, FeatureSchema.ACTION, FeatureSchema.DIFF_AMOUNT_BY_POT, ActionVector.stdCaller),
    TN_HU_IP_CALLER_VS_RAISE_OC_2_FD(PokerSituation.TN_HU_IP_CALLER_VS_RAISE, FeatureSchema.ACTION, FeatureSchema.DIFF_AMOUNT_BY_POT, ActionVector.stdCaller),
    TN_HU_IP_CALLER_VS_RAISE_OC_2_SD(PokerSituation.TN_HU_IP_CALLER_VS_RAISE, FeatureSchema.ACTION, FeatureSchema.DIFF_AMOUNT_BY_POT, ActionVector.stdCaller),
    TN_HU_IP_CALLER_VS_RAISE_OVER_PAIR(PokerSituation.TN_HU_IP_CALLER_VS_RAISE, FeatureSchema.ACTION, FeatureSchema.DIFF_AMOUNT_BY_POT, ActionVector.stdCaller),
    TN_HU_IP_CALLER_VS_RAISE_OVER_PAIR_AKQ(PokerSituation.TN_HU_IP_CALLER_VS_RAISE, FeatureSchema.ACTION, FeatureSchema.DIFF_AMOUNT_BY_POT, ActionVector.stdCaller),
    TN_HU_IP_CALLER_VS_RAISE_SECOND_PAIR_GK(PokerSit


            player.setAllowFlight(false);
            player.setFlying(false);
        });

        announcer.sendGlobalTitle(Title.title(
                gameMiniMessage.deserialize("<gold><bold>TRIDENT RACE"),
                gameMiniMessage.deserialize("<gray>Get ready!"),
                Title.Times.times(
                        Duration.ofMillis(0),
                        Duration.ofMillis(2000),
                        Duration.ofMillis(1000)
                )
        ));

        announcer.sendGlobalSound(Sound.ENTITY_PLAYER_LEVELUP, 0.5F, 0.5F);

        announcer.sendGlobalMessage("&a▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬", true);
        announcer.sendGlobalMessage("&f&lTrident Race", true);
        announcer.sendGlobalMessage("&0 ", false);
        announcer.sendGlobalMessage("&e&lShoot the target that will appear in front of", true);
        announcer.sendGlobalMessage("&e&lyou before your opponent does", true);
        announcer.sendGlobalMessage("&e&lThe first talent to reach 20 points wins!", true);
        announcer.sendGlobalMessage("&0 ", true);
        announcer.sendGlobalMessage("&a▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬", true);

        // The task constructor has the setPreLobby(true) func
        tridentMatchProperties.setPreLobbyTaskId(
                Bukkit.getScheduler().runTaskTimer(tridentMiniGame.getKaelaEvent(), new TridentPreLobbyTask(this), 0L, 20L).getTaskId()
        );
        setState(TridentMatchState.ARENA_STARTING);
    }

    public void postStart() {
        // Cancel the previous task
        tridentMatchProperties.setPreLobby(false);
        Bukkit.getScheduler().cancelTask(tridentMatchProperties.getPreLobbyTaskId());

        tridentMatchProperties.setArenaTickTaskId(
                Bukkit.getScheduler().runTaskTimer(getTridentMiniGame().getKaelaEvent(), new TridentTickTask(this), 0L, 1L).getTaskId()
        );

        announcer.sendGlobalMessage("&eShoot your tridents!", false);
        announcer.sendGlobalTitle(Title.title(
                gameMiniMessage.deserialize("<gold><bold>START!"),
                Component.empty(),
                Title.Times.times(
                        Duration.ofMillis(0),
                        Duration.ofMillis(1000),
                        Duration.ofMillis(500)
                )
        ));
        announcer.sendGlobalSound(Sound.ENTITY_FIREWORK_ROCKET_BLAST, 2.0F, 2.0F);

        spawnTarget();

        setState(TridentMatchState.GAME);
    }

    public void stop() {
        setState


.testGroups.filter(e => e.pass).length.toString()} pass, ${suite.testGroups.length.toString()} total`);
    console.log(chalk`  [Result]: ${result}`);
    console.log(chalk` [Summary]: ${successCount.toString()} pass, ${(count - successCount).toString()} fail, ${count.toString()} total`);
    console.log(chalk`    [Time]: ${suite.time.toString()}ms`);
    console.log("");
  }
  public onTodo(_group: TestGroup, todo: string): void {
    console.log(chalk`    {yellow [Todo]:} ${todo}`);
  }

  /**
   * A custom logger function for the default reporter that writes the log values using `console.log()`
   *
   * @param {LogValue} logValue - A value to be logged to the console
   */
  public onLog(logValue: LogValue): void {
    // create string representations of the pointer
    var pointer: string = logValue.pointer.toString();
    var hexPointer: string = logValue.pointer.toString(16);

    // log the log message
    if (logValue.pointer > 0) {
      console.log(chalk`     {yellow [Log]:} Reference at address [${pointer}] [hex: 0x${hexPointer}] ${logValue.message}`);
    } else {
      console.log(chalk`     {yellow [Log]:} ${logValue.message}`);
    }

    // if there are bytes to show, create a logging representation of the bytes
    if (logValue.bytes.length > 0) {
      const value = createReferenceString(logValue.bytes, logValue.pointer, logValue.offset);
      console.log(chalk`            {blueBright ${value.split("\n").join("\n            ")}}`);
    }

    console.log(chalk`        {yellow ${logValue.stack.split("\n").join("\n        ")}}\n`);
  }
}

export default class EmitListener {
  _ttl;
  _callback;

  constructor(callback, ttl = -1) {
    this._ttl = ttl;       // -1 means forever
    this._callback = callback;
  }

  deductLife(){
    if(this._ttl > 0) this._ttl -= 1
  };

  isAlive(){
    return this._ttl !== 0
  };

  apply(context, arr){
    return this._callback.apply(context, arr)
  };

  call(context){
    var args = new Array(arguments.length);
    for(var i=1; i<arguments.length; i++) args[i] = arguments[i];
    return this._callback.apply(context, args)
  };

}

import { BasePrepare } from "./BasePrepare";
import { BaseTexture } from "flash/display3D/textures/BaseTexture";

export class CanvasPrepare extends BasePrepare
{
    public static CANVAS_START_SIZE = 16;
    /**
     * @param {PIXI.CanvasRenderer} renderer - A reference to the current renderer
     */
    public canvas:any;
    public ctx:any;

    constructor(renderer)
    {
        super(renderer);

        // CanvasRenderer.registerPlugin('prepare', CanvasPrepare);

        this.uploadHookHelper = this;

        /**
        * An offline canvas to render textures to
        * @type {HTMLCanvasElement}
        * @private
        */
        this.canvas = document.createElement('canvas');
        this.canvas.width = CanvasPrepare.CANVAS_START_SIZE;
        this.canvas.height = CanvasPrepare.CANVAS_START_SIZE;

        /**
         * The context to the canvas
        * @type {CanvasRenderingContext2D}
        * @private


지휘관, 보너스에 과자 없는지 빨리 확인해!",
		headtouch = "",
		feeling2 = "밥인가!?",
		feeling4 = "지휘관 때문에 또 동생들이 비웃었어! 어떻게 할 거야! 머리 쓰다듬는 정도론── 에헤헤……(문질문질) 용서해…… 에헤헤…… 안 해줄 거다……",
		unlock = "시라츠유형 4번함인 유다치라고 한다. 말해두겠는데, 밤엔 시끄러우니까 마음의 준비는 하고 있으라구.",
		battle = "오오오! 싸움이라면 봐주지 않겠어!",
		login = "아우, 지휘관……「손」이라니!? 얕보는 거냐!?",
		vote = "",
		detail = "아우? ……뭐야?",
		couple_encourage = {}
	},
	[301141] = {
		touch = "시라츠유, 시구레, 눈싸움하자!",
		feeling3 = "",
		upgrade = "",
		expedition = "",
		win_mvp = "",
		home = "",
		mission = "",
		touch2 = "",
		feeling1 = "",
		skill = "",
		drop_descrip = "지휘관, 집무실에 틀어박혀있지 마! 따뜻한 곳에만 있으면 몸이 녹슬어버린다고! 밖으로 나가 놀자!",
		mail = "",
		lose = "",
		propose = "",
		hp_warning = "",
		id = 301141,
		voice_key = 0,
		feeling5 = "",
		main = "방 안은 따뜻해, 잠이 온다고……우으, 지휘관……고기……맛있어……|오우! 지휘관에게 화력을 집중해라! 이 눈싸움은 우리 승리다!|지휘관, 겨울엔 역시 전골이지! 전골? 전골!",
		voice_key_2 = -1,
		profile = "",
		mission_complete = "",
		headtouch = "",
		feeling2 = "",
		feeling4 = "",
		unlock = "지휘관, 집무