n(code, ...)
            print("Ethersync connection error: ", code, vim.inspect({ ... }))
        end,
        on_exit = function(code, _)
            if code == 0 then
                vim.schedule(function()
                    vim.api.nvim_err_writeln(
                        "Connection to Ethersync daemon lost. Probably it crashed or was stopped. Please restart the daemon, then Neovim."
                    )
                    -- TODO: Enable writing here again, so that user can make backup of file?
                end)
            else
                print(
                    "Could not connect to Ethersync daemon. Did you start it (in "
                        .. directory
                        .. ")? To stop trying, remove the .ethersync/ directory."
                )
            end
        end,
    }

    local connection
    local extra_spawn_params = { cwd = directory }

    if vim.version().api_level < 12 then
        -- In Neovim 0.9, the API was to pass the command and its parameters as two arguments.
        local params = {}
        for i = 2, #cmd do
            table.insert(params, cmd[i])
        end
        ---@diagnostic disable-next-line: redundant-parameter
        connection = vim.lsp.rpc.start(executable, params, dispatchers, extra_spawn_params)
    else
        -- While in Neovim 0.10, it is combined into one table.
        connection = vim.lsp.rpc.start(cmd, dispatchers, extra_spawn_params)
    end

    print("Connected to Ethersync daemon!")

    local result = { connection = connection }
    setmetatable(result, { __index = Connection })
    return result
end

return M


/* Runtime ABI for the ARM Cortex-M0
 * lmul.S: 64 bit multiplication
 *
 * Copyright (c) 2013 Jörg Mische <bobbl@gmx.de>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 * OF OR IN CONNECTION WITH


/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the QtEnginio module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL21$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** As a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#ifndef ENGINIOCLIENT_GLOBAL_H
#define ENGINIOCLIENT_GLOBAL_H

#include <QtCore/qglobal.h>

#if defined(QT_SHARED) || !defined(QT_STATIC)
#  if defined(ENGINIOCLIENT_LIBRARY)
#    define ENGINIOCLIENT_EXPORT Q_DECL_EXPORT
#  else
#    define ENGINIOCLIENT_EXPORT Q_DECL_IMPORT
#  endif
#else
#  define ENGINIOCLIENT_EXPORT
#endif

QT_BEGIN_NAMESPACE
ENGINIOCLIENT_EXPORT extern bool gEnableEnginioDebugInfo;
QT_END_NAMESPACE

#endif // ENGINIOCLIENT_GLOBAL_H


PAGE
	ldr	x16, [x16, ___blue_glCore_glCopyImageSubData@GOTPAGEOFF]
	ldr	x16, [x16]
	br	x16

.private_extern _bluegl_glFramebufferParameteri
	.align	2
_bluegl_glFramebufferParameteri:
	adrp	x16, ___blue_glCore_glFramebufferParameteri@GOTPAGE
	ldr	x16, [x16, ___blue_glCore_glFramebufferParameteri@GOTPAGEOFF]
	ldr	x16, [x16]
	br	x16

.private_extern _bluegl_glGetFramebufferParameteriv
	.align	2
_bluegl_glGetFramebufferParameteriv:
	adrp	x16, ___blue_glCore_glGetFramebufferParameteriv@GOTPAGE
	ldr	x16, [x16, ___blue_glCore_glGetFramebufferParameteriv@GOTPAGEOFF]
	ldr	x16, [x16]
	br	x16

.private_extern _bluegl_glGetInternalformati64v
	.align	2
_bluegl_glGetInternalformati64v:
	adrp	x16, ___blue_glCore_glGetInternalformati64v@GOTPAGE
	ldr	x16, [x16, ___blue_glCore_glGetInternalformati64v@GOTPAGEOFF]
	ldr	x16, [x16]
	br	x16

.private_extern _bluegl_glInvalidateTexSubImage
	.align	2
_bluegl_glInvalidateTexSubImage:
	adrp	x16, ___blue_glCore_glInvalidateTexSubImage@GOTPAGE
	ldr	x16, [x16, ___blue_glCore_glInvalidateTexSubImage@GOTPAGEOFF]
	ldr	x16, [x16]
	br	x16

.private_extern _bluegl_glInvalidateTexImage
	.align	2
_bluegl_glInvalidateTexImage:
	adrp	x16, ___blue_glCore_glInvalidateTexImage@GOTPAGE
	ldr	x16, [x16, ___blue_glCore_glInvalidateTexImage@GOTPAGEOFF]
	ldr	x16, [x16]
	br	x16

.private_extern _bluegl_glInvalidateBufferSubData
	.align	2
_bluegl_glInvalidateBufferSubData:
	adrp	x16, ___blue_glCore_glInvalidateBufferSubData@GOTPAGE
	ldr	x16, [x16, ___blue_glCore_glInvalidateBufferSubData@GOTPAGEOFF]
	ldr	x16, [x16]
	br	x16

.private_extern _bluegl_glInvalidateBufferData
	.align	2
_bluegl_glInvalidateBufferData:
	adrp	x16, ___blue_glCore_glInvalidateBufferData@GOTPAGE
	ldr	x16, [x16, ___blue_glCore_glInvalidateBufferData@GOTPAGEOFF]
	ldr	x16, [x16]
	br	x16

.private_extern _bluegl_glInvalidateFramebuffer
	.align	2
_bluegl_glInvalidateFramebuffer:
	adrp	x16, ___blue_glCore_glInvalidateFramebuffer@GOTPAGE
	ldr	x16, [x16, ___blue_glCore_glInvalidateFramebuffer@GOTPAGEOFF]
	ldr	x16, [x16]
	br	x16

.private_extern _bluegl_glInvalidateSubFramebuffer
	.align	2
_bluegl_glInvalidateSubFramebuffer:
	adrp	x16, ___blue_glCore_glInvalidateSubFramebuffer@GOTPAGE
	ldr	x16, [x16, ___blue_glCore_glInvalidateSubFramebuffer@GOTPAGEOFF]
	ldr	x16, [x16]
	br	x16

.private_extern _bluegl_glMultiDrawArraysIndirect
	.align	2
_bluegl_glMultiDrawArraysI


ur continued support and patience. The wait will be worth it.

Warm regards,<br/>
Gerasimos (Makis) Maropoulos

### This is the last release for the version 12 family.

- Security improvements and dependencies upgrade.

- New `Application/Party.MiddlewareExists(handlerNameOrHandler)` method added, example:

```go
package main

import (
	"fmt"

	"github.com/kataras/iris/v12"
	"github.com/kataras/iris/v12/x/errors"
)

func main() {
	app := iris.New()

	app.UseRouter(errors.RecoveryHandler)

	if app.MiddlewareExists(errors.RecoveryHandler) { // <- HERE.
		fmt.Println("errors.RecoveryHandler exists")
	}
	// OR:
	// if app.MiddlewareExists("iris.errors.recover") {
	// 	fmt.Println("Iris.Errors.Recovery exists")
	// }

	app.Get("/", indexHandler)

	app.Listen(":8080")
}

func indexHandler(ctx iris.Context) {
	panic("an error here")
	ctx.HTML("<h1>Index</h1>")
}

```
- New `x/errors.Intercept(func(ctx iris.Context, req *CreateRequest, resp *CreateResponse) error{ ... })` package-level function.

```go
func main() {
    app := iris.New()

    // Create a new service and pass it to the handlers.
    service := new(myService)

    app.Post("/", errors.Intercept(responseHandler), errors.CreateHandler(service.Create))

    // [...]
}

func responseHandler(ctx iris.Context, req *CreateRequest, resp *CreateResponse) error {
    fmt.Printf("intercept: request got: %+v\nresponse sent: %#+v\n", req, resp)
    return nil
}
```

- Rename `x/errors/ContextValidator.ValidateContext(iris.Context) error` to `x/errors/RequestHandler.HandleRequest(iris.Context) error`.

# Thu, 18 Jan 2024 | v12.2.10

- Simplify the `/core/host` subpackage and remove its `DeferFlow` and `RestoreFlow` methods. These methods are replaced with: `Supervisor.Configure(host.NonBlocking())` before `Serve` and ` Supervisor.Wait(context.Context) error` after `Serve`.
- Fix internal `trimHandlerName` and other minor stuff.
- New `iris.NonBlocking()` configuration option to run the server without blocking the main routine, `Application.Wait(context.Context) error` method can be used to block and wait for the server to be up and running. Example:

```go
func main() {
    app := iris.New()
    app.Get("/", func(ctx iris.Context) {
        ctx.Writef("Hello, %s!", "World")
    })

    app.Listen(":8080", iris.NonBlocking(), iris.WithoutServerError(iris.ErrServerClosed))

    ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
    defer cancel()

    if err := app.Wait(ctx); err != nil {
        log.Fatal(err)
    }


f0e167a-4060-54a4-8d51-9ce722941003"
	m["/sex-dance-hyperdimension-neptunia-lupin/"] = "70f17b9e-eae9-556b-bdee-79b5c6ee7af0"
	m["/sarablonde-live-the-highlights-part-2/"] = "2bdcf584-80b7-533c-b5ca-7993df313471"
	m["/bombshell/"] = "380c3d90-5b42-5a8e-b1c9-0bc87680af7b"
	m["/breakfast-surprise/"] = "48f51f69-8ee1-5ead-bb91-08e8436536c0"
	m["/the-witcher-yennefers-gift/"] = "6cdfcad3-fc1b-5106-8cf2-c876482cf9fa"
	m["/blondie-rose-episode-7/"] = "266fee63-46a4-54bb-9220-f60b12814460"
	m["/shemale-in-the-pink/"] = "84cf95d0-dfca-543e-8901-0875d7e66052"
	m["/taste-my-red-lips/"] = "31cbe41a-c95f-583f-ad9c-141334c8a244"
	m["/behind-the-scenes-huge-boob-blowjob/"] = "45a68df2-863f-55ae-8807-2a09555a5422"
	m["/444-viktoria/"] = "120eb945-973e-5928-9f56-92b4246c4ccb"
	m["/patient-in-use/"] = "815cc54c-d616-57b6-bb37-4e0db8ea0a97"
	m["/fun-on-the-couch-arina-shy/"] = "1628c4ac-ee8c-5652-8287-7be0a40b2e3a"
	m["/putting-the-d-in-diversity/"] = "80f01829-8ab7-5a73-8a2e-a49678690b7c"
	m["/up-close-vr-with-kylie-le-beau/"] = "0590e0be-a7d8-5d67-9cdf-1ea92544821f"
	m["/stepdaughter-lawyer-vr-threesome-kinky-surprise/"] = "d35f9656-7806-536c-b3d6-b4baee5f5fc6"
	m["/teen-schoolgirl-fucks-her-teacher-to-pass-class/"] = "27860062-9874-5bbc-a9da-8b8f5a7b929a"
	m["/hot-lexi-get-fucked-hard/"] = "215cd09f-0bb7-5214-8596-0fc51cccefc2"
	m["/gangbang-seduction-of-step-sister/"] = "a060126c-b638-537c-99fd-dab2f53b4717"
	m["/art-appreciation-in-nyc/"] = "3226b302-57bb-5add-aa29-c40532a8598e"
	m["/bang-bribe-for-test-pass/"] = "9e466a82-1463-5c97-ac26-1d956f02787a"
	m["/good-time/"] = "7516cc0f-19f8-56a0-a324-adc96a26f358"
	m["/vrmansions-blowjob-compilation-2/"] = "787c7cf4-c4cd-5a25-b9a5-34e62bc9388d"
	m["/


recursos derivados de la capitalización de la institución, la garantía se liberaría y los accionistas
no resultarían afectados en forma alguna. Así, el procedimiento propuesto mantiene operando a
la institución en protección de los intereses del público ahorrador, de la estabilidad y solvencia de
otras instituciones y entidades financieras y, en última instancia, del sistema financiero en
general y, además, conserva la operación del sistema de pagos.
Por otra parte, se respeta el derecho de los accionistas a efectuar aportaciones adicionales al
capital de la institución y, con esto, conservar el control de ella. Más aún, para el caso de
adjudicación de las acciones por falta de pago del referido crédito otorgado por el Instituto para
la Protección al Ahorro Bancario, el régimen que esta Iniciativa contempla da lugar a la
posibilidad de que se les restituya el valor contable de sus acciones. Con ello, se pretende lograr
un equilibrio en los bienes jurídicos antes descritos; es decir, por un lado, se toman en
consideración los derechos de los accionistas al proporcionarles instancias que les permitan
mantener a la institución o, en última instancia, no sufrir un perjuicio en el valor que representen
las acciones de las que hayan sido titulares y, por el otro, la seguridad de los ahorros del público,
la continuidad en el funcionamiento de los sistemas de pagos y la estabilidad del sistema
financiero en su conjunto.
5. Inter vención y Administrador Cautelar de REFR#3062 Instituciones de Banca Múltiple.
En la presente Iniciativa se proponen adecuaciones a la facultad de la REFR#3063 Comisión Nacional Bancaria
y de Valores de decretar la intervención respecto de REFR#3064 instituciones de banca múltiple. Para esto,
se plantea la desaparición de la intervención administrativa, mientras que, por lo que se refiere a
la intervención gerencial, se contemplan algunos ajustes. En primer término, se consideró
Insurgentes Sur No. 1971, Plaza Inn, Col. Guadalupe Inn C.P. 01020, Delegación Álvaro Obregón,
Ciudad de México Tel.: 5255 1454-6000 ww.gob.mx/cnbv

conveniente definir algunos supuestos específicos que darían lugar a la intervención por parte de
la REFR#3065 Comisión Nacional Bancaria y de Valores. Ello, con el objeto de brindar mayor seguridad
jurídica a las REFR#3066 instituciones de banca múltiple y al sistema en general, bajo la premisa siempre
presente de salvaguardar los intereses del público ahorrador.
Los supuestos que la presente Iniciativa propone actualizar como aquellos por los que la
REFR#3067 Comisión Nacional Bancaria y de Valores decretará la intervención consisten, por un lado, en que,
en


ploy, error) {
	ret := _m.Called(ctx, userID)

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

	var r0 []database.Deploy
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int64) ([]database.Deploy, error)); ok {
		return rf(ctx, userID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int64) []database.Deploy); ok {
		r0 = rf(ctx, userID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]database.Deploy)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, int64) error); ok {
		r1 = rf(ctx, userID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetRunningDeployByUserID is a helper method to define mock.On call
//   - ctx context.Context
//   - userID int64
func (_e *MockDeployTaskStore_Expecter) GetRunningDeployByUserID(ctx interface{}, userID interface{}) *MockDeployTaskStore_GetRunningDeployByUserID_Call {
	return &MockDeployTaskStore_GetRunningDeployByUserID_Call{Call: _e.mock.On("GetRunningDeployByUserID", ctx, userID)}
}

func (_c *MockDeployTaskStore_GetRunningDeployByUserID_Call) Run(run func(ctx context.Context, userID int64)) *MockDeployTaskStore_GetRunningDeployByUserID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64))
	})
	return _c
}

func (_c *MockDeployTaskStore_GetRunningDeployByUserID_Call) Return(_a0 []database.Deploy, _a1 error) *MockDeployTaskStore_GetRunningDeployByUserID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockDeployTaskStore_GetRunningDeployByUserID_Call) RunAndReturn(run func(context.Context, int64) ([]database.Deploy, error)) *MockDeployTaskStore_GetRunningDeployByUserID_Call {
	_c.Call.Return(run)
	return _c
}

// GetServerlessDeployByRepID provides a mock function with given fields: ctx, repoID
func (_m *MockDeployTaskStore) GetServerlessDeployByRepID(ctx context.Context, repoID int64) (*database.Deploy, error) {
	ret := _m.Called(ctx, repoID)

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

	var r0 *database.Deploy
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int64) (*database.Deploy, error)); ok {
		return rf(ctx, repoID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int64) *database.Deploy); ok {
		r0 = rf(ctx, repoID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*database.Deploy)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, int64) error); ok {
		r1 = rf(


g, jsxInlineConfig: InlineConfig[] = []) {
	if (!node) {
		return node;
	}

	return ts.visitEachChild(
		visitNode(node, context, cfg),
		(childNode) => {
			if (!childNode) {
				return childNode;
			}

			let inlineCfg = parseInlineConfig(childNode);

			if (!inlineCfg) {
				if (ts.isJsxElement(childNode)) {
					inlineCfg = jsxInlineConfig.pop();
				}
			} else if (inlineCfg.isJSXExpr) {
				jsxInlineConfig.push(inlineCfg);
				inlineCfg = null;
			}

			if (inlineCfg) {
				useNormalizeText = inlineCfg.normalize !== 'false';
				inlineCfg.context && phrasesContext.unshift(inlineCfg.context);
			} else {
				useNormalizeText = true;
			}

			const result = visitNodeAndChildren(childNode, context, cfg);

			if (inlineCfg) {
				inlineCfg.context && phrasesContext.shift();
			}

			return result;
		},
		context,
	);
}

function isTagName(name: string) {
	return R_IS_TAG.test(name);
}

function jsxTagToObject(
	node: ts.JsxElement | ts.JsxSelfClosingElement,
	context: object,
	cfg: Config,
) {
	const element = normJsxElement(node);
	const {attributes} = element;

	let type = element.tagName.getFullText();
	let props: ts.ObjectLiteralElementLike[] = [];

	attributes.properties.forEach(prop => {
		if (ts.isJsxAttribute(prop)) {
			const {initializer} = prop;
			let name = prop.name.getText();
			let value: ts.Expression;

			if (initializer) {
				if (cfg.isTranslatableJsxAttribute(prop, element) && cfg.isHumanText(prop.getText(), node)) {
					if (ts.isJsxExpression(initializer)) {
						if (ts.isTemplateExpression(initializer.expression)) {
							value = wrapTemplateExpression(initializer.expression, context, cfg);
						} else {
							value = ts.createIdentifier(initializer.getText().slice(1, -1));
						}
					} else {
						value = wrapStringLiteral(initializer, cfg) as ts.Expression;
					}
				} else {
					value = ts.isJsxExpression(initializer) ? initializer.expression : initializer;
				}
			} else {
				value = ts.createIdentifier('true');
			}

			props.push(ts.createPropertyAssignment(
				stringifyObjectKey(name),
				value,
			));
		} else if (ts.isJsxSpreadAttribute(prop)) {
			// log();
			props.push(ts.createSpreadAssignment(prop.expression));
		}
	});

	return ts.createObjectLiteral([
		ts.createPropertyAssignment(
			'type',
			isTagName(type) ? ts.createIdentifier(`"${type}"`) : element.tagName,
		),
		ts.createPropertyAssignment(
			'props',
			props.length ? ts.createObjectLiteral(props) : ts.createNull(),
		),
	]);
}

function checkPatterFile(this: Config, mask: string) {
	return this.fileName.match(mask) !== null;
}

const R_IS_SIMPLE_OBJ_KEY = /^[a-z\d_]+$/i;
function stringifyObjectKey(name: string) {
	return R_IS_SIMPLE_OBJ_KEY.test(name) ? name : JSON.stringify(name)
}

export type TXConfig = Partial<Pick<Config,
	| 'textFnName'
	| 'jsxFnName'
	| 'packageName'


ස්කරණ මෙවලම් තීරුව"},"elementspath":{"eleLabel":"මුලද්‍රව්‍ය මාර්ගය","eleTitle":"%1 මුල"},"find":{"find":"Find","findOptions":"Find Options","findWhat":"Find what:","matchCase":"Match case","matchCyclic":"Match cyclic","matchWord":"Match whole word","notFoundMsg":"The specified text was not found.","replace":"හිලව් කිරීම","replaceAll":"සියල්ලම හිලව් කරන්න","replaceSuccessMsg":"%1 occurrence(s) replaced.","replaceWith":"Replace with:","title":"Find and Replace"},"fakeobjects":{"anchor":"ආධාරය","flash":"Flash Animation","hiddenfield":"සැඟවුණු ප්‍රදේශය","iframe":"IFrame","unknown":"Unknown Object"},"flash":{"access":"පිටපත් ප්‍රවේශය","accessAlways":"හැමවිටම","accessNever":"කිසිදා නොවේ","accessSameDomain":"එකම වසමේ","alignAbsBottom":"පතුල","alignAbsMiddle":"Abs ","alignBaseline":"පාද රේඛාව","alignTextTop":"වගන්තිය ඉහල","bgcolor":"පසුබිම් වර්ණය","chkFull":"පුර්ණ තිරය සදහා අවසර","chkLoop":"පුඩුව","chkMenu":"සක්‍රිය බබලන මෙනුව","chkPlay":"ස්‌වයංක්‍රිය ක්


ield.type.chpl__deserialize2(data[0]);
 *      this.field = deserializedField;
 *    }
 *    else {
 *      var deserializedField = this.field.type.chpl__deserialize2(data[0]);
 *      this.field = &deserializedField;
 *    }
 *    return ret;
 *  }
 *
 *  proc on_fn(... rvfData ...) {
 *    var deserialized = chpl__deserialize1(rvfData);
 *
 *    ...
 *
 *    autoDestroy(deserialized);
 *  }
 *
 *  After:
 *  ------
 *
 *  proc type chpl__deserialize1(data, newArgRef) {
 *    var ret: this;
 *    this.field = newArgRef;
 *    return ret;
 *  }
 *
 *  proc on_fn(... rvfData ...) {
 *    var deserializedField = this.field.type.chpl__deserialize2(rvfData[0]);
 *    ref newArgRef = &deserializedField;
 *    var deserialized = chpl__deserialize1(rvfData, newArgRef);
 *
 *    ...
 *
 *    autoDestroy(deserializedField);
 *    autoDestroy(deserialized);
 *  }
 *
 *  Roughly the changes are:
 *  - The thenStmt of the conditional is hoisted from inside chpl__deserialize1
 *    to the on_fn
 *  - The result of this sub-deserialization is passed by reference to the main
 *    deserializer.
 *  - This ref is directly assigned to the field inside the main deserializer.
 *
 */
static CallExpr* handleRefDeserializers(Expr* anchor, FnSymbol* fn,
                                        FnSymbol* baseDeserializeFn,
                                        Symbol* arg) {

  // if no changes are necessary, we'll just return this
  CallExpr* baseCall = new CallExpr(baseDeserializeFn, arg);

  if (regularDeserializers.count(baseDeserializeFn) == 1) {
    return baseCall;
  }

  FnSymbol* deserializeFn = baseDeserializeFn->copy();
  CallExpr* modifiedCall = new CallExpr(deserializeFn, arg);

  bool modified = false;
  for_alist (stmt, deserializeFn->body->body) {
    if (CondStmt* cond = toCondStmt(stmt)) {
      SymExpr* flagExpr = toSymExpr(cond->condExpr);
      if (flagExpr->symbol()->hasFlag(FLAG_DESERIALIZATION_BLOCK_MARKER)) {
        if (!modified) {
          modified = true;
          baseDeserializeFn->defPoint->insertBefore(new DefExpr(deserializeFn));
        }

        // Phase 1: figure out which field we are deserializing for
        bool useThenBlock = true;
        CallExpr* setMemberCall = NULL;
        Type* fieldType = NULL;
        for_alist_backward (innerStmt, cond->elseStmt->body) {
          if (CallExpr* call = toCallExpr(innerStmt)) {
            if (call->isPrimitive(PRIM_SET_MEMBER)) {
              setMemberCall = call;

              SymExpr* field = toSymExpr(call->get(2));
              INT_ASSERT(field);

              if (field->symbol()->isRef()) {
                useThenBlock = false;
                fieldType = field->symbol()->type;
                break;
              }
              else {
                useThenBlock = true;
                break;
              }
            }
          }
        }

        // Phase 2: Choose val or ref deserialization
        if (useThenBlock) {
          // Phase 2a: We are not doing ref deserialization for this
          // field. Put all the statements in the `then` block in before the
          // conditional. The conditional will be discarded later.
          for_alist (stmt, cond->thenStmt->body) {
            cond->insertBefore(stmt->remove());
          }
        }
        else {
          // Phase 2b: We are doing ref deserialization


e *prog;
	struct clk *clk = NULL;
	struct clk_init_data init;

	if (id > PROG_ID_MAX)
		return ERR_PTR(-EINVAL);

	prog = kzalloc(sizeof(*prog), GFP_KERNEL);
	if (!prog)
		return ERR_PTR(-ENOMEM);

	init.name = name;
	init.ops = &programmable_ops;
	init.parent_names = parent_names;
	init.num_parents = num_parents;
	init.flags = CLK_SET_RATE_GATE | CLK_SET_PARENT_GATE;

	prog->id = id;
	prog->layout = layout;
	prog->hw.init = &init;
	prog->pmc = pmc;

	clk = clk_register(NULL, &prog->hw);
	if (IS_ERR(clk))
		kfree(prog);

	return clk;
}

static const struct clk_programmable_layout at91rm9200_programmable_layout = {
	.pres_shift = 2,
	.css_mask = 0x3,
	.have_slck_mck = 0,
};

static const struct clk_programmable_layout at91sam9g45_programmable_layout = {
	.pres_shift = 2,
	.css_mask = 0x3,
	.have_slck_mck = 1,
};

static const struct clk_programmable_layout at91sam9x5_programmable_layout = {
	.pres_shift = 4,
	.css_mask = 0x7,
	.have_slck_mck = 0,
};

static void __init
of_at91_clk_prog_setup(struct device_node *np, struct at91_pmc *pmc,
		       const struct clk_programmable_layout *layout)
{
	int num;
	u32 id;
	int i;
	struct clk *clk;
	int num_parents;
	const char *parent_names[PROG_SOURCE_MAX];
	const char *name;
	struct device_node *progclknp;

	num_parents = of_count_phandle_with_args(np, "clocks", "#clock-cells");
	if (num_parents <= 0 || num_parents > PROG_SOURCE_MAX)
		return;

	for (i = 0; i < num_parents; ++i) {
		parent_names[i] = of_clk_get_parent_name(np, i);
		if (!parent_names[i])
			return;
	}

	num = of_get_child_count(np);
	if (!num || num > (PROG_ID_MAX + 1))
		return;

	for_each_child_of_node(np, progclknp) {
		if (of_property_read_u32(progclknp, "reg", &id))
			continue;

		if (of_property_read_string(np, "clock-output-names", &name))
			name = progclknp->name;

		clk = at91_clk_register_programmable(pmc, name,
						     parent_names, num_parents,
						     id, layout);
		if (IS_ERR(clk))
			continue;

		of_clk_add_provider(progclknp, of_clk_src_simple_get, clk);
	}
}

void __init of_at91rm9200_clk_prog_setup(struct device_node *np,
					 struct at91_pmc *pmc)
{
	of_at91_clk_prog_setup(np, pmc, &at91rm9200_programmable_layout);
}

void __init of_at91sam9g45_clk_prog_setup(struct device_node *np,
					  struct at91_pmc *pmc)
{
	of_at91_clk_prog_setup(np, pmc, &at91sam9g45_programmable_layout);
}

void __init of_at91sam9x5_clk_prog_setup(struct device_node *np,
					 struct at91_pmc *pmc)
{
	of_at91_clk_prog_setup(np, pmc, &at91sam9x5_programmable_layout);
}


,4.27l4.08,1.88l2.51-0.01l4.31-1.17l1.08-1.69l-12.75-4.77L555.46,204.16L555.46,204.16z" stroke="#818181" stroke-width="1" stroke-linecap="round" stroke-linejoin="round" stroke-opacity="0.25" fill="#f4f3f0" original="#f4f3f0" id="jqvmap1_ge" class="jqvmap-region"></path><path d="M569.72,209.89l4.8,6.26l-1.41,1.65l-3.4-0.59l-4.22-3.78l0.23-2.48L569.72,209.89L569.72,209.89z" stroke="#818181" stroke-width="1" stroke-linecap="round" stroke-linejoin="round" stroke-opacity="0.25" fill="#f4f3f0" original="#f4f3f0" id="jqvmap1_am" class="jqvmap-region"></path><path d="M571.41,207.72l-1.01,1.72l4.71,6.18l1.64-0.53l2.7,2.83l1.17-4.96l2.93,0.47l-0.12-1.42l-4.82-4.22l-0.92,2.48L571.41,207.72L571.41,207.72z" stroke="#818181" stroke-width="1" stroke-linecap="round" stroke-linejoin="round" stroke-opacity="0.25" fill="#f4f3f0" original="#f4f3f0" id="jqvmap1_az" class="jqvmap-region"></path><path d="M569.65,217.95l-1.22,1.27l0.12,2.01l1.52,2.13l5.39,5.9l-0.82,2.36h-0.94l-0.47,2.36l3.05,3.9l2.81,0.24l5.63,7.79l3.16,0.24l2.46,1.77l0.12,3.54l9.73,5.67h3.63l2.23-1.89l2.81-0.12l1.64,3.78l10.51,1.46l0.31-3.86l3.48-1.26l0.16-1.38l-2.77-3.78l-6.17-4.96l3.24-2.95l-0.23-1.3l-4.06-0.63l-1.72-13.7l-0.2-3.15l-11.01-4.21l-4.88,1.1l-2.73,3.35l-2.42-0.16l-0.7,0.59l-5.39-0.35l-6.8-4.96l-2.53-2.77l-1.16,0.28l-2.09,2.39L569.65,217.95L569.65,217.95z" stroke="#818181" stroke-width="1" stroke-linecap="round" stroke-linejoin="round" stroke-opacity="0.25" fill="#f4f3f0" original="#f4f3f0" id="jqvmap1_ir" class="jqvmap-region"></path><path d="M558.7,209.19l-2.23,2.36l-8.2-0.24l-4.92-2.95l-4.8-0.12l-5.51,3.9l-5.16,0.24l-0.47,2.95h-5.86l-2.34,2.13v1.18l1.41,1.18v1.3l-0.59,1.54l0.59,1.3l1.88-0


next().await {
            match socket_res {
                Ok(mut socket) => {
                    let mut buf:Vec<u8> = Vec::new();
                    let mut total_buffer_read = 0u32;

                    loop {
                        let mut buff = [0u8; 64];
                        let n = socket.read(&mut buff).await.unwrap();
                        total_buffer_read += n as u32;

                        if n == 0 {
                            break
                        } else {
                            println!("Partial data ... {:?} bytes", n);
                            buf.append(&mut buff.to_vec());
                        }
                    }

                    println!("Read all data ... {:?} bytes", String::from_utf8(buf[0..(total_buffer_read as usize)].to_vec()).unwrap().len());
                }
                Err(err) => {
                    println!("accept error = {:?}", err);
                }
            }
        }
    };

    println!("Server running on localhost:6142");

    server.await;
}
<reponame>RobWalt/rustgym
struct Solution;

impl Solution {
    fn num_trees(n: i32) -> i32 {
        let n = n as usize;
        let mut dp: Vec<i32> = vec![0; n + 1];
        dp[0] = 1;
        dp[1] = 1;
        for i in 2..=n {
            for j in 0..i {
                dp[i] += dp[j] * dp[i - 1 - j];
            }
        }
        dp[n]
    }
}

#[test]
fn test() {
    let n = 3;
    let res = 5;
    assert_eq!(Solution::num_trees(n), res);
}
use headers::HeaderMapExt;
use http::{Request, Response};

use crate::body::Body;
use crate::util::{dav_method, DavMethod};
use crate::DavResult;

impl crate::DavInner {
    pub(crate) async fn handle_options(&self, req: &Request<()>) -> DavResult<Response<Body>> {
        let mut res = Response::new(Body::empty());

        let h = res.headers_mut();

        // We could simply not report webdav level 2 support if self.allow doesn't
        // contain LOCK/UNLOCK. However we do advertise support, since there might
        // be LOCK/UNLOCK support in another part of the URL space.
        let dav = "1,2,3,sabredav-partialupdate";
        h.insert("DAV", dav.parse().unwrap());
        h.insert("MS-Author-Via", "DAV".parse().unwrap());
        h.typed_insert(headers::ContentLength(0));

        // Helper to add method to array if method is in fact
        // allowed. If the current method is not OPTIONS, leave
        // out the current method since we're probably called
        // for DavMethodNotAllowed.
        let method = dav_method(req.method()).unwrap_or(DavMethod::Options);
        let islock = |m| m == DavMethod::Lock || m == DavMethod::Unlock;
        let mm = |v: &mut Vec<String>, m: &str, y: DavMethod| {
            if (y == DavMethod::Options || (y != method || islock(y) != islock(method))) &&
                (!islock(y) || self.ls.is_some()) &&
                self.allow.map(|x| x.contains(y)).unwrap_or(true)
            {
                v.push(m.to_string());
            }
        };

        let path = self.path(&req);
        let meta = self.fs.metadata(&path).await;
        let is_unmapped = meta.is_err();
        let is_file = meta.and_then(|m| Ok(m.is_file())).unwrap_or_default();
        let is_star = path.is_star() && method == DavMethod::O


_compile_fail,
        has_output,
        features,
        workspace,
    };

    let manifest = make_manifest(crate_name, &project, tests)?;
    if let Some(enabled_features) = &mut project.features {
        enabled_features.retain(|f| manifest.features.contains_key(f));
    }

    Ok((project, manifest))
}

fn make_manifest(
    crate_name: String,
    project: &Project,
    tests: &[Test],
) -> Result<Manifest> {
    let source_manifest = dependencies::get_manifest(&project.source_dir);
    let workspace_manifest = dependencies::get_workspace_manifest(&project.workspace);

    let features = source_manifest
        .features
        .keys()
        .map(|feature| {
            let enable = format!("{}/{}", crate_name, feature);
            (feature.clone(), vec![enable])
        })
        .collect();

    let mut manifest = Manifest {
        package: Package {
            name: project.name.clone(),
            version: "0.0.0".to_owned(),
            edition: source_manifest.package.edition,
            publish: false,
        },
        features,
        dependencies: Map::new(),
        bins: Vec::new(),
        workspace: Some(Workspace {}),
        // Within a workspace, only the [patch] and [replace] sections in
        // the workspace root's Cargo.toml are applied by Cargo.
        patch: workspace_manifest.patch,
        replace: workspace_manifest.replace,
    };

    manifest.dependencies.extend(source_manifest.dependencies);
    manifest
        .dependencies
        .extend(source_manifest.dev_dependencies);
    manifest.dependencies.insert(
        crate_name,
        Dependency {
            version: None,
            path: Some(project.source_dir.clone()),
            default_features: false,
            features: Vec::new(),
            rest: Map::new(),
        },
    );

    manifest.bins.push(Bin {
        name: Name(project.name.to_owned()),
        path: Path::new("main.rs").to_owned(),
    });

    for (i, test) in tests.iter().enumerate() {
        manifest.bins.push(Bin {
            name: Name(Test::gen_name(i)),
            path: project.source_dir.join(&test.path),
        });
    }

    Ok(manifest)
}

#[derive(Deserialize)]
pub struct Metadata {
    pub target_directory: PathBuf,
    pub workspace_root: PathBuf,
}

fn raw_cargo() -> Command {
    Command::new(option_env!("CARGO").unwrap_or("cargo"))
}

fn cargo(project: &Project) -> Command {
    let mut cmd = raw_cargo();
    cmd.current_dir(&project.dir);
    cmd.env("CARGO_TARGET_DIR", &project.target_dir);
    rustflags::set_env(&mut cmd);
    cmd
}

pub fn build_dependencies(project: &Project) -> Result<()> {
    let status = cargo(project)
        .arg(if project.has_pass || project.has_output { "build" } else { "check" })
        .arg("--bin")
        .arg(&project.name)
        .status()
        .map_err(Error::Cargo)?;

    if status.success() {
        Ok(())
    } else {
        Err(Error::CargoFail)
    }
}

pub fn build_test(project: &Project, name: &str) -> Result<Output> {
    let _ = cargo(project)
        .arg("clean")
        .arg("--package")
        .arg(&project.name)
        .arg("--color=never")
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        .status();

    ca


packet.writeBoolean(this.exhausted);
		packet.writeBoolean(this.imposingPenalty);
		packet.writeInt(this.staminaType);
		packet.writeInt(this.consumeOnServer);
		packet.writeLong(this.playerID.getMostSignificantBits());
		packet.writeLong(this.playerID.getLeastSignificantBits());
	}

	public static SyncStaminaMessage decode(PacketBuffer packet) {
		SyncStaminaMessage message = new SyncStaminaMessage();
		message.stamina = packet.readInt();
		message.max = packet.readInt();
		message.exhausted = packet.readBoolean();
		message.imposingPenalty = packet.readBoolean();
		message.staminaType = packet.readInt();
		message.consumeOnServer = packet.readInt();
		message.playerID = new UUID(packet.readLong(), packet.readLong());
		return message;
	}

	@OnlyIn(Dist.DEDICATED_SERVER)
	public void handleServer(Supplier<NetworkEvent.Context> contextSupplier) {
		contextSupplier.get().enqueueWork(() -> {
			ServerPlayerEntity player;
			player = contextSupplier.get().getSender();
			ParCool.CHANNEL_INSTANCE.send(PacketDistributor.ALL.noArg(), this);
			if (player == null) return;
			IStamina stamina = IStamina.get(player);
			if (stamina == null) return;
			if (stamina instanceof OtherStamina) {
				((OtherStamina) stamina).setMax(this.max);
				((OtherStamina) stamina).setImposingPenalty(imposingPenalty);
			}
			if (staminaType != -1 && consumeOnServer > 0) {
				IStamina.Type.values()[staminaType].handleConsumeOnServer(player, consumeOnServer);
			}
			stamina.set(this.stamina);
			stamina.setExhaustion(exhausted);
		});
		contextSupplier.get().setPacketHandled(true);
	}

	@OnlyIn(Dist.CLIENT)
	public void handleClient(Supplier<NetworkEvent.Context> contextSupplier) {
		contextSupplier.get().enqueueWork(() -> {
			ServerPlayerEntity serverPlayer = null;
			PlayerEntity player;
			if (contextSupplier.get().getDirection().getReceptionSide() == LogicalSide.CLIENT) {
				World world = Minecraft.getInstance().level;
				if (world == null) return;
				player = world.getPlayerByUUID(playerID);
				if (player == null || player.isLocalPlayer()) return;
			} else {
				player = serverPlayer = contextSupplier.get().getSender();
				ParCool.CHANNEL_INSTANCE.send(PacketDistributor.ALL.noArg(), this);
				if (player == null) return;
			}
			IStamina stamina = IStamina.get(player);
			if (stamina == null) return;
			if (stamina instanceof OtherStamina) {
				((OtherStamina) stamina).setMax(this.max);
				((OtherStamina) stamina).setImposingPenalty(imposingPenalty);
			}
			if (serverPlayer != null && staminaType != -1 && consumeOnServer > 0) {
				IStamina.Type.values()[staminaType].handleConsumeOnServer(serverPlayer, consumeOnServer);
			}
			stamina.set(this.stamina);
			stamina.setExhaustion(exhausted);
		});
		contextSupplier.get().setPacketHandled(true);
	}

	@OnlyIn(Dist.CLIENT)
	public static void sync(PlayerEntity player) {
		IStamina stamina = IStamina.get(player);
		if (stamina == null || !player.isLocalPlayer()) return;

		SyncStaminaMessage message = new SyncStaminaMessage();
		message.stamina = stamina.get();
		message.max = stamina.ge


ins for documentation and sanity checks only.
// Changing these will not change the pin they are on.

// Hardware UART pins
#define UART1_TX_PIN                        PA9   // default uses CH340 RX
#define UART1_RX_PIN                        PA10  // default uses CH340 TX
#define UART2_TX_PIN                        PA2   // default uses HEATER_BED_PIN
#define UART2_RX_PIN                        PA3   // not connected
#define UART3_TX_PIN                        PB10  // default uses LCD connector
#define UART3_RX_PIN                        PB11  // default uses LCD connector
#define UART4_TX_PIN                        PC10  // default uses sdcard SDIO_D2
#define UART4_RX_PIN                        PC11  // default uses sdcard SDIO_D3
#define UART5_TX_PIN                        PC12  // default uses sdcard SDIO_CK
#define UART5_RX_PIN                        PD2   // default uses sdcard SDIO_CMD

// SDIO pins
#define SDIO_D0_PIN                         PC8
#define SDIO_D1_PIN                         PC9
#define SDIO_D2_PIN                         PC10
#define SDIO_D3_PIN                         PC11
#define SDIO_CK_PIN                         PC12
#define SDIO_CMD_PIN                        PD2

//
// M3/M4/M5 - Spindle/Laser Control
//
#if HAS_CUTTER
  //#define HEATER_0_PIN                    -1
  //#define HEATER_BED_PIN                  -1
  #if DISABLED(CV_LASER_MODULE)
    #define FAN0_PIN                        -1
  #endif
  #define SPINDLE_LASER_ENA_PIN             PC0   // FET 1
  #define SPINDLE_LASER_PWM_PIN             PC0   // Bed FET
  #define SPINDLE_DIR_PIN                   PC0   // FET 4
  #define LASER_SOFT_PWM_PIN                PC0
#endif


including sub directories),
 starting from a given directory (root directory).
 If the file is found, it is pushed into an array. otherwise continue search through recursion.
*/

export const retrieveAllFilesFromDirectories = (
  directory: string,
  filePathArray: string[]
): string[] => {
  const filesOrDirectories: string[] = readdirSync(directory);

  filesOrDirectories.forEach((fileOrDirectory: string) => {
    const filePath: string = resolve(directory, fileOrDirectory);

    if (statSync(filePath).isDirectory())
      filePathArray = retrieveAllFilesFromDirectories(filePath, filePathArray);
    else {
      if (filePath) filePathArray.push(filePath);
    }
  });

  return filePathArray;
};import yaml from 'js-yaml';

export const parseMatch = (yamlPayload: string) => {
  return yaml.load(yamlPayload);
};

export const aggregateRunsForPowerPlay = (inningsDeliveries: any) => {
  const powerPlayDeliveries = inningsDeliveries.filter((d: any) => parseFloat(Object.keys(d)[0]) < 6.1);
  const powerPlayRuns = powerPlayDeliveries.map((d: any) => Object.values(d)[0]);

  return powerPlayRuns
    .map((d: any) => d['runs']['total'])
    .reduce((agg: number, runs: number) => {
      agg = agg + runs;
      return agg;
    }, 0);
};

export const powerPlayRuns = (match: any) => {
  const firstInnings = match.innings[0]['1st innings'];
  // Handle case if there was a washout
  const secondInnings = (match.innings[1] || { '2nd innings': { deliveries: [] } })['2nd innings'];

  const firstInningsDeliveries = firstInnings['deliveries'];
  const secondInningsDeliveries = secondInnings['deliveries'];

  return {
    firstInnings: { team: firstInnings['team'], runs: aggregateRunsForPowerPlay(firstInningsDeliveries) },
    secondInnings: { team: secondInnings['team'], runs: aggregateRunsForPowerPlay(secondInningsDeliveries) }
  };
};
// Resolving data types chain:
// -> typeMapping (int, float ... to TypedArray)
// -> nativeStructs (vector, color32 ..)
// -> File Structs
// -> throw Error "type not found"

const textDecoder = new TextDecoder();
const textEncoder = new TextEncoder();

export class BinaryFile {

    static async fetch(path) {
        return fetch(path).then(async res => {
            if(res.status == 200) {
                const dataArray = await res.arrayBuffer();
                return new this(dataArray);
            } else {
                throw new Error('Status: ' + res.status);
            }
        });
    }

    static get STRUCT() {
        return {};
    }

    constructor(buffer) {
        if(buffer) {
            const file = this.constructor.createFile(buffer);
            this.constructor.parseFile(file);
            return file;
        }
    }

    get size() {
        return this.buffer.byteLength;
    }

    get type() {
        return 'application/octet-stream';
    }

    get buffer() {
        return this.view.buffer;
    }

    async arrayBuffer() {
        return this.view.buffer;
    }

    static getTypeBytelength(type) {
        return typeMapping[type] ? typeMapping[type].BYTES_PER_ELEMENT : 0;
    }

    static getValue(struct, key) {
        return (struct.data || struct)[key].valueOf();
    }

    static parseFile(binaryFile) {
        // unserialize content
    }

    static fromDataArray(dataArray) {
        console.warn('[Depricated] use of "fromDataArray"');
        return new this(dataArray);
    }

    static createFile(dataArray) {

        if(dataArray instanceof ArrayBuffer) {
            const file = new this();
            file.view = new DataView(dataArray);
            return file;


n
        filterRepository.saveAll(List.of(Filter.of(filterName, FilterType.COMPANY.getName())));
        List<Filter> filters = filterService.findAllFilters();

        // then
        assertSoftly(softly -> {
            softly.assertThat(filters.size()).isEqualTo(1);
            softly.assertThat(filters.get(0).getName()).isEqualTo(filterName);
        });
    }

    @Test
    void 필터를_저장한다() {
        // given
        FiltersRequest filtersRequest = new FiltersRequest(
                List.of(
                        new FilterRequest(FilterType.COMPANY.getName(), "충전소 회사"),
                        new FilterRequest(FilterType.CAPACITY.getName(), "2"),
                        new FilterRequest(FilterType.CONNECTOR_TYPE.getName(), "DC_COMBO")
                )
        );

        // when
        filterService.addFilters(admin.getId(), filtersRequest);

        // then
        List<Filter> filters = filterService.findAllFilters();
        assertThat(filters).hasSize(3);
    }

    @Test
    void 필터를_제거한다() {
        // given
        FiltersRequest filtersRequest = new FiltersRequest(
                List.of(
                        new FilterRequest(FilterType.COMPANY.getName(), "충전소 회사"),
                        new FilterRequest(FilterType.CAPACITY.getName(), "2"),
                        new FilterRequest(FilterType.CONNECTOR_TYPE.getName(), "DC_COMBO")
                )
        );

        filterService.addFilters(admin.getId(), filtersRequest);

        // when
        filterService.deleteFilterByName(admin.getId(), "충전소 회사");

        // then
        List<Filter> filters = filterService.findAllFilters();
        assertThat(filters).hasSize(2);
    }

    @Test
    void 차량에_필터를_적용한다() {
        // given
        Car savedCar = carRepository.save(createCar());
        filterRepository.saveAll(List.of(new Filter("HG", FilterType.COMPANY)));
        String filterName = "HG";
        FiltersRequest request = new FiltersRequest(
                List.of(new FilterRequest(FilterType.COMPANY.getName(), filterName))
        );

        // when
        List<Filter> result = filterService.addCarFilters(admin.getId(), savedCar.getId(), request);

        // then
        assertSoftly(softly -> {
            softly.assertThat(result.size()).isEqualTo(1);
            softly.assertThat(result.get(0).getName()).isEqualTo(filterName);
        });
    }

    @Test
    void 어드민이_아니면_차량에_필터를_적용하지_못한다() {
        // given
        Car savedCar = carRepository.save(createCar());
        FiltersRequest request = new FiltersRequest(
                List.of(new FilterRequest(FilterType.COMPANY.getName(), "HG"))
        );

        // when & then
        assertThatThrownBy(() -> filterService.addCarFilters(member.getId(), savedCar.getId(), request))
                .isInstanceOf(AdminException.class)
                .hasMessage(AdminExceptionType.NOT_ADMIN.message());
    }

    @Test
    void 회원이_등록한_모든_필터를_찾는다() {
        // given
        List<MemberFilter> memberFilters = memberFilterRepository.saveAll(
                List.of(new MemberFilter(member, Filter.of("DC_COMBO", FilterType.CONNECTOR_TYPE.getName())))
        );

        // when
        List<Filter> result = filterService.findMemberFilters(member.getId(), member.getId());

        // then
        assertThat(memberFilters.get(0).getFilter()).isEqualTo(result.


 tileWidth * 2,
      top: viewport.top - tileHeight * 2,
      bottom: viewport.bottom + tileHeight * 2
    };

    // 检查角色是否在视口内的函数
    const isInViewport = (character) => {
      // 室内人物由所在建筑物决定可见性
      if (character.isIndoor) {
        return character.sprite && character.sprite.visible;
      }

      // 室外人物根据位置判断是否在视口内
      return character.x >= viewportBounds.left &&
        character.x <= viewportBounds.right &&
        character.y >= viewportBounds.top &&
        character.y <= viewportBounds.bottom;
    };

    // 预先筛选需要更新的角色
    const visibleCharacters = gameStore.characters.filter(char => {
      // 必须有sprite并且sprite必须存在
      if (!char.sprite) return false;

      // 检查角色之前是否可见
      const wasVisible = char.isVisible;

      // 计算当前是否可见
      const isVisible = isInViewport(char);

      // 更新可见状态
      char.isVisible = isVisible;

      // 如果可见状态发生变化，需要更新
      const visibilityChanged = wasVisible !== isVisible;

      // 室内人物需要特殊处理：只有在建筑物被hover显示时才更新
      if (char.isIndoor) {
        // 如果不可见，不需要更新
        if (!isVisible) return false;

        // 如果父精灵存在且可见，说明建筑被hover显示，需要更新
        return char.sprite.visible === true;
      }

      // 如果是焦点角色，无论是否可见都需要更新
      if (char.isFocused) return true;

      // 如果可见或者可见性刚刚变化，需要更新
      return isVisible || visibilityChanged;
    });

    // 记录所有可见室外人物当前位置
    visibleCharacters.forEach(character => {
      if (!character.isIndoor) {
        // 只记录室外人物
        const positionKey = `${Math.floor(character.x / tileWidth)},${Math.floor(character.y / tileHeight)}`;
        this.characterPositions.set(positionKey, character);

        // 实时更新zIndex，即使没有移动也更新
        if (character.sprite) {
          // character.sprite.zIndex = character.y;
        }
      }
    });

    // 将角色位置信息传递给行为控制器
    this.behaviorController.setCharacterPositions(this.characterPositions);

    // 将视口信息传递给行为控制器
    this.behaviorController.setViewportBounds(viewportBounds, tileWidth, tileHeight);

    // 遍历所有需要更新的人物
    for (const character of visibleCharacters) {
      character.moveTimer += adjustedDeltaTime * 1000;  // 转换为毫秒

      // 实时更新人物的zIndex，确保正确的层级关系
      if (character.sprite) {
        character.sprite.zIndex = character.y;

        // 为工作中的人物添加颜色标识
        if (character.isWorking !== 0) {  // 修改：任何非0的isWorking视为true
          // 添加气泡图标
          if (!character.bubbleSprite) {
            this.addBubbleToCharacter(character);
          }

          // 如果是室外人物且处于工作状态，那么重置前往建筑的标志
          if (!character.isIndoor) {


    addField("signature", FIELD_SIGNATURE);
      addField("holder", FIELD_HOLDER);
      addField("isPrivate", FIELD_IS_PRIVATE);
      addField("isPublic", FIELD_IS_PUBLIC);
      addField("isProtected", FIELD_IS_PROTECTED);
      addField("isPackagePrivate", FIELD_IS_PACKAGE_PRIVATE);
      addField("isStatic", FIELD_IS_STATIC);
      addField("isFinal", FIELD_IS_FINAL);
      addField("isSynchronized", FIELD_IS_SYNCHRONIZED);
      addField("isNative", FIELD_IS_NATIVE);
      addField("isAbstract", FIELD_IS_ABSTRACT);
      addField("isStrict", FIELD_IS_STRICT);
      addField("isSynthetic", FIELD_IS_SYNTHETIC);
      addField("isObsolete", FIELD_IS_OBSOLETE);
   }
}
/*
 * Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code 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
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

// Non-public classes so we can keep them all in this one source file

class HostOfMemberNoHost {
    // Missing NestHost attribute
    static class MemberNoHost {}
}

class HostOfMemberMissingHost {
    // Missing NestHost class
    static class MemberMissingHost {}
}

class HostOfMemberNotInstanceHost {
    // Invalid NestHost class (not instance class)
    static class MemberNotInstanceHost {
        Object[] oa; // create CP entry to use in jcod change
    }
}

class HostOfMemberNotOurHost {
    // Valid but different NestHost class
    static class MemberNotOurHost {}
}

class HostOfMemberMalformedHost {
    // Malformed NestHost class
    static class MemberMalformedHost {}
}

// Host lists itself as a member along
// with real member.
class HostWithSelfMember {
    static class Member {}
}

// Host lists duplicate members.
class HostWithDuplicateMembers {
    static class Member1 {}
    static interface Member2 {}
}
/*
 * Copyright (c) 2003, 2007, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code 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
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.


.4-53.9 130.1-34.8 34.8-81 53.9-130.1 53.9h-16c-49.1 0-95.4-19.1-130.1-53.9-34.8-34.8-53.9-81-53.9-130.1V184h384v296zm136-128c0 41-26.9 75.8-64 87.6V232h64v120z")),t.UnlockOutline=c("unlock",i,s(o,"M832 464H332V240c0-30.9 25.1-56 56-56h248c30.9 0 56 25.1 56 56v68c0 4.4 3.6 8 8 8h56c4.4 0 8-3.6 8-8v-68c0-70.7-57.3-128-128-128H388c-70.7 0-128 57.3-128 128v224h-68c-17.7 0-32 14.3-32 32v384c0 17.7 14.3 32 32 32h640c17.7 0 32-14.3 32-32V496c0-17.7-14.3-32-32-32zm-40 376H232V536h560v304zM484 701v53c0 4.4 3.6 8 8 8h40c4.4 0 8-3.6 8-8v-53a48.01 48.01 0 1 0-56 0z")),t.UpCircleOutline=c("up-circle",i,s(o,"M518.5 360.3a7.95 7.95 0 0 0-12.9 0l-178 246c-3.8 5.3 0 12.7 6.5 12.7H381c10.2 0 19.9-4.9 25.9-13.2L512 460.4l105.2 145.4c6 8.3 15.6 13.2 25.9 13.2H690c6.5 0 10.3-7.4 6.5-12.7l-178-246z","M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z")),t.UpSquareOutline=c("up-square",i,s(o,"M334 624h46.9c10.2 0 19.9-4.9 25.9-13.2L512 465.4l105.2 145.4c6 8.3 15.6 13.2 25.9 13.2H690c6.5 0 10.3-7.4 6.5-12.7l-178-246a7.95 7.95 0 0 0-12.9 0l-178 246A7.96 7.96 0 0 0 334 624z","M880 112H144c-17.7 0-32 14.3-32 32v736c0 17.7 14.3 32 32 32h736c17.7 0 32-14.3 32-32V144c0-17.7-14.3-32-32-32zm-40 728H184V184h656v656z")),t.UsbOutline=c("usb",i,s(o,"M760 432V144c0-17.7-14.3-32-32-32H296c-17.7 0-32 14.3-32 32v288c-66.2 0-120 52.1-120 116v356c0 4.4 3.6 8 8 8h56c4.4 0 8-3.6 8-8V548c0-24.3 21.6-44 48.1-44h495.8c26.5 0 48.1 19.7 48.1 44v356c0 4.4 3.6 8 8 8h56c4.4 0 8-3.6 8-8V548c0-


 months = (int)Math.floor((double)days / 29.530588853);
            long monthStart = (long)Math.floor((double)months * 29.530588853 - 1.0);
            if (days - monthStart >= 25L && IslamicCalendar.moonAge(this.internalGetTimeInMillis()) > 0.0) {
                ++months;
            }
            while ((monthStart = IslamicCalendar.trueMonthStart(months)) > days) {
                --months;
            }
            year = months / 12 + 1;
            month = months % 12;
        }
        int dayOfMonth = (int)(days - this.monthStart(year, month)) + 1;
        int dayOfYear = (int)(days - this.monthStart(year, 0) + 1L);
        this.internalSet(0, 0);
        this.internalSet(1, year);
        this.internalSet(19, year);
        this.internalSet(2, month);
        this.internalSet(5, dayOfMonth);
        this.internalSet(6, dayOfYear);
    }

    public String getType() {
        if (this.civil) {
            return "islamic-civil";
        }
        return "islamic";
    }
}

/*
 * Decompiled with CFR 0.153-SNAPSHOT (d6f6758-dirty).
 */
package com.ibm.icu.util;

import com.ibm.icu.impl.Grego;
import com.ibm.icu.util.AnnualTimeZoneRule;
import com.ibm.icu.util.BasicTimeZone;
import com.ibm.icu.util.InitialTimeZoneRule;
import com.ibm.icu.util.TimeZone;
import com.ibm.icu.util.TimeZoneRule;
import com.ibm.icu.util.TimeZoneTransition;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Date;
import java.util.List;

public class RuleBasedTimeZone
extends BasicTimeZone {
    private static final long serialVersionUID = 7580833058949327935L;
    private final InitialTimeZoneRule initialRule;
    private List<TimeZoneRule> historicRules;
    private AnnualTimeZoneRule[] finalRules;
    private transient List<TimeZoneTransition> historicTransitions;
    private transient boolean upToDate;
    private transient boolean isFrozen = false;

    public RuleBasedTimeZone(String id, InitialTimeZoneRule initialRule) {
        super(id);
        this.initialRule = initialRule;
    }

    /*
     * Enabled force condition propagation
     * Lifted jumps to return sites
     */
    public void addTransitionRule(TimeZoneRule rule) {
        if (this.isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify a frozen RuleBasedTimeZone instance.");
        }
        if (!rule.isTransitionRule()) {
            throw new IllegalArgumentException("Rule must be a transition rule");
        }
        if (rule instanceof AnnualTimeZoneRule && ((AnnualTimeZoneRule)rule).getEndYear() == Integer.MAX_VALUE) {
            if (this.finalRules == null) {
                this.finalRules = new AnnualTimeZoneRule[2];
                this.finalRules[0] = (AnnualTimeZoneRule)rule;
            } else {
                if (this.finalRules[1] != null) throw new IllegalStateException("Too many final rules");
                this.finalRules[1] = (AnnualTimeZoneRule)rule;
            }
        } else {
            if (this.historicRules == null) {
                this.historicRules = new ArrayList<TimeZoneRule>();
            }
            this.historicRules.add(rule);
        }
        this.upToDate = false;
    }

    public int getOffset(int era, int year, int month, int day, int dayOfWeek, int milliseconds) {
        if (era == 0) {
            year = 1 - year;
        }
        long time = Grego.fieldsToDay(year, month, day) * 86400000L + (long)milliseconds;
        int[] offsets = new int[2];


    public ISynchronizeInvoke Invoker => this;

        public IJobUserFeedback ShowFeedback(
            JobDescription jobDescription,
            CancellationTokenSource cancellationSource)
        {
            Debug.Assert(!this.Invoker.InvokeRequired, "ShowForegroundFeedback must be called on UI thread");

            switch (jobDescription.Feedback)
            {
                case JobUserFeedbackType.ForegroundFeedback:
                    //
                    // Show WaitDialog, blocking all user intraction.
                    //
                    var waitDialog = new WaitDialog(this, jobDescription.StatusMessage, cancellationSource);
                    this.dialogTheme.ApplyTo(waitDialog);
                    return waitDialog;

                default:
                    return this.viewModel.CreateBackgroundJob(jobDescription, cancellationSource);
            }
        }

        public void Reauthorize()
        {
            using (var dialog = this.serviceProvider
                .GetService<WindowActivator<AuthorizeView, AuthorizeViewModel, IDialogTheme>>()
                .CreateDialog())
            {
                dialog.ViewModel.UseExistingAuthorization(
                    this.serviceProvider.GetService<IAuthorization>());
                dialog.ShowDialog(this);
            }
        }

        private void cancelBackgroundJobsButton_Click(object sender, EventArgs e)
            => this.viewModel.CancelBackgroundJobs();

        //---------------------------------------------------------------------
        // Helper classes.
        //---------------------------------------------------------------------

        private class CallbackSource<TContext> : IContextSource<TContext>
            where TContext : class
        {
            private readonly Func<TContext?> queryCurrentContextFunc;

            public CallbackSource(Func<TContext?> queryCurrentContextFunc)
            {
                this.queryCurrentContextFunc = queryCurrentContextFunc;
            }

            public TContext? Context => this.queryCurrentContextFunc();
        }
    }
}


BRA",
      "en_short_name": "Brazil",
      "nationality": "Brazilian",
      "dial_code": "+55",
      "nameTranslations": {
        "sk": "Brazília",
        "se": "Brasil",
        "pl": "Brazylia",
        "no": "Brasil",
        "ja": "ブラジル",
        "it": "Brasile",
        "zh": "巴西",
        "nl": "Brazilië",
        "de": "Brasilien",
        "fr": "Brésil",
        "es": "Brasil",
        "en": "Brazil",
        "pt_BR": "Brasil",
        "sr-Cyrl": "Бразил",
        "sr-Latn": "Brazil",
        "zh_TW": "巴西",
        "tr": "Brezilya",
        "ro": "Brazilia",
        "ar": "البرازيل"
      }
    },
    {
      "num_code": "86",
      "alpha_2_code": "IO",
      "alpha_3_code": "IOT",
      "en_short_name": "British Indian Ocean Territory",
      "nationality": "BIOT",
      "dial_code": "+246",
      "nameTranslations": {
        "sk": "Britské indickooceánske územie",
        "se": "British Indian Ocean Territory",
        "pl": "Brytyjskie Terytorium Oceanu Indyjskiego",
        "no": "Det britiske territoriet i Indiahavet",
        "ja": "英領インド洋地域",
        "it": "Territorio britannico dell’Oceano Indiano",
        "zh": "英属印度洋领地",
        "nl": "Brits Indische Oceaanterritorium",
        "de": "Britisches Territorium im Indischen Ozean",
        "fr": "Territoire britannique de l’océan Indien",
        "es": "Territorio Británico del Océano Índico",
        "en": "British Indian Ocean Territory",
        "pt_BR": "Território Britânico do Oceano Índico",
        "sr-Cyrl": "Британска територија Индијског океана",
        "sr-Latn": "Britanska teritorija Indijskog okeana",
        "zh_TW": "英屬印度洋領地",
        "tr": "Britanya Hint Okyanusu Toprakları",
        "ro": "Teritoriul Britanic din Oceanul Indian",
        "ar": "إقليم المحيط الهندي البريطاني"
      }
    },
    {
      "num_code": "96",
      "alpha_2_code": "BN",
      "alpha_3_code": "BRN",
      "en_short_name": "Brunei Darussalam",
      "nationality": "Bruneian",
      "dial_code": "+673",
      "nameTranslations": {
        "sk": "Brunej",
        "se": "Brunei",
        "pl": "Brunei",
        "no": "Brunei",
        "ja": "ブルネイ",
        "it": "Brunei",
        "zh": "文莱",
        "nl": "Brunei",
        "de": "Brunei Darussalam",
        "fr": "Brunéi Darussalam",
        "es": "Brunéi",


nstruction',
  'Anchor',
  'Sailboat',
  'Speedboat',
  'Passenger Ship',
  'Ferry',
  'Motor Boat',
  'Ship',
  'Airplane',
  'Small Airplane',
  'Airplane Departure',
  'Airplane Arrival',
  'Seat',
  'Helicopter',
  'Suspension Railway',
  'Mountain Cableway',
  'Aerial Tramway',
  'Satellite',
  'Rocket',
  'Flying Saucer',
  'Shooting Star',
  'Milky Way',
  'Umbrella on Ground',
  'Fireworks',
  'Sparkler',
  'Moon Viewing Ceremony',
  'Yen Banknote',
  'Dollar Banknote',
  'Euro Banknote',
  'Pound Banknote',
  'Moai',
  'Passport Control',
  'Customs',
  'Baggage Claim',
  'Left Luggage'
], [
  '🚣',
  '🗾',
  '🏔',
  '⛰',
  '🌋',
  '🗻',
  '🏕',
  '🏖',
  '🏜',
  '🏝',
  '🏞',
  '🏟',
  '🏛',
  '🏗',
  '🏘',
  '🏚',
  '🏠',
  '🏡',
  '🏢',
  '🏣',
  '🏤',
  '🏥',
  '🏦',
  '🏨',
  '🏩',
  '🏪',
  '🏫',
  '🏬',
  '🏭',
  '🏯',
  '🏰',
  '💒',
  '🗼',
  '🗽',
  '⛪',
  '🕌',
  '🕍',
  '⛩',
  '🕋',
  '⛲',
  '⛺',
  '🌁',
  '🌃',
  '🏙',
  '🌄',
  '🌅',
  '🌆',
  '🌇',
  '🌉',
  '🎠',
  '🎡',
  '🎢',
  '🚂',
  '🚃',
  '🚄',
  '🚅',
  '🚆',
  '🚇',
  '🚈',
  '🚉',
  '🚊',
  '🚝',
  '🚞',
  '🚋',
  '🚌',
  '🚍',
  '🚎',
  '🚐',
  '🚑',
  '🚒',
  '🚓',
  '🚔',
  '🚕',
  '🚖',
  '🚗',
  '🚘',
  '🚚',
  '🚛',
  '🚜',
  '🏎',
  '🏍',
  '🛵',
  '🚲',
  '🛴',
  '🚏',
  '🛤',
  '⛽',
  '🚨',
  '🚥',
  '🚦',
  '🚧',
  '⚓',
  '⛵',
  '🚤',
  '🛳',
  '⛴',
  '🛥',
  '🚢',
  '✈',
  '🛩',
  '🛫',
  '🛬',
  '💺',
  '🚁',
  '🚟',
  '🚠',
  '🚡',
  '🛰',
  '🚀',
  '🛸',
  '🌠',
  '🌌',
  '⛱',
  '🎆',
  '🎇',
  '🎑',
  '💴',
  '💵',
  '💶',
  '💷',
  '🗿',
  '🛂',
  '🛃',
  '🛄',
  '🛅'
]);

/// Map of all possible emojis along with their names in [Category.ACTIVITIES]
final Map<String, String> activities = Map.fromIterables([
  'Man in Suit Levitating',
  'Man Climbing',
  'Woman Climbing',
  'Horse Racing',
  'Skier',
  'Snowboarder',
  'Man Golfing',
  'Woman Golfing',
  'Man Surfing',
  'Woman Sur


aun Moynihan',\n            Emir : 'Emir Ayouni'\n        }\"\n        :hidden-options=\"['Tim', 'Victor']\"\n    ></ui-checkbox>\n
\n:::\n\n:::vue\n@name:max\n---\n#config\n>conf-desc\n最多可选项目的数量。\n>conf-accept\n数量\n>conf-type\nNumber\n>conf-default\n`Infinity`\n---\n#demo\n>tpl\n
\n    <ui-checkbox\n        form-name=\"姓名\"\n        :list=\"{\n            Tim : 'Tim Boelaars',\n            Andrew : 'Andrew Colin Beck',\n            Victor : 'Victor Erixon',\n            Shaun : 'Shaun Moynihan',\n            Emir : 'Emir Ayouni'\n        }\"\n        :max=\"3\"\n    ></ui-checkbox>\n
\n:::\n\n:::vue\n@name:parent\n---\n#config\n>conf-desc\n此配置可以将当前的复选框组件关联到另一个复选框的某个选项上，建立从属关系。

如果父选项被选中，那么所关联的子选项都会被选中。
如果部分子选项被选中，那么父选项会处于部分选中状态。

每个父选项只能关联到一个复选框组件上。关联时会优先取子复选框组件的状态。\n>conf-accept\n`[关联复选框的选择器]:[关联选项的key]`\n>conf-type\nString\n>conf-default\n`''`\n---\n#demo\n>tpl\n
\n    <ui-checkbox\n        form-name=\"Continents\"\n        id=\"continents\"\n        :list=\"{\n            asia : 'Asia',\n            na : 'North America',\n            europe : 'Europe',\n            africa : 'Africa'\n        }\"></ui-checkbox>\n    <ui-checkbox\n        form-name=\"Asia\"\n        parent=\"#continents:asia\"\n        :list=\"{\n            beijing : 'Beijing',\n            hk : 'Hong Kong',\n            singapore : 'Singapore',\n            tokyo : 'Tokyo'\n        }\"\n    ></ui-checkbox>\n    <ui-checkbox\n        form-name=\"North America\"\n        parent=\"#continents:na\"\n        :list=\"{\n            ny : 'New York',\n            toronto : 'Toronto',\n            la : 'Los Angeles'\n        }\"\n    ></ui-checkbox>\n    <ui-checkbox\n        form-name=\"Europe\"\n        parent=\"#continents:europe\"\n        :list=\"{\n            london : 'London',\n            paris : 'Paris',\n            berlin : 'Berlin',\n            rome : 'Rome',\n            copenhagen : 'Copenhagen',\n            madrid : 'Madrid'\n        }\"\n    ></ui-checkbox>\n    <ui-checkbox\n        form-name=\"Africa\"\n        parent=\"#continents:africa\"\n        :list=\"{\n            cairo : 'Cairo',\n            cuba : 'Cuba'\n        }\"\n    ></ui-checkbox>\n
\n---\n#demo\n>desc\n有默认值的情况。\n>tpl\n
\n    <ui-checkbox\n        form-name=\"Continents\"\n        id=\"continents2\"\n        v-model=\"value1\"\n        :list=\"{\n            asia : 'Asia',\n            na : 'North America',\n            europe : 'Europe',\n            africa : 'Africa'\n        }\"\n    ></ui-checkbox>\n    <ui-checkbox\n        form-name=\"Asia\"\n        parent=\"#continents2:asia\"\n        :list=\"{\n            beijing : 'Beijing',\n


yee_state"`
	PayeeZipCode                string    `json:"payee_zip_code"`
	RecordSequenceNumber        int32     `json:"record_sequence_number"`
	TypeWagerCode               string    `json:"type_wager_code"`
	DateWon                     time.Time `json:"date_won"`
	Transaction                 string    `json:"transaction,omitempty"`
	Race                        string    `json:"race,omitempty"`
	Cashier                     string    `json:"cashier,omitempty"`
	Window                      string    `json:"window,omitempty"`
	FirstId                     string    `json:"first_id,omitempty"`
	SecondId                    string    `json:"second_id,omitempty"`
	SpecialDataEntries          string    `json:"special_data_entries,omitempty"`
	StateIncomeTaxWithheld      int32     `json:"state_income_tax_withheld,omitempty"`
	LocalIncomeTaxWithheld      int32     `json:"local_income_tax_withheld,omitempty"`
}
// Copyright 2020 The Moov Authors
// Use of this source code is governed by an Apache License
// license that can be found in the LICENSE file.

package pdf_generator

import (
	"os"
	"strings"
	"testing"

	"gopkg.in/check.v1"
)

func Test(t *testing.T) { check.TestingT(t) }

var _ = check.Suite(&PdfTest{})

// Pdf test
type PdfTest struct{}

func (t *PdfTest) SetUpSuite(c *check.C) {}

func (t *PdfTest) SetUpTest(c *check.C) {
	pdfConverter = "pdftk"
	convertParam1 = "fill_form"
	convertParam3 = "cat"
}

func (t *PdfTest) TestPdfWithMscCopyB(c *check.C) {
	pdf := Pdf1099Misc{Type: PdfMscCopyB}
	f, err := GeneratePdf(&pdf)
	c.Assert(err, check.IsNil)
	files := make([][]byte, 0)
	_, err = MergePdfs(files)
	c.Assert(err, check.NotNil)
	files = append(files, f)
	_, err = MergePdfs(files)
	c.Assert(err, check.IsNil)
	files = append(files, f)
	_, err = MergePdfs(files)
	c.Assert(err, check.IsNil)

	templateFdf, err := pdf.getTemplateFdf()
	c.Assert(err, check.IsNil)
	newFdf, err := pdf.generateFDF("")
	c.Assert(err, check.IsNil)
	c.Assert(strings.ReplaceAll(string(templateFdf), "\r", ""),
		check.Equals, strings.ReplaceAll(string(newFdf), "\r", ""))
}

func (t *PdfTest) TestPdfWithMscCopyC(c *check.C) {
	pdf := Pdf1099Misc{Type: PdfMscCopyC}
	_, err := GeneratePdf(&pdf)
	c.Assert(err, check.IsNil)
	templateFdf, err := pdf.getTemplateFdf()
	c.Assert(err, check.IsNil)
	newFdf, err := pdf.generateFDF("")
	c.Assert(err, check.IsNil)
	c.Assert(strings.ReplaceAll(string(templateFdf), "\r", ""),
		check.Equals, strings.ReplaceAll(string(newFdf), "\r", ""))
}

func (t *PdfTest) TestPdfWithNecCopyB(c *check.C) {
	pdf := Pdf1099Misc{Type: PdfNecCopyB}
	_, err := GeneratePdf(&pdf)
	c.Assert(err, check.IsNil)
	templateFdf, err := pdf.getTemplateFdf()
	c.Assert(err, check.IsNil)
	newFdf, err := pdf.generateFDF("")
	c.Assert(err, check.IsNil)
	c.Assert(strings.ReplaceAll(string(templateFdf), "\r", ""),
		check.Equals, strings.ReplaceAll(string(newFdf), "\r", ""))
}

func (t *PdfTest) TestPdfWithNecCopyC(c *check.C) {
	pdf := Pdf1099Misc{Type: PdfNecCopyC}
	templateFdf, err := pdf.getTemplateFdf()
	c.Assert(err, check.IsNil)
	newFdf, err := pdf.generateFDF("")
	c.Assert(


# Code generated by lark_sdk_gen. DO NOT EDIT.

from pylark.lark_request import RawRequestReq, _new_method_option
import attr
import typing
import io

@attr.s
class GetCalendarEventAttendeeChatMemberListReq(object):
    page_token: str = attr.ib(
        default="", metadata={"req_type": "query", "key": "page_token"}
    )  # 分页标记，第一次请求不填，表示从头开始遍历；分页查询结果还有更多项时会同时返回新的 page_token，下次遍历可采用该 page_token 获取查询结果, 示例值："23jhysaxxxxsysy"
    page_size: int = attr.ib(
        default=0, metadata={"req_type": "query", "key": "page_size"}
    )  # 分页大小, 示例值：10, 最大值：`100`
    calendar_id: str = attr.ib(
        default="", metadata={"req_type": "path", "key": "calendar_id"}
    )  # 日历 ID, 示例值："feishu.cn_xxxxxxxxxx@group.calendar.feishu.cn"
    event_id: str = attr.ib(
        default="", metadata={"req_type": "path", "key": "event_id"}
    )  # 日程 ID, 示例值："xxxxxxxxx_0"
    attendee_id: str = attr.ib(
        default="", metadata={"req_type": "path", "key": "attendee_id"}
    )  # 参与人 ID, 示例值："user_xxxxxx"

@attr.s
class GetCalendarEventAttendeeChatMemberListRespItem(object):
    rsvp_status: str = attr.ib(
        default="", metadata={"req_type": "json", "key": "rsvp_status"}
    )  # 参与人RSVP状态, 可选值有: `needs_action`：参与人尚未回复状态，或表示会议室预约中, `accept`：参与人回复接受，或表示会议室预约成功, `tentative`：参与人回复待定, `decline`：参与人回复拒绝，或表示会议室预约失败, `removed`：参与人或会议室已经从日程中被移除
    is_optional: bool = attr.ib(
        factory=lambda: bool(), metadata={"req_type": "json", "key": "is_optional"}
    )  # 参与人是否为「可选参加」, 默认值: `false`
    display_name: str = attr.ib(
        default="", metadata={"req_type": "json", "key": "display_name"}
    )  # 参与人名称
    is_organizer: bool = attr.ib(
        factory=lambda: bool(), metadata={"req_type": "json", "key": "is_organizer"}
    )  # 参与人是否为日程组织者
    is_external: bool = attr.ib(
        factory=lambda: bool(), metadata={"req_type": "json", "key": "is_external"}
    )  # 参与人是否为外部参与人

@attr.s
class GetCalendarEventAttendeeChatMemberListResp(object):
    items: typing.List[GetCalendarEventAttendeeChatMemberListRespItem] = attr.ib(
        factory=lambda: [], metadata={"req_type": "json", "key": "items"}
    )  # 群中的群成员，当type为chat时有效；群成员不支持编辑
    has_more: bool = attr.ib(
        factory=lambda: bool(), metadata={"req_type": "json", "key": "has_more"}
    )  # 是否还有更多项
    page_token: str = attr.ib(
        default="", metadata={"req_type": "json", "key": "page_token"}
    )  # 分页标记，当 has_more 为 true 时，会同时返回新的 page_token，否则不返回 page_token

def _gen_get_calendar_event_attendee_chat_member_list_req(
    request, options
) -> RawRequestReq:
    return RawRequestReq(
        dataclass=GetCalendarEventAttendeeChatMemberListResp,
        scope="Calendar",
        api="GetCalendarEventAttendeeChatMemberList",
        method="GET",
        url="https://open.feishu.cn/open-apis/calendar/v4/calendars/:calendar_id/events/:event_id/attendees/:attendee_id/chat_members",
        body=request,
        method_option=_new_method_option(options),
        need_tenant_access_token=True,
        need_user_access_token=True,
    )


5196
data8  0x3DA163A6617D741C
data4  0x3F638E38,0x3DF13843
data8  0x3E2C55E6CBD3D5BB
data4  0x3F579430,0x3E2FF9A0
data8  0xBE3EB0BFD86EA5E7
data4  0x3F4CCCC8,0x3E647FD6
data8  0x3E2E6A8C86B12760
data4  0x3F430C30,0x3E8B3AE7
data8  0x3E47574C5C0739BA
data4  0x3F3A2E88,0x3EA30C68
data8  0x3E20E30F13E8AF2F
data4  0x3F321640,0x3EB9CEC8
data8  0xBE42885BF2C630BD
data4  0x3F2AAAA8,0x3ECF9927
data8  0x3E497F3497E577C6
data4  0x3F23D708,0x3EE47FC5
data8  0x3E3E6A6EA6B0A5AB
data4  0x3F1D89D8,0x3EF8947D
data8  0xBDF43E3CD328D9BE
data4  0x3F17B420,0x3F05F3A1
data8  0x3E4094C30ADB090A
data4  0x3F124920,0x3F0F4303
data8  0xBE28FBB2FC1FE510
data4  0x3F0D3DC8,0x3F183EBF
data8  0x3E3A789510FDE3FA
data4  0x3F088888,0x3F20EC80
data8  0x3E508CE57CC8C98F
data4  0x3F042108,0x3F29516A
data8  0xBE534874A223106C
LOCAL_OBJECT_END(Constants_G_H_h1)

// Z2 - 16 bit fixed
LOCAL_OBJECT_START(Constants_Z_2)
data4  0x00008000
data4  0x00007F81
data4  0x00007F02
data4  0x00007E85
data4  0x00007E08
data4  0x00007D8D
data4  0x00007D12
data4  0x00007C98
data4  0x00007C20
data4  0x00007BA8
data4  0x00007B31
data4  0x00007ABB
data4  0x00007A45
data4  0x000079D1
data4  0x0000795D
data4  0x000078EB
LOCAL_OBJECT_END(Constants_Z_2)

// G2 and H2 - IEEE single and h2 - IEEE double
LOCAL_OBJECT_START(Constants_G_H_h2)
data4  0x3F800000,0x00000000
data8  0x0000000000000000
data4  0x3F7F00F8,0x3B7F875D
data8  0x3DB5A11622C42273
data4  0x3F7E03F8,0x3BFF015B
data8  0x3DE620CF21F86ED3
data4  0x3F7D08E0,0x3C3EE393
data8  0xBDAFA07E484F34ED
data4  0x3F7C0FC0,0x3C7E0586
data8  0xBDFE07F03860BCF6
data4  0x3F7B1880,0x3C9E75D2
data8  0x3DEA370FA78093D6
data4  0x3F7A2328,0x3CBDC97A
data8  0x3DFF579172A753D0
data4  0x3F792FB0,0x3CDCFE47
data8  0x3DFEBE6CA7EF896B
data4  0x3F783E08,0x3CFC15D0
data8  0x3E0CF156409ECB43
data4  0x3F774E38,0x3D0D874D
data8  0xBE0B6F97FFEF71DF
data4  0x3F766038,0x3D1CF49B
data8  0xBE0804835D59EEE8
data4


x23c24: "R\x0e\U00023c24", // 𣰤
	0x23c25: "R\x0e\U00023c25", // 𣰥
	0x23c26: "R\x0e\U00023c26", // 𣰦
	0x23c27: "R\x0e\U00023c27", // 𣰧
	0x23c28: "R\x0e\U00023c28", // 𣰨
	0x23c29: "R\x0e\U00023c29", // 𣰩
	0x23c2a: "R\x0e\U00023c2a", // 𣰪
	0x23c2b: "R\x0f\U00023c2b", // 𣰫
	0x23c2c: "R\x0f\U00023c2c", // 𣰬
	0x23c2d: "R\x0f\U00023c2d", // 𣰭
	0x23c2e: "R\x0f\U00023c2e", // 𣰮
	0x23c2f: "R\x0f\U00023c2f", // 𣰯
	0x23c30: "R\x0f\U00023c30", // 𣰰
	0x23c31: "R\x10\U00023c31", // 𣰱
	0x23c32: "R\x10\U00023c32", // 𣰲
	0x23c33: "R\x10\U00023c33", // 𣰳
	0x23c34: "R\x10\U00023c34", // 𣰴
	0x23c35: "R\x10\U00023c35", // 𣰵
	0x23c36: "R\x11\U00023c36", // 𣰶
	0x23c37: "R\x11\U00023c37", // 𣰷
	0x23c38: "R\x11\U00023c38", // 𣰸
	0x23c39: "R\x11\U00023c39", // 𣰹
	0x23c3a: "R\x11\U00023c3a", // 𣰺
	0x23c3b: "R\x12\U00023c3b", // 𣰻
	0x23c3c: "R\x12\U00023c3c", // 𣰼
	0x23c3d: "R\x12\U00023c3d", // 𣰽
	0x23c3e: "R\x12\U00023c3e", // 𣰾
	0x23c3f: "R\x13\U00023c3f", // 𣰿
	0x23c40: "R\x13\U00023c40", // 𣱀
	0x23c41: "R\x13\U00023c41", // 𣱁
	0x23c42: "R\x16\U00023c42", // 𣱂
	0x23c43: "R\x16\U00023c43", // 𣱃
	0x23c44: "R\x18\U00023c44", // 𣱄
	0x23c45: "S\x04\U00023c45", // 𣱅
	0x23c46: "S\x04\U00023c46", // 𣱆
	0x23c47: "S\x05\U00023c47", // 𣱇
	0x23c48: "S\x05\U00023c48", //


, 0.12), 0 1px 2px rgba(0, 0, 0, 0.24);
    position: relative;
    -webkit-transition: height 0.2s ease-in-out;
    transition: height 0.2s ease-in-out;
    width: 100%
}

.v__2E8FwqWrFBkpdVK3yY {
    border-bottom: 1px solid #E9EAEA;
    background-color: #fff
}

.v__2E8FwqWrFBkpdVK3yY:last-child {
    border-bottom-width: 0
}

._1Eq6AGMcJBLI9c1DuTRVhG h2 {
    padding: 1rem 0
}

._89Nni_yTzED35osSMU-ag {
    height: 80px;
    padding: 1rem;
    width: 100%;
    z-index: 0
}

._7OQU1KMXdr5cMzhXcw6dj {
    padding-left: 1rem;
    -ms-flex-negative: 1;
    flex-shrink: 1;
    overflow: hidden
}

._7OQU1KMXdr5cMzhXcw6dj ._3kRzNMFAk0Gk2e94MhgIhq {
    color: #204056;
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
    max-width: 100%;
    margin-bottom: 0
}

._7OQU1KMXdr5cMzhXcw6dj ._3gVM3CtWYb5y0AHf9gLLgE {
    font-size: .9rem;
    color: #BEBFC1;
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
    margin-bottom: 0
}

.P72WyzgobqwlQWv17XXRg {
    -ms-flex-negative: 0;
    flex-shrink: 0;
    color: #204056;
    width: 40px
}

._3WJBSOLLkgmSyTtyoGWhfC {
    z-index: 1
}

._3WJBSOLLkgmSyTtyoGWhfC ._3kRzNMFAk0Gk2e94MhgIhq, ._3WJBSOLLkgmSyTtyoGWhfC .P72WyzgobqwlQWv17XXRg {
    color: #fff
}

._3WJBSOLLkgmSyTtyoGWhfC ._3gVM3CtWYb5y0AHf9gLLgE {
    color: rgba(255, 255, 255, 0.6)
}

._3WJBSOLLkgmSyTtyoGWhfC.Lp7VVX6jEk8EBS9NROdDt {
    background-color: #F65A5B;
    color: #F65A5B
}

._3WJBSOLLkgmSyTtyoGWhfC.pJpQRg-mF6KOi3ZFHX6_z {
    background-color: #204056;
    color: #204056
}

._3WJBSOLLkgmSyTtyoGWhfC .zBvlWJ18M5G1i3Y_En-Id {
    color: #fff;
    font-size: 26px;
    cursor: pointer
}

._3WJBSOLLkgmSyTtyoGWhfC .zBvlWJ18M5G1i3Y_En-Id._3l1G-_QZ1HP_vRuMjKqnej {
    opacity: 0.5;
    cursor: default
}

._3HqLzpSljHlD5GH_fB7qMh {
    opacity: 0.7
}

._3HqLzpSljHlD5GH_fB7qMh ._7OQU1KMXdr5cMzhXcw6dj ._3kRzNMFAk0Gk2e


+607e-607f, U+6081-6086, U+6088-608e, U+6091-6093, U+6095-6098, U+609a-609b, U+609d-609e, U+60a2, U+60a4-60a5, U+60a7-60a8, U+60b0-60b1, U+60b3-60b5, U+60b7-60b8, U+60bb, U+60bd-60be, U+60c2, U+60c4, U+60c6-60cb, U+60ce-60cf, U+60d3-60d5, U+60d8-60d9, U+60db, U+60dd-60df, U+60e1-60e2, U+60e5, U+60ee, U+60f0-60f2, U+60f4-60f8, U+60fa-60fd, U+6100, U+6102-6103, U+6106-6108, U+610a, U+610c-610e, U+6110-6114, U+6116;
}

/* [41] */
@font-face {
    font-family: 'GenJyuuGothicXP';
    font-style: normal;
    font-weight: 700;
    font-display: swap;
    src: url(./GenJyuuGothicX-P-Bold-3173c8c85b725024f378f4eceed1a494d0ed511a73207cded02d4264ea7640ae-41.woff2) format('woff2');
    unicode-range: U+5d9b, U+5d9d, U+5d9f-5da0, U+5da2, U+5da4, U+5da7, U+5dab-5dac, U+5dae, U+5db0, U+5db2, U+5db4, U+5db7-5db9, U+5dbc-5dbd, U+5dc3, U+5dc7, U+5dc9, U+5dcb-5dce, U+5dd0-5dd3, U+5dd6-5dd9, U+5ddb, U+5de0, U+5de2, U+5de4, U+5de9, U+5df2, U+5df5, U+5df8-5df9, U+5dfd, U+5dff-5e00, U+5e07, U+5e0b, U+5e0d, U+5e11-5e12, U+5e14-5e15, U+5e18-5e1b, U+5e1f-5e20, U+5e25, U+5e28, U+5e2e, U+5e32, U+5e35-5e37, U+5e3e, U+5e40, U+5e43-5e44, U+5e47, U+5e49, U+5e4b, U+5e4e, U+5e50-5e51, U+5e54, U+5e56-5e58, U+5e5b-5e5c, U+5e5e-5e5f, U+5e62, U+5e64, U+5e68, U+5e6a-5e6e, U+5e70, U+5e75-5e77, U+5e7a, U+5e7f-5e80, U+5e87, U+5e8b, U+5e8e, U+5e96, U+5e99-5e9a, U+5ea0, U+5ea2, U+5ea4-5ea5, U+5ea8, U+5eaa, U+5eac, U+5eb1, U+5eb3, U+5eb8-


import json
import sys
from pathlib import Path

sys.path.append(str(Path(__file__).resolve().parents[1]))

from handlers import synth_param_editor_handler_class as speh
class SimpleForm(dict):
    def getvalue(self, name, default=None):
        return self.get(name, default)

def test_new_preset_triggers_refresh(monkeypatch, tmp_path):
    default_preset = tmp_path / "default.json"
    default_preset.write_text(json.dumps({"kind": "drift", "parameters": {}}))

    monkeypatch.setattr(speh, "DEFAULT_PRESET", str(default_preset))
    monkeypatch.setattr(speh, "NEW_PRESET_DIR", str(tmp_path))
    monkeypatch.setattr(speh, "CORE_LIBRARY_DIR", str(tmp_path / "core"))

    monkeypatch.setattr(speh, "generate_dir_html", lambda *a, **k: "")
    monkeypatch.setattr(speh, "load_drift_schema", lambda: {})
    monkeypatch.setattr(speh, "extract_parameter_values", lambda p: {"success": True, "parameters": []})
    monkeypatch.setattr(speh, "extract_macro_information", lambda p: {"success": True, "macros": [], "mapped_parameters": {}})
    monkeypatch.setattr(speh, "extract_available_parameters", lambda p: {"success": True, "parameters": [], "parameter_paths": {}})

    called = {}
    def fake_refresh():
        called['done'] = True
        return True, "ok"
    monkeypatch.setattr(speh, "refresh_library", fake_refresh)

    handler = speh.SynthParamEditorHandler()
    form = SimpleForm({'action': 'new_preset', 'new_preset_name': 'Test'})
    result = handler.handle_post(form)

    assert called.get('done') is True
    assert "Library refreshed" in result['message']
    assert (tmp_path / "Test.ablpreset").exists()


リスト構造を反転させ、三角形の各メッシュにおける点 A、B、C に対応する 20 個のインデックスを持つ 3 つの上位リストを取得します。その後、`IndexGroup.ByIndices` ノードを使用して、3 つずつのインデックスによるインデックス グループを作成します。構造化された `IndexGroups` のリストと頂点のリストを `Mesh.ByPointsFaceIndices` の入力として使用することで、変換されたメッシュを取得します。

## サンプル ファイル

![Example](./Autodesk.DesignScript.Geometry.Mesh.VertexIndicesByTri_img.jpg)
<!--- Autodesk.DesignScript.Geometry.TSpline.TSplineSurface.ByTorusCoordinateSystemRadii --->
<!--- TTAJ2WGGNFLM755ADOCD3G7N4MJBQI66CAC7SXM3XCYLEIPLBOCQ --->
## In-Depth
次の例では、指定された座標系 `cs` を原点とする T スプライン トーラス サーフェスが作成されます。形状の短半径と長半径は、`innerRadius` および `outerRadius` の入力で設定します。`innerRadiusSpans` と `outerRadiusSpans` の値は、2 つの方向に沿ったサーフェスの定義をコントロールします。形状の初期対称性は `symmetry` 入力で指定します。形状に適用される軸対称が X 軸または Y 軸に対してアクティブである場合、トーラスの `outerRadiusSpans` の値は 4 の倍数でなければなりません。放射対称にはそのような要件はありません。最後に、`inSmoothMode` 入力を使用して、T スプライン サーフェスのスムーズ モードとボックス モードのプレビューを切り替えます。

## サンプル ファイル

![Example](./TTAJ2WGGNFLM755ADOCD3G7N4MJBQI66CAC7SXM3XCYLEIPLBOCQ_img.jpg)
<!--- Autodesk.DesignScript.Geometry.TSpline.TSplineSurface.BridgeFacesToEdges --->
<!--- DVNDD4ZUEDM4QCH35SLRIEZJLS266CIRRB7MZMMNDBI5W6UPBSQA --->
## 詳細
`TSplineSurface.BridgeToFacesToEdges` は、同じサーフェスまたは 2 つの異なるサーフェスのエッジのセットと面のセットを接続します。面を構成するエッジは、ブリッジの反対側のエッジの数と一致するか、その倍数である必要があります。ノードには、以下に説明する入力が必要です。ブリッジを生成するには最初の 3 つの入力で十分で、残りの入力は省略可能です。作成されるサーフェスは、最初のエッジのグループが属するサーフェスの子です。

- `TSplineSurface`: ブリッジするサ


f((c|0)==(h|0)){break a}c=c-h|0;qk(a+232|0,h,c);H[a+228>>2]=c;f=1;break g}J:{K:{L:{h=Ie(a,b);M:{if(!h){c=b>>>0>65535?44394:45022;b=47602;break M}if(J[h+12>>1]==65){c=0;g=H[a+236>>2];if((g|0)>0){break L}f=H[a+240>>2];break K}c=b>>>0>65535?44394:45022;b=H[h+16>>2]}d=H[a+628>>2];a=H[a>>2];H[e+8>>2]=b;H[e+4>>2]=c;H[e>>2]=a;Xa(d,45619,47316,e);break a}f=H[a+240>>2];while(1){d=N(c,12)+f|0;if(H[H[d>>2]>>2]==(b|0)){c=N(c,12)+f|0;f=H[c+8>>2];if(!f){break J}Ta(f);H[c+8>>2]=0;break J}c=c+1|0;if((g|0)!=(c|0)){continue}break}}c=g+1|0;H[a+236>>2]=c;c=Ue(f,N(c,12));if(!c){b=H[a+628>>2];H[e+32>>2]=H[a>>2];Xa(b,45619,48082,e+32|0);f=0;break a}H[a+240>>2]=c;d=(c+N(H[a+236>>2],12)|0)-12|0;H[d>>2]=h;H[d+4>>2]=0;H[d+8>>2]=0}c=H[h+8>>2]-1|0;if(c>>>0<=12){g=H[(c<<2)+63360>>2]}else{g=0}if(!g){b=H[a+628>>2];a=H[a>>2];c=H[h+8>>2];H[e+24>>2]=H[h+16>>2];H[e+20>>2]=c;H[e+16>>2]=a;Xa(b,45619,49048,e+16|0);f=0;break a}N:{if(I[h+15|0]){c=H[e+156>>2];H[e+156>>2]=c+4;c=H[c>>2];break N}c=1;O:{P:{f=G[h+6>>1];switch((f&65535)-65533|0){case 1:break P;case 0:case 2:break N;default:break O}}c=J[a+98>>1];break N}c=f}H[d+4>>2]=c;if(H[h+8>>2]==2){c=H[e+156>>2];H[e+156>>2]=c+4;qf(d+8|0,H[c>>2]);f=1;break g}c=Yb(a,g,c,49498);H[d+8>>2]=c;if(!c){break c}Q:{if(!(I[h+15|0]|J[h+6>>1]>65532)){i=H[d+4>>2];if((i|0)<2){break Q}}R:{S:{T:{f=H[h>>2];switch(f-321|0){case 0:case 15:break R;case 1:case 2:case 3:case 4:case 5:case 6:case 7:case 8:case 9:case 10:case 11:case 12:case 13:case 14:break S;default:break T}}if((f|0)==297|(f|0)==530){break R}}f=H[e+


val searchId = id.toIntOrNull()
            ?: run {
                xLogW("Invalid ID format for searchById: $id")
                return null
            }
        return try {
            api.getMangaDetails(searchId)
        } catch (e: Exception) {
            xLogW("Error during searchById '$id': ${e.message}", e)
            null
        }
    }
    // SY <--

    fun getIfAuthExpired(): Boolean {
        return trackPreferences.trackAuthExpired(this).get()
    }

    fun setAuthExpired() {
        trackPreferences.trackAuthExpired(this).set(true)
    }

    fun saveOAuth(oAuth: MALOAuth?) {
        trackPreferences.trackToken(this).set(json.encodeToString(oAuth))
    }

    fun loadOAuth(): MALOAuth? {
        return try {
            json.decodeFromString<MALOAuth>(trackPreferences.trackToken(this).get())
        } catch (e: Exception) {
            null
        }
    }

    // KMK -->
    override fun hasNotStartedReading(status: Long): Boolean = status == PLAN_TO_READ
    // KMK <--
}
package eu.kanade.tachiyomi.data.track.anilist.dto

import eu.kanade.tachiyomi.data.database.models.Track
import eu.kanade.tachiyomi.data.track.TrackerManager
import eu.kanade.tachiyomi.data.track.anilist.Anilist
import eu.kanade.tachiyomi.data.track.anilist.AnilistApi
import eu.kanade.tachiyomi.data.track.model.TrackSearch
import eu.kanade.tachiyomi.util.lang.htmlDecode
import java.text.SimpleDateFormat
import java.util.Locale

data class ALManga(
    val remoteId: Long,
    val title: String,
    val imageUrl: String,
    val description: String?,
    val format: String,
    val publishingStatus: String,
    val startDateFuzzy: Long,
    val totalChapters: Long,
    val averageScore: Int,
    val staff: ALStaff,
) {
    fun toTrack() = TrackSearch.create(TrackerManager.ANILIST).apply {
        remote_id = remoteId
        title = this@ALManga.title
        total_chapters = totalChapters
        cover_url = imageUrl
        summary = description?.htmlDecode() ?: ""
        score = averageScore.toDouble()
        tracking_url = AnilistApi.mangaUrl(remote_id)
        publishing_status = publishingStatus
        publishing_type = format
        if (startDateFuzzy != 0L) {
            start_date = try {
                val outputDf = SimpleDateFormat("yyyy-MM-dd", Locale.US)
                outputDf.format(startDateFuzzy)
            } catch (e: IllegalArgumentException) {
                ""
            }
        }
        staff.edges.forEach {
            val name = it.node.name() ?: return@forEach
            if ("Story" in it.role) authors += name
            if ("Art" in it.role) artists += name
        }
    }
}

data class ALUserManga(
    val libraryId: Long,
    val listStatus: String,
    val scoreRaw: Int,
    val chaptersRead: Int,
    val startDateFuzzy: Long,
    val completedDateFuzzy: Long,
    val manga: ALManga,
    val private: Boolean,
) {
    fun toTrack() = Track.create(TrackerManager.ANILIST).apply {
        remote_id = manga.remoteId
        title = manga.title
        status = toTrackStatus()
        score = scoreRaw.toDouble()
        started_reading_date = startDateFuzzy
        finished_reading_date = completedDateFuzzy
        last_chapter_read = chaptersRead.toDou


                 "🚕",
	"blue_car":                              "🚙",
	"bus":                                   "🚌",
	"trolleybus":                            "🚎",
	"race_car":                              "🏎",
	"racing_car":                            "🏎",
	"police_car":                            "🚓",
	"ambulance":                             "🚑",
	"fire_engine":                           "🚒",
	"minibus":                               "🚐",
	"truck":                                 "🚚",
	"articulated_lorry":                     "🚛",
	"tractor":                               "🚜",
	"motorcycle":                            "🏍",
	"racing_motorcycle":                     "🏍",
	"bike":                                  "🚲",
	"rotating_light":                        "🚨",
	"oncoming_police_car":                   "🚔",
	"oncoming_bus":                          "🚍",
	"oncoming_automobile":                   "🚘",
	"oncoming_taxi":                         "🚖",
	"aerial_tramway":                        "🚡",
	"mountain_cableway":                     "🚠",
	"suspension_railway":                    "🚟",
	"railway_car":                           "🚃",
	"train":                                 "🚋",
	"monorail":                              "🚝",
	"bullettrain_side":                      "🚄",
	"bullettrain_front":                     "🚅",
	"light_rail":                            "🚈",
	"mountain_railway":                      "🚞",
	"steam_locomotive":                      "🚂",
	"train2":                                "🚆",
	"metro":                                 "🚇",
	"tram":                                  "🚊",
	"station":                               "🚉",
	"helicopter":                            "🚁",
	"airplane_small":                        "🛩",
	"small_airplane":                        "🛩",
	"airplane":                              "✈",
	"airplane_departure":                    "🛫",
	"airplane_arriving":                     "🛬",
	"sailboat":                              "⛵",
	"motorboat":                             "🛥",
	"speedboat":                             "🚤",
	"ferry":                                 "⛴",
	"cruise_ship":                           "🛳",
	"passenger_ship":                        "🛳",
	"rocket":                                "🚀",
	"satellite_orbital":                     "🛰",
	"seat":                                  "💺",
	"anchor":                                "⚓",
	"construction":                          "🚧",
	"fuelpump":                              "⛽",
	"busstop":                               "🚏",
	"vertical_traffic_light":                "🚦",
	"traffic_light":                         "🚥",
	"checkered_flag":                        "🏁",
	"ship":                                  "🚢",
	"ferris_wheel":                          "🎡",
	"roller_coaster":                        "🎢",
	"carousel_horse":                        "🎠",
	"construction_site":                     "🏗",
	"building_construction":                 "🏗",
	"foggy":                                 "🌁",
	"tokyo_tower":                           "🗼",
	"factory":                               "🏭",
	"fountain":                              "⛲",
	"rice_scene":                            "🎑",
	"mountain":                              "⛰",
	"mountain_snow":                         "🏔",
	"snow_c


   /**
     *
     * @description 编辑数据
     * @date 2020-07-19 14:16:19
     * @author
     * @param payHead
     * @param bindingResult
     * @param model
     * @return String
     *
     */
    @RequestMapping("editApInvoiceHead")
    public String editApInvoiceHead(@Valid ApInvoiceHead payHead, BindingResult bindingResult, Model model, RedirectAttributes attr) {
        //参数校验
        Map<String, String> errorMap = this.validateParameters(bindingResult, model);
        if(errorMap.size()>0) {
            return "forward:getApInvoiceHead";
        }

        try {
            //对当前编辑的对象初始化默认的字段
            payHead.setApType("Invoice");
            payHead.setInvoiceType("PO_INVOICE");

            //保存编辑的数据
            this.apInvoiceHeadService.insertOrUpdateDataObject(payHead);
            //提示信息
            attr.addFlashAttribute("hint", "success");
            attr.addAttribute("invoiceHeadCode", payHead.getInvoiceHeadCode());
        }catch(Exception e){
            if(e.getCause().getClass()==ConstraintViolationException.class) {
                //提示信息
                attr.addFlashAttribute("hint", "hint");
                attr.addFlashAttribute("alertMessage", "发票编码已存在请重新输入");
                return "redirect:getApInvoiceHeadList";
            }else {
                throw e;
            }
        }

        return "redirect:getApInvoiceHead";
    }

    /**
     *
     * @description 删除数据
     * @date 2020-07-19 14:16:19
     * @author
     * @param payHead
     * @return String
     *
     */
    @RequestMapping("deleteApInvoiceHead")
    public String deleteApInvoiceHead(ApInvoiceHead payHead, RedirectAttributes attr) {
        //删除数据前验证数据
        if(payHead!=null&&payHead.getInvoiceHeadId()!=null) {
            if(payHead.getStatus().equals("NEW")) {
                //删除数据
                this.apInvoiceHeadService.deleteDataObject(payHead);

                //提示信息
                attr.addFlashAttribute("hint", "success");
            }else {
                //提示信息
                attr.addFlashAttribute("hint", "hint");
                attr.addFlashAttribute("alertMessage", "非新建状态的发票不能删除");
            }
        }

        return "redirect:getApInvoiceHeadList";
    }

    /**
     *
     * @description 更新审批状态
     * @date 2020年8月4日
     * @author dongbin
     * @param code
     * @param approveStatus
     * @param attr
     * @return
     * @return String
     *
     */
    @RequestMapping("updateApproveStatus")
    public String updateApproveStatus(String code, String approveStatus, RedirectAttributes attr) {

        if(StringUtils.isNotBlank(code)&&StringUtils.isNotBlank(approveStatus)) {
            if(approveStatus.equals("UNSUBMIT")) {
                boolean payFlag = this.apPayHeadService.isExistApPayRelateApInvoice(code);
                if(payFlag) {
                    //提示信息
                    attr.addFlashAttribute("hint", "hint");
                    attr.addFlashAttribute("alertMessage", "当前发票已付款核销不能变更");
                    attr.addAttribute("invoiceHeadCode", code);
                    return "redirect:getApInvoiceHead";


lobally visible in JS as window.Go in the browser or exports.Go in nodejs
	// TODO consider how to make Go/Haxe libs available across all platforms
	return `
#if js
@:expose("Go")
#end
class Go
{

	public static function Platform():String { // codes returned the same as used by Haxe
    #if flash
    	return "flash";
    #elseif js
    	return "js";
    #elseif cpp
    	return "cpp";
    #elseif java
    	return "java";
    #elseif cs
    	return "cs";
    #elseif python
    	#error "SORRY: the python target is not yet ready for general use"
    	return "python";
    #elseif php
    	return "php";
    #elseif neko
    	return "neko";
    #else
        #error "Only the js, flash, cpp (C++), java, cs (C#), php, python and neko Haxe targets are supported as a Go platform"
    #end
	}
`
}

// end the main Go class
func (l langType) GoClassEnd(pkg *ssa.Package) string {
	// init function
	main := "public static var doneInit:Bool=false;\n"                                                          // flag to run this routine only once
	main += "\npublic static function init() : Void {\ndoneInit=true;\nvar gr:Int=Scheduler.makeGoroutine();\n" // first goroutine number is always 0
	main += `if(gr!=0) throw "non-zero goroutine number in init";` + "\n"                                       // first goroutine number is always 0, NOTE using throw as panic not setup

	main += "var _sfgr=new Go_haxegoruntime_init(gr,[]).run();\n" //haxegoruntime.init() NOTE can't use .hx() to call from Haxe as that would call this fn
	main += `Go.haxegoruntime_ZZiLLen.store_uint32('字'.length);`  // value required by haxegoruntime to know what type of strings we have
	main += "while(_sfgr._incomplete) Scheduler.runAll();\n"
	main += "var _sf=new Go_" + l.LangName(pkg.Pkg.Path(), "init") + `(gr,[]).run();` + "\n" //NOTE can't use .hx() to call from Haxe as that would call this fn
	main += "while(_sf._incomplete) Scheduler.runAll();\n"
	main += ""
	main += "Scheduler.doneInit=true;\n"
	main += "}\n"
	// Haxe main function, only called in a go-only environment,
	// or ends with a call to haxegoruntime.BrowserMain() to set-up JS timed callbacks
	main += "\npublic static function main() : Void {\n"
	main += "Go_" + l.LangName(pkg.Pkg.Path(), "main") + `.hx();` + "\n"
	main += "}\n"

	pos := "public static function CPos(pos:Int):String {\nvar prefix:String=\"\";\n"
	pos += fmt.Sprintf(`if (pos==%d) return "(No File Position Hash)";`, pogo.NoPosHash) + "\n"
	pos += "if (pos<0) { pos = -pos; prefix= \"near \";}\n"
	for p := len(l.PogoComp().PosHashFileList) - 1; p >= 0; p-- {
		pos += fmt.Sprintf(`if(pos>%d) return prefix+"%s:"+Std.string(pos-%d);`,
			l.PogoComp().PosHashFileList[p].BasePosHash,
			strings.Replace(l.PogoComp().PosHashFileList[p].FileName, "\\", "\\\\", -1),
			l.PogoComp().PosHashFileList[p].BasePosHash) + "\n"
	}
	pos += "return \"(invalid File Position Hash:\"+Std.string(pos)+\")\";\n}\n"

	if l.PogoComp().Debug


               "        " // Each of these is 8 spaces, and there are 8.
                     "        " // In total there are 65 spaces
                     "        " // 'a' + 65 spaces + '\0' = 67
                     "        "
                     "        "
                     "        "
                     "        "
                     "        ");

  // passing null as the output pointer is allowed as long as buffsz is 0.
  written = call_vsnprintf(nullptr, 0, "%s and more", "1234567890");
  EXPECT_EQ(written, 19);
}

TEST(LlvmLibcVSNPrintfTest, NoCutOff) {
  char buff[64];
  int written;

  written = call_vsnprintf(buff, 37, "A simple string with no conversions.");
  EXPECT_EQ(written, 36);
  ASSERT_STREQ(buff, "A simple string with no conversions.");

  written = call_vsnprintf(buff, 20, "%s", "1234567890");
  EXPECT_EQ(written, 10);
  ASSERT_STREQ(buff, "1234567890");
}
//===-- Unittests for remove ----------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "src/fcntl/open.h"
#include "src/stdio/remove.h"
#include "src/sys/stat/mkdirat.h"
#include "src/unistd/access.h"
#include "src/unistd/close.h"
#include "test/UnitTest/ErrnoSetterMatcher.h"
#include "test/UnitTest/Test.h"

#include "src/errno/libc_errno.h"
#include <unistd.h>

TEST(LlvmLibcRemoveTest, CreateAndRemoveFile) {
  // The test strategy is to create a file and remove it, and also verify that
  // it was removed.
  LIBC_NAMESPACE::libc_errno = 0;
  using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Fails;
  using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;

  constexpr const char *FILENAME = "remove.test.file";
  auto TEST_FILE = libc_make_test_file_path(FILENAME);
  int fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
  ASSERT_ERRNO_SUCCESS();
  ASSERT_GT(fd, 0);
  ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));

  ASSERT_THAT(LIBC_NAMESPACE::access(TEST_FILE, F_OK), Succeeds(0));
  ASSERT_THAT(LIBC_NAMESPACE::remove(TEST_FILE), Succeeds(0));
  ASSERT_THAT(LIBC_NAMESPACE::access(TEST_FILE, F_OK), Fails(ENOENT));
}

TEST(LlvmLibcRemoveTest, CreateAndRemoveDir) {
  // The test strategy is to create a dir and remove it, and also verify that
  // it was removed.
  LIBC_NAMESPACE::libc_errno = 0;
  using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Fails;
  using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
  constexpr const char *FILENAME = "remove.test.dir";
  auto TEST_DIR = libc_make_test_file_path(FILENAME);
  ASSERT_THAT(LIBC_NAMESPACE::mkdirat(AT_FDCWD, TEST_DIR, S_IRWXU),
              Succeeds(0));

  ASSERT_THAT(LIBC_NAMESPACE::access(TEST_DIR, F_OK), Succeeds(0));
  ASSERT_THAT(LIBC_NAMESPACE::remove(TEST_DIR), Succeeds(0));
  ASSERT_THAT(LIBC_NAMESPACE::access(TEST_DIR, F_OK), Fails(ENOENT));
}

TEST(LlvmLibcRemoveTest, RemoveNonExistent) {
  using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Fails;
  ASSERT_THAT(LIBC_NAMESPACE::