 gl

		gl.enable( gl.CULL_FACE );
		gl.enable( gl.DEPTH_TEST );
		gl.depthMask( true );

		renderer.resetGLState();

	};

	function createProgram ( shader ) {

		var program = gl.createProgram();

		var fragmentShader = gl.createShader( gl.FRAGMENT_SHADER );
		var vertexShader = gl.createShader( gl.VERTEX_SHADER );

		var prefix = "precision " + renderer.getPrecision() + " float;\n";

		gl.shaderSource( fragmentShader, prefix + shader.fragmentShader );
		gl.shaderSource( vertexShader, prefix + shader.vertexShader );

		gl.compileShader( fragmentShader );
		gl.compileShader( vertexShader );

		gl.attachShader( program, fragmentShader );
		gl.attachShader( program, vertexShader );

		gl.linkProgram( program );

		return program;

	}

};

// File:src/renderers/webgl/plugins/ShadowMapPlugin.js

/**
 * @author alteredq / http://alteredqualia.com/
 */

THREE.ShadowMapPlugin = function ( _renderer, _lights, _webglObjects, _webglObjectsImmediate ) {

	var _gl = _renderer.context;

	var _depthMaterial, _depthMaterialMorph, _depthMaterialSkin, _depthMaterialMorphSkin,

	_frustum = new THREE.Frustum(),
	_projScreenMatrix = new THREE.Matrix4(),

	_min = new THREE.Vector3(),
	_max = new THREE.Vector3(),

	_matrixPosition = new THREE.Vector3(),

	_renderList = [];

	// init

	var depthShader = THREE.ShaderLib[ "depthRGBA" ];
	var depthUniforms = THREE.UniformsUtils.clone( depthShader.uniforms );

	_depthMaterial = new THREE.ShaderMaterial( {
		uniforms: depthUniforms,
		vertexShader: depthShader.vertexShader,
		fragmentShader: depthShader.fragmentShader
	 } );

	_depthMaterialMorph = new THREE.ShaderMaterial( {
		uniforms: depthUniforms,
		vertexShader: depthShader.vertexShader,
		fragmentShader: depthShader.fragmentShader,
		morphTargets: true
	} );

	_depthMaterialSkin = new THREE.ShaderMaterial( {
		uniforms: depthUniforms,
		vertexShader: depthShader.vertexShader,
		fragmentShader: depthShader.fragmentShader,
		skinning: true
	} );

	_depthMaterialMorphSkin = new THREE.ShaderMaterial( {
		uniforms: depthUniforms,
		vertexShader: depthShader.vertexShader,
		fragmentShader: depthShader.fragmentShader,
		morphTargets: true,
		skinning: true
	} );

	_depthMaterial._shadowPass = true;
	_depthMaterialMorph._shadowPass = true;
	_depthMaterialSkin._shadowPass = true;
	_depthMaterialMorphSkin._shadowPass = true;

	this.render = function ( scene, camera ) {

		if ( _renderer.shadowMapEnabled === false ) return;

		var i, il, j, jl, n,

		shadowMap, shadowMatrix, shadowCamera,
		buffer, material,
		webglObject, object, light,

		lights = [],
		k = 0,

		fog = null;

		// set GL state for depth map

		_gl.clearColor( 1, 1, 1, 1 );
		_gl.disable( _gl.BLEND );

		_gl.enable( _gl.CULL_FACE );
		_gl.frontFace( _gl.CCW );

		if ( _renderer.shadowMapCullFace === THREE.CullFaceFront ) {

			_gl.cullFace( _gl.FRONT );

		} else {

			_gl.cullFace( _gl.BACK );

		}

		_renderer.state.setDepthTest( true );

		// preprocess lights
		// 	- skip lights that are not casting shadows
		//	- create virtual lights for cascaded shadow maps

		for ( i = 0, il = _lights.length; i


re";
    public static final String TYPE_NAME_LTREE = "ltree";
    public static final String TYPE_NAME_ISBN = "isbn";
    public static final String TYPE_NAME_VECTOR = "vector";
    public static final String TYPE_NAME_HALF_VECTOR = "halfvec";
    public static final String TYPE_NAME_SPARSE_VECTOR = "sparsevec";

    public static final String TYPE_NAME_HSTORE_ARRAY = "_hstore";
    public static final String TYPE_NAME_GEOGRAPHY_ARRAY = "_geography";
    public static final String TYPE_NAME_GEOMETRY_ARRAY = "_geometry";
    public static final String TYPE_NAME_CITEXT_ARRAY = "_citext";
    public static final String TYPE_NAME_LTREE_ARRAY = "_ltree";
    public static final String TYPE_NAME_TSVECTOR = "tsvector";

    public static final int NO_TYPE_MODIFIER = -1;
    public static final int UNKNOWN_LENGTH = -1;

    // PostgreSQL driver reports user-defined Domain types as Types.DISTINCT
    public static final int DOMAIN_TYPE = Types.DISTINCT;

    private static final String CATEGORY_ARRAY = "A";
    private static final String CATEGORY_ENUM = "E";

    private static final String SQL_ENUM_VALUES = "SELECT t.enumtypid as id, array_agg(t.enumlabel) as values "
            + "FROM pg_catalog.pg_enum t GROUP BY id";

    private static final String SQL_TYPES = "SELECT t.oid AS oid, t.typname AS name, t.typelem AS element, t.typbasetype AS parentoid, t.typtypmod as modifiers, t.typcategory as category, e.values as enum_values "
            + "FROM pg_catalog.pg_type t "
            + "JOIN pg_catalog.pg_namespace n ON (t.typnamespace = n.oid) "
            + "LEFT JOIN (" + SQL_ENUM_VALUES + ") e ON (t.oid = e.id) "
            + "WHERE n.nspname != 'pg_toast'";

    private static final String SQL_NAME_LOOKUP = SQL_TYPES + " AND t.typname = ?";

    private static final String SQL_OID_LOOKUP = SQL_TYPES + " AND t.oid = ?";

    private static final Map<String, String> LONG_TYPE_NAMES = Collections.unmodifiableMap(getLongTypeNames());

    private static Map<String, String> getLongTypeNames() {
        Map<String, String> longTypeNames = new HashMap<>();

        longTypeNames.put("bigint", "int8");
        longTypeNames.put("bit varying", "varbit");
        longTypeNames.put("boolean", "bool");
        longTypeNames.put("character", "bpchar");
        longTypeNames.put("character varying", "varchar");
        longTypeNames.put("double precision", "float8");
        longTypeNames.put("integer", "int4");
        longTypeNames.put("real", "float4");
        longTypeNames.put("smallint", "int2");
        longTypeNames.put("timestamp without time zone", "timestamp");
        longTypeNames.put("timestamp with time zone", "timestamptz");
        longTypeNames.put("time without time zone", "time");
        longTypeNames.put("time with time zone", "timetz");

        return longTypeNames;
    }

    private final Map<String, PostgresType> nameToType = new HashMap<>();
    private final Map<Integer, PostgresType> oidToType = new HashMap<>();

    private final PostgresConnection connection;
    private final SqlTypeMapper sqlTypeMapper;

    private int geometryOid = Integer.MIN_VALUE;
    private int geographyOid = Integer.MIN_VALUE;
    private int citextOid = Integer.MIN_VALUE;
    private int hstoreOid = Integer.MIN_VALUE;
    private int ltreeOid = Integer.MIN_VALUE;
    private int isbnOid = Integer.MIN_VALUE;

    private int vectorOid = Integer.MIN_VALUE;
    private int halfVectorOid = Integer.MIN_VALUE;
    private int sparseVectorOid = Integer.MIN_VALUE;

    private int hstoreArrayOid = Integer.MIN_VALUE;
    private int geometryArrayOid = Integer.MIN_VALUE


()) }
        }
    }

    override fun getIconHeight(): Int {
        return width
    }

    override fun getIconWidth(): Int {
        return height
    }

    override @Synchronized fun setDimension(newDimension: Dimension) {
        width = newDimension.width
        height = newDimension.height
    }

    override fun supportsColorFilter(): Boolean {
        return true
    }

    override fun setColorFilter(colorFilter: RadianceIcon.ColorFilter?) {
        this.colorFilter = colorFilter
    }

    override @Synchronized fun paintIcon(c: Component?, g: Graphics, x: Int, y: Int) {
        val g2d = g.create() as Graphics2D
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON)
        g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                RenderingHints.VALUE_INTERPOLATION_BICUBIC)
        g2d.translate(x, y)

        val coef1 = this.width.toDouble() / getOrigWidth()
        val coef2 = this.height.toDouble() / getOrigHeight()
        val coef = Math.min(coef1, coef2)
        g2d.clipRect(0, 0, this.width, this.height)
        g2d.scale(coef, coef)
        g2d.translate(-getOrigX(), -getOrigY())
        if (coef1 != coef2) {
            if (coef1 < coef2) {
                val extraDy = ((getOrigWidth() - getOrigHeight()) / 2.0).toInt()
                g2d.translate(0, extraDy)
            } else {
                val extraDx = ((getOrigHeight() - getOrigWidth()) / 2.0).toInt()
                g2d.translate(extraDx, 0)
            }
        }
        val g2ForInner = g2d.create() as Graphics2D
        innerPaint(g2ForInner)
        g2ForInner.dispose()
        g2d.dispose()
    }
}

/*
 * Copyright (c) 2005-2025 Radiance Kirill Grouchnikov. All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *  o Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 *  o Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 *  o Neither the name of the copyright holder nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
package org.pushingpixels.radiance.demo.component.ktx.common

import org.pushingpixels.radiance.common.api.RadianceCommonCortex
import org.pushingpixels.radiance.common.api.icon.RadianceIcon
import org.pushingpixels.radiance.component.api.bcb.BreadcrumbItem
impor


->fLeft, src.fLeft);
    dst->fTop = SkMinScalar(dst->fTop, src.fTop);
    dst->fRight = SkMaxScalar(dst->fRight, src.fRight);
    dst->fBottom = SkMaxScalar(dst->fBottom, src.fBottom);
}

static bool is_degenerate(const SkPath& path) {
    return path.countVerbs() <= 1;
}

class SkAutoDisableDirectionCheck {
public:
    SkAutoDisableDirectionCheck(SkPath* path) : fPath(path) {
        fSaved = static_cast<SkPathPriv::FirstDirection>(fPath->getFirstDirection());
    }

    ~SkAutoDisableDirectionCheck() {
        fPath->setFirstDirection(fSaved);
    }

private:
    SkPath*                     fPath;
    SkPathPriv::FirstDirection  fSaved;
};
#define SkAutoDisableDirectionCheck(...) SK_REQUIRE_LOCAL_VAR(SkAutoDisableDirectionCheck)

/*  This guy's constructor/destructor bracket a path editing operation. It is
    used when we know the bounds of the amount we are going to add to the path
    (usually a new contour, but not required).

    It captures some state about the path up front (i.e. if it already has a
    cached bounds), and then if it can, it updates the cache bounds explicitly,
    avoiding the need to revisit all of the points in getBounds().

    It also notes if the path was originally degenerate, and if so, sets
    isConvex to true. Thus it can only be used if the contour being added is
    convex.
 */
class SkAutoPathBoundsUpdate {
public:
    SkAutoPathBoundsUpdate(SkPath* path, const SkRect& r) : fPath(path), fRect(r) {
        // Cannot use fRect for our bounds unless we know it is sorted
        fRect.sort();
        // Mark the path's bounds as dirty if (1) they are, or (2) the path
        // is non-finite, and therefore its bounds are not meaningful
        fHasValidBounds = path->hasComputedBounds() && path->isFinite();
        fEmpty = path->isEmpty();
        if (fHasValidBounds && !fEmpty) {
            joinNoEmptyChecks(&fRect, fPath->getBounds());
        }
        fDegenerate = is_degenerate(*path);
    }

    ~SkAutoPathBoundsUpdate() {
        fPath->setConvexity(fDegenerate ? SkPath::kConvex_Convexity
                                        : SkPath::kUnknown_Convexity);
        if ((fEmpty || fHasValidBounds) && fRect.isFinite()) {
            fPath->setBounds(fRect);
        }
    }

private:
    SkPath* fPath;
    SkRect  fRect;
    bool    fHasValidBounds;
    bool    fDegenerate;
    bool    fEmpty;
};
#define SkAutoPathBoundsUpdate(...) SK_REQUIRE_LOCAL_VAR(SkAutoPathBoundsUpdate)

////////////////////////////////////////////////////////////////////////////

/*
    Stores the verbs and points as they are given to us, with exceptions:
    - we only record "Close" if it was immediately preceeded by Move | Line | Quad | Cubic
    - we insert a Move(0,0) if Line | Quad | Cubic is our first command

    The iterator does more cleanup, especially if forceClose == true
    1. If we encounter degenerate segments, remove them
    2. if we encounter Close, return a cons'd up Line() first (if the curr-pt != start-pt)
    3. if we encounter Move without a preceeding Close, and forceClose is true, goto #2
    4. if we encounter Line | Quad | Cubic after Close, cons up a Move
*/

////////////////////////////////////////////////////////////////////////////

// flag to require a moveTo if we begin with som


data: ArchwebPackage {
                        pkgname: String::from("test"),
                        pkgver: String::from("0.1"),
                        pkgrel: String::from("2"),
                        ..ArchwebPackage::default()
                    },
                    status: Status::Good,
                    build_id: 0,
                },
                Package {
                    data: ArchwebPackage {
                        pkgname: String::from("xyz"),
                        pkgver: String::from("0.4"),
                        pkgrel: String::from("1"),
                        ..ArchwebPackage::default()
                    },
                    status: Status::Bad,
                    build_id: 0,
                },
            ],
            false,
            None,
            &mut output,
        )?;
        assert_eq!(
            "[+] test 0.1-2 GOOD \n[-] xyz 0.4-1 BAD  \n",
            str::from_utf8(&output)?
        );
        Ok(())
    }
}
use crate::math::{degrees_to_radians, Vec3, R};
use crate::ray::Ray;

pub struct Camera {
    origin: Vec3,
    lower_left_corner: Vec3,
    horizontal: Vec3,
    vertical: Vec3,
    u: Vec3,
    v: Vec3,
    w: Vec3,
    lens_radius: R,
}

impl Camera {
    pub fn new(
        eye: Vec3,
        target: Vec3,
        up_dir: Vec3,
        v_fov_degrees: R,
        aspect_ratio: R,
        aperture: R,
        depth_of_field: R,
    ) -> Self {
        let theta = degrees_to_radians(v_fov_degrees);
        let h = (theta / 2.).tan();

        let viewport_height = 2.0 * h;
        let viewport_width = aspect_ratio * viewport_height;

        let w = (eye - target).unit_vector();
        let u = (up_dir.cross(w)).unit_vector();
        let v = w.cross(u);

        let origin = eye;
        let horizontal = depth_of_field * viewport_width * u;
        let vertical = depth_of_field * viewport_height * v;
        let lower_left_corner = origin - horizontal / 2. - vertical / 2. - depth_of_field * w;

        let lens_radius = depth_of_field / 2.;

        Self {
            origin,
            lower_left_corner,
            horizontal,
            vertical,
            w,
            u,
            v,
            lens_radius,
        }
    }

    pub fn get_ray(&self, u: R, v: R) -> Ray {
        let rd = self.lens_radius * Vec3::random_in_unit_disk();
        let offset = self.u * rd.x + self.v * rd.y;

        Ray::new(
            self.origin + offset,
            self.lower_left_corner + u * self.horizontal + v * self.vertical - self.origin - offset,
        )
    }
}
<filename>src/pages/home.rs
use yew::{html, Component};

pub struct HomePage;

impl Component for HomePage {
    type Message = ();
    type Properties = ();

    fn change(&mut self, _props: Self::Properties) -> yew::ShouldRender {
        false
    }

    fn update(&mut self, _msg: Self::Message) -> yew::ShouldRender {
        false
    }

    fn create(_props: Self::Properties, _link: yew::ComponentLink<Self>) -> Self {
        Self
    }

    fn view(&self) -> yew::Html {
        html! {


# copyright: sktime developers, BSD-3-Clause License (see LICENSE file)
"""Tests for singleton and multiton decorators."""

import pytest

from sktime.tests.test_switch import run_test_for_class
from sktime.utils.singleton import _multiton, _singleton

@_singleton
class _TestSingleton:
    def __init__(self, a=0):
        self.a = a

    def set_b(self, b):
        self.b = b

@_multiton
class _TestMultiton:
    def __init__(self, key, a=0):
        self.key = key
        self.a = a

    def set_b(self, b):
        self.b = b

@pytest.mark.skipif(
    not run_test_for_class(_singleton),
    reason="run test incrementally (if requested)",
)
def test_singleton():
    """Test singleton behaviour."""
    instance1 = _TestSingleton(42)
    instance1.set_b(43)
    instance2 = _TestSingleton()

    assert instance1 is instance2
    assert instance1.a == 42
    assert instance2.a == 42

    assert instance1.b == 43
    assert instance2.b == 43

    instance2.set_b(41)
    assert instance1.b == 41

@pytest.mark.skipif(
    not run_test_for_class(_multiton),
    reason="run test incrementally (if requested)",
)
def test_multiton():
    """Test multiton behaviour."""
    instance1 = _TestMultiton("key1", 42)
    instance1.set_b(43)
    instance2 = _TestMultiton("key2")
    instance2.set_b(44)

    instance1b = _TestMultiton("key1", 77)
    instance2b = _TestMultiton("key2")

    assert instance1 is not instance2
    assert instance1 is instance1b
    assert instance2 is instance2b

    assert instance1.a == 42
    assert instance2.a == 0
    assert instance1b.b == 43
    assert instance2.b == 44


  s: String?,
  length: Int,
): String? {
  if (s == null || s.length <= length) {
    return s
  }

  return s.substring(0, length - 3) + "..."
}

/**
 * Utility function for truncating strings with attribution to the platform for debugging purposes.
 * Factor out into separate class as necessary.
 *
 * TODO: should be private (once tests have been converted to kotlin
 */
fun truncateWithPlatformMessage(
  str: String?,
  maxWidth: Int,
): String? {
  if (str == null || str.length <= maxWidth) {
    return str
  }

  val maxWidthAdjusted = maxWidth - ATTRIBUTION_MESSAGE.length - 1
  // 4 is the min maxWidth of the Apache Lib we are using.
  val minMaxWidthApacheLib = 4
  if (maxWidthAdjusted < minMaxWidthApacheLib) {
    return str
  }

  return abbreviate(str, maxWidthAdjusted) + " " + ATTRIBUTION_MESSAGE
}
/*
 * Copyright (c) 2020-2025 Airbyte, Inc., all rights reserved.
 */

package io.airbyte.commons.auth.roles

object AuthRoleConstants {
  // TODO: replace "ADMIN" with "INSTANCE_ADMIN" and remove "EDITOR", "OWNER", etc
  // once all @Secured annotations are migrated to the new organization/workspace RBAC roles.
  const val ADMIN = "ADMIN"
  const val INSTANCE_ADMIN = "INSTANCE_ADMIN"
  const val AUTHENTICATED_USER = "AUTHENTICATED_USER"
  const val EDITOR = "EDITOR"
  const val OWNER = "OWNER"
  const val NONE = "NONE"
  const val READER = "READER"

  const val ORGANIZATION_ADMIN = "ORGANIZATION_ADMIN"
  const val ORGANIZATION_EDITOR = "ORGANIZATION_EDITOR"
  const val ORGANIZATION_RUNNER = "ORGANIZATION_RUNNER"
  const val ORGANIZATION_READER = "ORGANIZATION_READER"
  const val ORGANIZATION_MEMBER = "ORGANIZATION_MEMBER"

  const val WORKSPACE_ADMIN = "WORKSPACE_ADMIN"
  const val WORKSPACE_EDITOR = "WORKSPACE_EDITOR"
  const val WORKSPACE_RUNNER = "WORKSPACE_RUNNER"
  const val WORKSPACE_READER = "WORKSPACE_READER"

  const val EMBEDDED_END_USER = "EMBEDDED_END_USER"

  const val DATAPLANE = "DATAPLANE"

  // the 'SELF' role is used to secure endpoints that should only be called by the user themselves.
  // For example, creating an Airbyte User record for a particular authUserId should only be done
  // by callers that have authenticated as that authUserId.
  const val SELF = "SELF"
}
package com.youngfeng.android.assistant

/**
 * 该类主要用于定义通用常量.
 *
 * @author Scott Smith 2021/11/19 22:52
 */
object Constants {

    object Port {
        const val HTTP_SERVER = 9527
        const val UDP_DEVICE_DISCOVER = 20000
        const val CMD_SERVER = 20001
        const val HEARTBEAT_SERVER = 20002
    }

    const val PLATFORM_ANDROID = 1

    const val SEARCH_PREFIX = "search#"
    const val SEARCH_RES_PREFIX = "search_msg_received#"
    const val RANDOM_STR_SEARCH = "a2w0nuNyiD6vYogF"
    const val RADNOM_STR_RES_SEARCH = "RBIDoKFHLX9frYTh"

    const val KEEP_TEMP_ZIP_FILE_DURATION = 60 * 60


// along with MemoryEngine360. If not, see <https://www.gnu.org/licenses/>.
//

namespace MemEngine360.Engine.Events.XbdmEvents;

public class XbdmEventArgsDebugString : XbdmEventArgs {
    public string DebugString { get; }

    public uint Thread { get; init; }

    public bool IsThreadStop { get; init; }

    public XbdmEventArgsDebugString(string rawMessage, string debugString) : base(rawMessage) {
        this.DebugString = debugString;
    }

    public override string ToString() {
        return $"{this.GetType().Name} {{ Thread = 0x{this.Thread:X8}, IsThreadStop = {this.IsThreadStop}, String = \"{this.DebugString}\" }} [[[RAW = {this.RawMessage})]]]";
    }
}


 Successfully installed warpdrive-0.14.6
```

我们仍然需要Django，但我们绝对不希望在命令行上将其作为参数传递给'pip'以进行手动安装。相反，我们应该为"pip"在‘requirements.txt’文件中任何需要的Python包。因此，我们将创建一个“requirements.txt”，并在文件中只列出”Django。

即使到现在，我仍然没有真的想要手动运行‘pip’来建立一个Python Web应用程序项目，这样的话，它可以比安装必需的Python包更频繁的运行。例如，当与一个生产级WSGI服务器一起使用Django时，它一般会需要运行'python manage.py collectstatic'。这些措施虽然可能被用户遗忘。更好的方法是自动完成这样的步骤，并在必要时，将这些手动步骤记录在特殊的构建脚本中，这样，在为运行一个Python Web应用程序设置环境时，就可以自动运行。这就是‘warpdrive’发挥的作用。

现在，虽然我创建了一个Python虚拟环境，并安装了‘warpdrive’，但是它很干净，所以我安装了‘warpdrive’并显示它，否则我只是安装了一个空的Python。

我现在要做的事是为这个特定的Python Web应用程序建立一个单独的Python虚拟环境，但是让‘warpdrive’为我创建并设置它。

```py
> (warpdrive) $ eval "$(warpdrive activate mydjangosite)"
> (warpdrive+mydjangosite) $ warpdrive build
>  ----->; Installing dependencies with pip
> Collecting Django (from -r requirements.txt (line 1))
>  Downloading Django-1.9.2-py2.py3-none-any.whl (6.6MB)
>  100% |████████████████████████████████| 6.6MB 1.4MB/s
> Installing collected packages: Django
> Successfully installed Django-1.9.2
> Collecting mod-wsgi
> Installing collected packages: mod-wsgi
> Successfully installed mod-wsgi-4.4.22
>  ----->; Collecting static files for Django
> Copying ‘.../django/contrib/admin/static/admin/css/base.css’
> ...
>
> 56 static files copied to '/Users/graham/.warpdrive/warpdrive+mydjangosite/home/django_static_root'.
```

这里的第一步是使用‘warpdrive activate’创建一个新的Python虚拟环境，并将其用于当前的shell。第二步是使用‘warpdrive build’来设置我们的环境。

‘warpdrive build’命令在这里做一些事情，但主要的事情是，它安装在‘requirements.txt’ 文件中列出的所有Python包，安装‘mod_wsgi-express’，最后运行‘python manage.py collectstatic’。

你可能注意到，我们实际上并没有指定Django管理命令‘collectstatic’应该被执行。这是因为‘warpdrive’本身知道了Python Web应用程序可能会启动的各种方式，包括当你运行一个Django web应用程序时检测的特殊支持。知道你正在使用Django，它就会自动为你运行‘collectstatic’。

敏锐的人甚至可能会注意到，我们没有修改Django的设置模块，并指定‘STATIC_ROOT’从而使得“collectstatic”知道从哪里


d returns an expected amount. Clients should use
  /// this value as an advisory, and should be prepared to deal with
  /// either more or less data.
  /// @result The expected content length of the receiver, or -1 if
  /// there is no expectation that can be arrived at regarding expected
  /// content length.
  int get expectedContentLength {
    return _lib._objc_msgSend_190(_id, _lib._sel_expectedContentLength1);
  }

  /// !
  /// @abstract Returns the name of the text encoding of the receiver.
  /// @discussion This name will be the actual string reported by the
  /// origin source during the course of performing a protocol-specific
  /// URL load. Clients can inspect this string and convert it to an
  /// NSStringEncoding or CFStringEncoding using the methods and
  /// functions made available in the appropriate framework.
  /// @result The name of the text encoding of the receiver, or nil if no
  /// text encoding was specified.
  NSString? get textEncodingName {
    final _ret = _lib._objc_msgSend_44(_id, _lib._sel_textEncodingName1);
    return _ret.address == 0
        ? null
        : NSString._(_ret, _lib, retain: true, release: true);
  }

  /// !
  /// @abstract Returns a suggested filename if the resource were saved to disk.
  /// @discussion The method first checks if the server has specified a filename using the
  /// content disposition header. If no valid filename is specified using that mechanism,
  /// this method checks the last path component of the URL. If no valid filename can be
  /// obtained using the last path component, this method uses the URL's host as the filename.
  /// If the URL's host can't be converted to a valid filename, the filename "unknown" is used.
  /// In most cases, this method appends the proper file extension based on the MIME type.
  /// This method always returns a valid filename.
  /// @result A suggested filename to use if saving the resource to disk.
  NSString? get suggestedFilename {
    final _ret = _lib._objc_msgSend_44(_id, _lib._sel_suggestedFilename1);
    return _ret.address == 0
        ? null
        : NSString._(_ret, _lib, retain: true, release: true);
  }

  @override
  NSURLResponse init() {
    final _ret = _lib._objc_msgSend_2(_id, _lib._sel_init1);
    return NSURLResponse._(_ret, _lib, retain: true, release: true);
  }

  static NSURLResponse new1(PedometerBindings _lib) {
    final _ret = _lib._objc_msgSend_2(
      _lib._class_NSURLResponse1,
      _lib._sel_new1,
    );
    return NSURLResponse._(_ret, _lib, retain: false, release: true);
  }

  static NSURLResponse allocWithZone_(
    PedometerBindings _lib,
    ffi.Pointer<_NSZone> zone,
  ) {
    final _ret = _lib._objc_msgSend_3(
      _lib._class_NSURLResponse1,
      _lib._sel_allocWithZone_1,
      zone,
    );
    return NSURLResponse._(_ret, _lib, retain: false, release: true);
  }

  static NSURLResponse alloc(PedometerBindings _lib) {
    final _ret = _lib._objc_msgSend_2(
      _lib._class_NSURLResponse1,
      _lib._sel_alloc1,
    );
    return NSURLResponse._(_ret, _lib, retain: false, release: true);
  }

  static void cancelPreviousPerformRequestsWithTarget_selector_object_(
    PedometerBindings _lib,
    NSObject aTarget,
    ffi.Pointer<ObjCSel> aSelector,
    NSObject? anArgument,
  ) {
    _lib._objc_msgSend_14(
      _lib._class_NSURLResponse1,
      _lib._sel_cancelPreviousPerformRequestsWithTarget_selector_object_1,
      aTarget._id,
      aSelector,


shé ","折转":"zhé zhuǎn","折子":"zhé ","哲思":" sī","赭石":" shí","这边":"zhè ","这般":"zhè ","这次":"zhè ","这点":"zhè ","这儿":"zhè ","这个":"zhè gè","这么":"zhè me","这里":"zhè ","这些":"zhèi xiē","这样":"zhè ","贞观":" guān","贞节":" jié","贞女":" nǚ","针刺":" cì","针头":" tóu","针叶":" yè","侦查":" zhā","针织":" zhī","侦缉":" jī","珍藏":" cáng","珍奇":" qí","珍摄":" shè","珍重":" zhòng","真传":" chuán","真个":" gè","真菌":" jūn","真空":" kōng","真切":" qiè","真数":" shù","真率":" shuài","真相":" xiàng","真正":" zhèng","真知":" zhī","甄别":" bié","诊脉":" mài","枕骨":" gǔ","枕藉":" jiè","枕头":" tou","阵地":" dì","阵发":" fā","阵亡":" wáng","阵风":" fēng","阵雨":" yǔ","鸩毒":" dú","振臂":" bì","振兴":" xīng","镇长":" cháng","镇尺":" chǐ","镇服":" fú","镇压":" yā","震颤":" chàn","震区":" qū","震中":" zhōng","争吵":" chǎo","争得":" de","争斗":" dòu","争论":" lùn","争强":" qiáng","争抢":" qiǎng","征调":" diào","征发":" fā","征夫":" fū","征服":" fú","征剿":" jiǎo","征召":" zhào","挣揣":"zhèng chuài","挣命":"zhèng ","挣钱":"zhèng ","挣脱":"zhèng ","挣扎":"zhēng zhá","蒸发":" fā","蒸馏":" liú","蒸笼":" lóng","蒸散":" sàn","蒸食":" shí","整地":" dì","整个":" gè","整风":" fēng","整数":" shù","整齐":" qí","整宿":" sù","整体":" tǐ","整枝":" zhī","正本":"zhèng ","正比":"zhèng ","正步":"zhèng ","正餐":"zhèng ","正册":"zhèng ","正常":"zhèng ","正传":"zhèng zhuàn","正出":"zhèng ","正大":"zhèng dà","正旦":"zhēng ","正当":"zhèng dāng","正道":"zhèng ","正德":"zhèng ","正点":"zhèng ","正电":"zhèng ","正殿":"zhèng ","正定":"zhèng ","正法":"zhèng ","正犯":"zhèng ","正方":"zhèng ","正房":"zhèng ","正负":"zhèng ","正告":"zhèng ","正割":"zhèng ","正格":"zhèng ","正宫":"zhèng ","正骨":"zhèng gǔ","正规":"zhèng ","正轨":"zhèng ","正果":"zhèng ","正好":"zhèng hǎo","正话":"zhèng ","正号":"zhèng hào","正极":"zhèng ","正见":"zhèng jiàn","正解":"zhèng jiě","正教":"zh


from setuptools import setup

package_name = 'pure_pursuit'

setup(
    name=package_name,
    version='0.0.0',
    packages=[package_name],
    data_files=[
        ('share/ament_index/resource_index/packages',
            ['resource/' + package_name]),
        ('share/' + package_name, ['package.xml']),
    ],
    install_requires=['setuptools'],
    zip_safe=True,
    maintainer='zzangupenn, Hongrui Zheng',
    maintainer_email='zzang@seas.upenn.edu, billyzheng.bz@gmail.com',
    description='f1tenth pure_pursuit',
    license='MIT',
    tests_require=['pytest'],
    entry_points={
        'console_scripts': [
            'pure_pursuit_node = pure_pursuit.pure_pursuit_node:main',
        ],
    },
)


  padding: 0 50px;
  height: 64px;
  line-height: 64px;
}

.ant-layout-footer {
  padding: 24px 50px;
  color: rgba(0, 0, 0, 0.65);
  font-size: 12px;
}

.ant-layout-content {
  -webkit-box-flex: 1;
  -webkit-flex: auto;
  -ms-flex: auto;
  flex: auto;
}

.ant-layout-sider {
  -webkit-transition: all 0.15s cubic-bezier(0.645, 0.045, 0.355, 1);
  transition: all 0.15s cubic-bezier(0.645, 0.045, 0.355, 1);
  position: relative;
  background: #404040;
  /* fix firefox can't set width smaller than content on flex item */
  min-width: 0;
}

.ant-layout-sider-has-trigger {
  padding-bottom: 48px;
}

.ant-layout-sider-right {
  -webkit-box-ordinal-group: 2;
  -webkit-order: 1;
  -ms-flex-order: 1;
  order: 1;
}

.ant-layout-sider-trigger {
  position: absolute;
  text-align: center;
  width: 100%;
  bottom: 0;
  cursor: pointer;
  height: 48px;
  line-height: 48px;
  background: rgba(64, 64, 64, 0.88);
  color: #fff;
}

.ant-layout-sider-zero-width > * {
  overflow: hidden;
}

.ant-layout-sider-zero-width-trigger {
  position: absolute;
  top: 64px;
  right: -36px;
  text-align: center;
  width: 36px;
  height: 42px;
  line-height: 42px;
  background: #404040;
  color: #fff;
  font-size: 18px;
  border-radius: 0 4px 4px 0;
  cursor: pointer;
  -webkit-transition: background .3s ease;
  transition: background .3s ease;
}

.ant-layout-sider-zero-width-trigger:hover {
  background: #535353;
}

/* stylelint-disable at-rule-empty-line-before,at-rule-name-space-after,at-rule-no-unknown */

/* stylelint-disable declaration-bang-space-before */

/* stylelint-disable declaration-bang-space-before */

/* stylelint-disable at-rule-empty-line-before,at-rule-name-space-after,at-rule-no-unknown */

/* stylelint-disable declaration-bang-space-before */

/* stylelint-disable declaration-bang-space-before */

.ant-mention-wrapper {
  position: relative;
  display: inline-block;
  width: 100%;
  vertical-align: middle;
}

.ant-mention-wrapper .ant-mention-editor {
  position: relative;
  display: inline-block;
  padding: 4px 7px;
  width: 100%;
  height: 28px;
  cursor: text;
  font-size: 12px;
  color: rgba(0, 0, 0, 0.65);
  background-color: #fff;
  background-image: none;
  border: 1px solid #d9d9d9;
  border-radius: 4px;
  -webkit-transition: all .3s;
  transition: all .3s;
  line-height: 1.5;
  padding: 0;
  display: block;
}

.ant-mention-wrapper .ant-mention-editor::-moz-placeholder {
  color: rgba(0, 0, 0, 0.25);
  opacity: 1;
}

.ant-mention-wra


      fn $name() {
                Piece::from_pgn($input);
            }
        )*
        }
    }

    tests_panic_from_pgn! {
        test_from_pgn_invalid_1: "I", "Unrecognized piece: I",
        test_from_pgn_invalid_2: "1", "Unrecognized piece: 1",
        test_from_pgn_invalid_3: "H", "Unrecognized piece: H",
        test_from_pgn_invalid_4: "abcd", "Unrecognized piece: abcd",
        test_from_pgn_invalid_5: "1234", "Unrecognized piece: 1234",
    }
}

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

    macro_rules! tests_nominal_from_fen {
        ($($name:ident: $value:expr,)*) => {
        $(
            #[test]
            fn $name() {
                let (input, expected) = $value;
                assert_eq!(expected, Piece::from_fen(input));
            }
        )*
        }
    }

    tests_nominal_from_fen! {
        test_from_fen_pawn_lower: ("P", Piece::Pawn),
        test_from_fen_knight_lower: ("N", Piece::Knight),
        test_from_fen_bishop_lower: ("B", Piece::Bishop),
        test_from_fen_rook_lower: ("R", Piece::Rook),
        test_from_fen_queen_lower: ("Q", Piece::Queen),
        test_from_fen_king_lower: ("K", Piece::King),
        test_from_fen_pawn_upper: ("p", Piece::Pawn),
        test_from_fen_knight_upper: ("n", Piece::Knight),
        test_from_fen_bishop_upper: ("b", Piece::Bishop),
        test_from_fen_rook_upper: ("r", Piece::Rook),
        test_from_fen_queen_upper: ("q", Piece::Queen),
        test_from_fen_king_upper: ("k", Piece::King),
    }

    macro_rules! tests_panic_from_fen {
        ($($name:ident: $input:expr, $panic_str:expr,)*) => {
        $(
            #[test]
            #[should_panic(expected = $panic_str)]
            fn $name() {
                Piece::from_fen($input);
            }
        )*
        }
    }

    tests_panic_from_fen! {
        test_from_fen_invalid_1: "", "Unrecognized piece: ",
        test_from_fen_invalid_2: "1", "Unrecognized piece: 1",
        test_from_fen_invalid_3: "H", "Unrecognized piece: H",
        test_from_fen_invalid_4: "abcd", "Unrecognized piece: ABCD",
        test_from_fen_invalid_5: "1234", "Unrecognized piece: 1234",
    }
}
<gh_stars>10-100
//! Redundant-move elimination.

use crate::{Allocation, VReg};
use fxhash::FxHashMap;
use smallvec::{smallvec, SmallVec};

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum RedundantMoveState {
    Copy(Allocation, Option<VReg>),
    Orig(VReg),
    None,
}
#[derive(Clone, Debug, Default)]
pub struct RedundantMoveEliminator {
    allocs: FxHashMap<Allocation, RedundantMoveState>,
    reverse_allocs: FxHashMap<Allocation, SmallVec<[Allocation; 4]>>,
}
#[derive(Copy, Clone, Debug)]
pub struct RedundantMoveAction {
    pub elide: bool,
    #[cfg(feature = "checker")]
    pub def_alloc: Option<(


           data_memory.append(inputs[selected_indexes])
            targets_memory.append(targets[selected_indexes])

            class_means[class_idx, :] = examplar_mean

        data_memory = np.concatenate(data_memory)
        targets_memory = np.concatenate(targets_memory)

        return data_memory, targets_memory, herding_indexes, class_means

    def get_memory(self):
        return self._data_memory, self._targets_memory

    @staticmethod
    def compute_examplar_mean(feat_norm, feat_flip, indexes, nb_max):
        D = feat_norm.T
        D = D / (np.linalg.norm(D, axis=0) + EPSILON)

        D2 = feat_flip.T
        D2 = D2 / (np.linalg.norm(D2, axis=0) + EPSILON)

        selected_d = D[..., indexes]
        selected_d2 = D2[..., indexes]

        mean = (np.mean(selected_d, axis=1) + np.mean(selected_d2, axis=1)) / 2
        mean /= np.linalg.norm(mean) + EPSILON

        return mean

    @staticmethod
    def compute_accuracy(model, loader, class_means):
        features, targets_ = utils.extract_features(model, loader)

        features = (features.T / (np.linalg.norm(features.T, axis=0) + EPSILON)).T

        # Compute score for iCaRL
        sqd = cdist(class_means, features, "sqeuclidean")
        score_icarl = (-sqd).T

        return score_icarl, targets_

def _clean_list(l):
    for i in range(len(l)):
        l[i] = None


ирус не обновляет информацию в заголовке файла. При  запуске таких  файлов MS DOS  выдает диагностическое  сообщение "ERROR  in  EXE  File".  Такие  повреждения  можно  устранить,  запустив CHKDSK/F, а  затем соответствующий фаг. Как уже отмечалось, вирус иногда заражает файлы данных. Они могут быть восстановлены с помощью соответствующего фага.

Фаза проявления  привязана к дате 22 сентября, однако код в имеющихся экземплярах вируса  стерт в связи с недостаточным размером памяти, отведенным под  стек. Учитывая  наличие в  теле вируса загрузчика, выдающего сообщение "Фродо жив", логично предположить, что она связана с записью в бут-сектор этого  загрузчика. В результате первая же перезагрузка приведет к  выдаче на экран приведенного выше сообщения. Однако реально после 22 сентября  запуск любой зараженной программы вызывает зависание операционной системы (вирус зацикливается), создавая впечатление машинной неисправности. По  данным П.Хоффман, из-за ошибки в коде вирус может "сращивать" файлы на диске при манипулировании FAT и числом свободных секторов. Пользователь, использующий команду CHKDSK/F, обнаруживает, что файлы имеют потерянные кластеры или кластеры, принадлежащие двум файлам одновременно.

Вирус ориентирован на MS DOS 3.х и использует ряд недокументированных функций последней.  Работоспособность при  работе с  версиями 4.01 и 5.0 сомнительна, однако  автором не проверялась. Зависимости от типа используемого процессора  не выявлено. При экспериментах вирус успешно работал как на  XT, так  и на  AT/286. Вирус  несовместим с  сетевым программным обеспечением фирмы Novell.

Все авторы публикаций, включающих описание данного вируса, сходятся в том, что  вирус написан техно-крысой, хорошо знающей "внутренности" операционной системы и алгоритмы работы антивирусных программ. Есть основания предполагать,  что при  написании вируса  использованы идеи и метод


p(struct device *dev, struct device_attribute *da,
			const char *buf, size_t count)
{
	int res;
	long val;

	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	struct ds620_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;

	res = kstrtol(buf, 10, &val);

	if (res)
		return res;

	val = (clamp_val(val, -128000, 128000) * 10 / 625) * 8;

	mutex_lock(&data->update_lock);
	data->temp[attr->index] = val;
	i2c_smbus_write_word_swapped(client, DS620_REG_TEMP[attr->index],
				     data->temp[attr->index]);
	mutex_unlock(&data->update_lock);
	return count;
}

static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
			  char *buf)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	struct ds620_data *data = ds620_update_client(dev);
	struct i2c_client *client;
	u16 conf, new_conf;
	int res;

	if (IS_ERR(data))
		return PTR_ERR(data);

	client = data->client;

	/* reset alarms if necessary */
	res = i2c_smbus_read_word_swapped(client, DS620_REG_CONF);
	if (res < 0)
		return res;

	new_conf = conf = res;
	new_conf &= ~attr->index;
	if (conf != new_conf) {
		res = i2c_smbus_write_word_swapped(client, DS620_REG_CONF,
						   new_conf);
		if (res < 0)
			return res;
	}

	return sprintf(buf, "%d\n", !!(conf & attr->index));
}

static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp, set_temp, 1);
static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp, set_temp, 2);
static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL,
			  DS620_REG_CONFIG_TLF);
static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL,
			  DS620_REG_CONFIG_THF);

static struct attribute *ds620_attrs[] = {
	&sensor_dev_attr_temp1_input.dev_attr.attr,
	&sensor_dev_attr_temp1_min.dev_attr.attr,
	&sensor_dev_attr_temp1_max.dev_attr.attr,
	&sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
	&sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
	NULL
};

ATTRIBUTE_GROUPS(ds620);

static int ds620_probe(struct i2c_client *client,
		       const struct i2c_device_id *id)
{
	struct device *dev = &client->dev;
	struct device *hwmon_dev;
	struct ds620_data *data;

	data = devm_kzalloc(dev, sizeof(struct ds620_data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	data->client = client;
	mutex_init(&data->update_lock);

	/* Initialize the DS620 chip */
	ds620_init_client(client);

	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
							   data, ds620_groups);
	return PTR_ERR_OR_ZERO(hwmon_dev);
}

static const struct i2c_device_id ds620_id[] = {
	{"ds620", 0},
	{}
};

MODULE_DEVICE_TABLE(i2c, ds620_id);

/* This is the driver that will be inserted */
static struct i2c_driver ds620_driver = {
	.class = I2C_CLASS_HWMON,
	.driver = {
		   .name = "ds620",
	},
	.probe = ds620_probe,
	.id_table = ds620_id,
};

module_i2c_driver(ds620_driver);

MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
MODULE_DESCRIPTION("DS620 driver");
MODULE_LICENSE("GPL");


.955,873.701L176.46,905.206ZM135.504,883.153C130.634,892.196 132.273,903.362 139.536,910.625C146.798,917.888 157.965,919.526 167.008,914.657L135.504,883.153Z"
                        style="fill:none;stroke:black;stroke-width:1px;"></path>
                    <path
                        d="M1114.11,894.179C1114.11,873.627 1130.77,856.967 1151.33,856.967C1161.19,856.967 1170.66,860.887 1177.64,867.866C1184.62,874.845 1188.54,884.31 1188.54,894.179C1188.54,914.731 1171.88,931.392 1151.33,931.392C1130.77,931.392 1114.11,914.731 1114.11,894.179ZM1171.8,905.206C1176.67,896.163 1175.03,884.996 1167.77,877.733C1160.51,870.471 1149.34,868.832 1140.3,873.701L1171.8,905.206ZM1130.85,883.153C1125.98,892.196 1127.62,903.362 1134.88,910.625C1142.14,917.888 1153.31,919.526 1162.35,914.657L1130.85,883.153Z"
                        style="fill:rgb(255,0,0);"></path>
                    <path
                        d="M1114.11,894.179C1114.11,873.627 1130.77,856.967 1151.33,856.967C1161.19,856.967 1170.66,860.887 1177.64,867.866C1184.62,874.845 1188.54,884.31 1188.54,894.179C1188.54,914.731 1171.88,931.392 1151.33,931.392C1130.77,931.392 1114.11,914.731 1114.11,894.179ZM1171.8,905.206C1176.67,896.163 1175.03,884.996 1167.77,877.733C1160.51,870.471 1149.34,868.832 1140.3,873.701L1171.8,905.206ZM1130.85,883.153C1125.98,892.196 1127.62,903.362 1134.88,910.625C1142.14,917.888 1153.31,919.526 1162.35,914.657L1130.85,883.153Z"
                        style="fill:none;stroke:black;stroke-width:1px;"></path>
                    <rect height="45.26" style="fill-opacity:0;" width="270.236" x="369.764" y="871.548"></rect>
                    <rect height="25.6" style="fill:rgb(255,229,153);fill-rule:nonzero;" width="56.136" x="452.084"
                        y="880.548"></rect>
                    <path
                        d="M413.754,885.762L415.973,885.762L423.629,897.918L423.723,897.918L423.629,894.965L423.629,885.762L425.442,885.762L425.442,901.028L423.567,901.028L415.567,888.293L415.489,888.293L415.567,891.231L415.567,901.028L413.754,901.028L413.754,885.762ZM433.298,901.371C432.225,901.371 431.261,901


rstOrDefault(x => x.CurrentSlot == (uint)InventorySlots.SLOT_MAINHAND)?.Template.WeaponSpeed ?? 0) / 4;

            //Stat update
            foreach (Item item in equipped)
                foreach (ItemAttribute ia in item.Template.Attributes)
                    attributes[ia.ID] += ia.Value;

            character.Agility.ResetCurrent(true);
            character.Agility.Current = ((uint)attributes[(int)InventoryStats.AGILITY] + character.Agility.BaseAmount);
            character.Strength.ResetCurrent(true);
            character.Strength.Current = ((uint)attributes[(int)InventoryStats.STRENGTH] + character.Strength.BaseAmount);
            character.Stamina.ResetCurrent(true);
            character.Stamina.Current = ((uint)attributes[(int)InventoryStats.STAMINA] + character.Stamina.BaseAmount);
            character.Spirit.ResetCurrent(true);
            character.Spirit.Current = ((uint)attributes[(int)InventoryStats.SPIRIT] + character.Spirit.BaseAmount);
            character.Intellect.ResetCurrent(true);
            character.Intellect.Current = ((uint)attributes[(int)InventoryStats.INTELLECT] + character.Intellect.BaseAmount);
        }

        private void UpdateHealth()
        {
            uint baseStam = (character.Stamina.Current < 20 ? character.Stamina.Current : 20);
            uint moreStam = character.Stamina.Current - baseStam;
            character.Health.Maximum = character.Health.BaseAmount + baseStam + (moreStam * 10);
        }

        private void UpdateMana()
        {
            uint baseMana = (character.Intellect.Current < 20 ? character.Intellect.Current : 20);
            uint moreMana = character.Intellect.Current - baseMana;
            character.Mana.Maximum = character.Mana.BaseAmount + baseMana + (moreMana * 15);
        }

        private void UpdateDefenseBonusesMod()
        {
            character.BlockPercentage = 5f + ((character.Level * 5f) * 0.04f);
            character.ParryPercentage = 5f + ((character.Level * 5f) * 0.04f);
            character.DodgePercentage = 5f + ((character.Level * 5f) * 0.04f);
        }

        public float GetSpiritRegenRate()
        {
            float addValue = 0f;
            float spirit = character.Spirit.Current;

            switch (character.Class)
            {
                case (byte)Classes.CLASS_DRUID:
                case (byte)Classes.CLASS_PALADIN:
                case (byte)Classes.CLASS_WARLOCK:
                    addValue = (character.Spirit.Current / 5 + 15);
                    break;
                case (byte)Classes.CLASS_MAGE:
                case (byte)Classes.CLASS_PRIEST:
                    addValue = (character.Spirit.Current / 4 + 15);
                    break;
                case (byte)Classes.CLASS_SHAMAN:
                    addValue = (character.Spirit.Current / 5 + 17);
                    break;
            }
            return addValue /= 2.0f; //This returns the per second update amount
        }

    }
}


　企业名称＿＿＿＿＿＿＿＿所有制性质＿＿＿＿＿＿＿＿
　　企业地址＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
　　主管部门＿＿＿＿＿＿＿＿保证单位＿＿＿＿＿＿＿＿
　企业流动资金来源
　其中：自有资金
　　　　其它资金

申请借款金额

借款用途

还款时间

还款资金来源

申请
（盖章）

负责人（盖章）

企业

经办行审批意见

审批行意见

　　　　　　　　　建设银行工交企业流动资金贷款借据（正本）

　　借款企业名称：　　　　　　年　　月　　日　　　　　　　　企业编号：
贷款种类

贷款帐号

存款帐号

借款金额

人民币（大写）

亿千百十万千百十元角分

借款用途：

还款期限：

　　兹向你行借上列款项，到期由我单位主动归还，或从我单位存款中扣收，我单位愿遵守建设银行贷款办法的各项规定。
　企业负责人：　财务负责人：
　　　　　　　　　（企业公章）
　　　　　　　　　年　月　日

　　上述贷款，根据　　号借款合同，于　　年　　月　　日起用，月息　　‰，于　　年　　月　　日到期。
　经办人：
　　　　　　　　　（信贷部门签章）
　　　　　　　　　　　年　月　日

分　次　还　款　记　录

展　期　记　录

年

月

日

金额

年

月

日

金额

　　本借据由借款企业填写交银行信贷部门签章后，交会计部门凭以发放贷款，借还清后，注销借帐，借据退还借款企业

　　　　　　　　　　　　　　　　　　　　　合同编号：（　　年）第　　号

　　　　　　　　　　　　中国人民建设银行借款合同

　　　　　　　　　　（固定资产投资贷款类：　　贷款）

　　　借款单位：　　　　　　　　　　　　　贷款银行：
　　　地　　址：　　　　　　　　　　　　　地　　址：

　　　　　　　　　　　签订日期：　　年　　月　　日
　　　　　　借款单位（简称甲方）＿＿＿＿＿＿＿＿＿＿
立合同单位


_H;
  int INV_LN2;
  int LN2_L;
  int LN2_H;
  int LN2;
  int CP_L;
  int CP_H;
  int CP;
  int EXP_LIMIT_L;
  int EXP_LIMIT_H;
  int SQRT_3;
  int SQRT_2;
  int SQRT_1_5;
  int PIO2_3L;
  int PIO2_3;
  int PIO2_2L;
  int PIO2_2;
  int PIO2_1L;
  int PIO2_1;
  int PI_L;
  int PI_OVER_TWO;
  int TWO_OVER_PI;
  int TWO_1023;
  int TWO_66;
  int TWO_64;
  int TWO_60;
  int TWO_57;
  int TWO_54;
  int TWO_52;
  int TWO_49;
  int TWO_31;
  int TWO_29;
  int TWO_28;
  int TWO_27;
  int TWO_24;
  int TWO_20;
  int TWO_16;
  int PI;
  int E;
  int rand;
}
class StackTraceElement {
  int isNative;
  int methodName;
  int declaringClass;
  int lineNumber;
  int fileName;
  int serialVersionUID;
}
class StackOverflowError {
  int serialVersionUID;
}
class Short {
  int value;
  int shortCache;
  int MAX_CACHE;
  int MIN_CACHE;
  int SIZE;
  int TYPE;
  int MAX_VALUE;
  int MIN_VALUE;
  int serialVersionUID;
}
class SecurityManager {
  int inCheck;
  int current;
}
class SecurityException {
  int serialVersionUID;
}
class RuntimePermission {
  int serialVersionUID;
}
class RuntimeException {
  int serialVersionUID;
}
class Runtime {
  int current;
  int shutdownHooks;
  int exitSequence;
  int libpath;
}
class Runnable {
}
class ReflectiveOperationException {
  int serialVersionUID;
}
class Readable {
}
class ProcessBuilder {
  int redirect;
  int environment;
  int command;
  int directory;
}
class Process {
}
class Package {
  int loader;
  int sealed;
  int specVersion;
  int specVendor;
  int specTitle;
  int implVersion;
  int implVendor;
  int implTitle;
  int name;
}
class OutOfMemoryError {
  int serialVersionUID;
}
class Object {
}
class NumberFormatException {
  int serialVersionUID;
}
class Number {
  int digits;
  int serialVersionUID;
}
class NullPointerException {
  int serialVersionUID;
}
class NoSuchMethodException {
  int serialVersionUID;
}
class NoSuchMethodError {
  int serialVersionUID;
}
class NoSuchFieldException {
  int serialVersionUID;
}
class NoSuchFieldError {
  int serialVersionUID;
}
class NoClassDefFoundError {
  int serialVersionUID;
}
class NegativeArraySizeException {
  int serialVersionUID;
}
class Math {
  int PI;
  int E;
  int rand;
}
class Long {
  int value;
  int longCache;
  int MAX_CACHE;
  int MIN_CACHE;
  int SIZE;
  int TYPE;
  int MAX_VALUE;
  int MIN_VALUE;
  int serialVersionUID;
}
class LinkageError {
  int serialVersionUID;
}
class Iterable {
}
class InterruptedException {
  int


currentColor"></path>
              </svg>

            <template v-if="infoModal.clientSettings.expiryTime > 0">

                <template v-if="app.datepicker === 'gregorian'">
                  [[ DateUtil.formatMillis(infoModal.clientSettings.expiryTime) ]]
                </template>
                <template v-else>
                  [[ DateUtil.convertToJalalian(moment(infoModal.clientSettings.expiryTime)) ]]
                </template>

            </template>
            <a-tag v-else-if="infoModal.clientSettings.expiryTime < 0" color="green">[[ infoModal.clientSettings.expiryTime / -86400000 ]] {{ i18n "pages.client.days" }}

              <svg height="10px" width="14px" viewBox="0 0 640 512" fill="currentColor">
                <path d="M484.4 96C407 96 349.2 164.1 320 208.5C290.8 164.1 233 96 155.6 96C69.75 96 0 167.8 0 256s69.75 160 155.6 160C233.1 416 290.8 347.9 320 303.5C349.2 347.9 407 416 484.4 416C570.3 416 640 344.2 640 256S570.3 96 484.4 96zM155.6 368C96.25 368 48 317.8 48 256s48.25-112 107.6-112c67.75 0 120.5 82.25 137.1 112C276 285.8 223.4 368 155.6 368zM484.4 368c-67.75 0-120.5-82.25-137.1-112C364 226.2 416.6 144 484.4 144C543.8 144 592 194.2 592 256S543.8 368 484.4 368z" fill="currentColor"></path>
              </svg>

      <template v-if="app.subSettings.enable && infoModal.clientSettings.subId">
        Subscription URL

            Subscription Link

          [[ infoModal.subLink ]]

            Json Link

          [[ infoModal.subJsonLink ]]

      </template>
      <template v-if="app.tgBotEnable && infoModal.clientSettings.tgId">
        Telegram ChatID

            <a-tag color="blu


    }
            catch (Exception ex)
            {
                TracingHelper.Error(ex, typeof(frmConsumeHistory));
            }
        }

        //private void InitProduct()
        //{
        //    string sql = "select Id,ProductName from product";
        //    DataSet ds = DBHelper.ExecuteDataSet(sql, null, null);
        //    if (ds == null || ds.Tables[0].Rows.Count < 1) return;
        //    DataTable dt = ds.Tables[0];
        //    DataRow row = dt.NewRow();
        //    dt.Rows.InsertAt(row, 0);
        //    cmbxProduct.DataSource = dt;
        //    cmbxProduct.DisplayMember = "ProductName";
        //    cmbxProduct.ValueMember = "Id";
        //}

        private void InitAdmin()
        {
            try
            {
                string sql = "select Id,AdminName from Admin";
                DataSet ds = DBHelper.ExecuteDataSet(sql, null, null);
                if (ds == null || ds.Tables[0].Rows.Count < 1) return;
                DataTable dt = ds.Tables[0];
                DataRow row = dt.NewRow();
                dt.Rows.InsertAt(row, 0);
                cmbxAdmin.DataSource = dt;
                cmbxAdmin.DisplayMember = "AdminName";
                cmbxAdmin.ValueMember = "Id";
            }
            catch (Exception ex)
            {
                TracingHelper.Error(ex, typeof(frmConsumeHistory));
            }
        }

        private void btnQuery_Click(object sender, EventArgs e)
        {
            try
            {
                StringBuilder sbSql = new StringBuilder(" 1=1 ");
                string userName = txtUserName.Text;
                string cardId = txtCardId.Text;
                if (!string.IsNullOrEmpty(userName))
                    sbSql.Append(" and UserName='" + userName + "'");
                if (!string.IsNullOrEmpty(cardId))
                    sbSql.Append(" and CardId='" + cardId + "'");
                if (!string.IsNullOrEmpty(txtTel.Text))
                    sbSql.Append(" and Tel='" + txtTel.Text + "'");
                if (!string.IsNullOrEmpty(cbxUserType.Text))
                {
                    string userType = cbxUserType.Text;
                    if (userType == notVip)
                        sbSql.Append(" and (CardId='' or CardId=null)");
                    else
                        sbSql.Append(" and UserType='" + cbxUserType.Text + "'");
                }
                if (dateTimePickerStart.Checked && dateTimePickerEnd.Checked)
                {
                    if (dateTimePickerStart.Value > dateTimePickerEnd.Value)
                    {
                        MessageBox.Show("截止时间必须大于开始时间");
                        return;
                    }
                    sbSql.Append(" and (ConsumeTime>='" + dateTimePickerStart.Value.ToShortDateString() + "' and ConsumeTime<'" + dateTimePickerEnd.Value.AddDays(1).ToShortDateString() + "')");
                }
                else
                {
                    if (dateTimePickerStart.Checked)
                        sbSql.Append(" and ConsumeTime>='" + dateTimePickerStart.Value.ToShortDateString() + "'");
                    if (dateTimePickerEnd.Checked)
                        sbSql.Append(" and ConsumeTime<'" + dateTimePickerEnd.Value.AddDays(1).ToShortDateString() + "'");
                }
                if (!string.IsNullOrEmpty(cmbxEmployeeName.Text))
                    sbSql.Append(" and EmployeeName='" + cmbxEmployeeName.Text + "'");
                if (!string.IsNullOrEmpty(cmbxAdmin.Text))
                    sbSql.Append


("pkE= "); printbinary(&pkE);
	print!("Encapsulated z= "); printbinary(&z);

	hpke::authdecap(config_id,&skR,&mut z,&pkE,&pkR,&pkS);
	print!("Decapsulated z= "); printbinary(&z);

	hpke::keyschedule(config_id,&mut key,&mut nonce,&mut exp_secret,mode,&mut z,&info,Some(&psk),Some(&pskID));
	print!("key= "); printbinary(&key);
	print!("nonce= "); printbinary(&nonce);
	print!("exporter secret= "); printbinary(&exp_secret);

	gcm::encrypt(&mut cipher[0..plain.len()],&mut tag,&key,&nonce,&aad,&plain);
	print!("Cipher= ");  printbinary(&cipher[0..plain.len()]);
	print!("Tag= ");  printbinary(&tag);

}

fn main() {

    hpke_c25519();
    hpke_nist521();
}<filename>src/endpoints/account/put.rs
//Anything related to PUT requests for account and it's properties goes here.
use super::InvoiceAddress;

use crate::framework::endpoint::{HerokuEndpoint, Method};

/// Invoice Address update
///
/// Update invoice address for an account.
///
/// [See Heroku documentation for more information about this endpoint](https://devcenter.heroku.com/articles/platform-api-reference#invoice-address-update)
///
/// # Example:
///
/// InvoiceAddressUpdate has no required parameters, and returns the [`InvoiceAddress`][response].
/// ```rust
/// use heroku_rs::prelude::*;
///#    let api_client = HttpApiClient::create(&"API_KEY").unwrap();
///
/// let update_invoice = &InvoiceAddressUpdate::new()
///     .address_1("Grove Street")
///     .address_2("Not Grove Street")
///     .city("Seattle")
///     .country("US")
///     .other("Company ABC Inc. VAT 903820")
///     .postal_code("98101")
///     .state("WA")
///     .use_invoice_address(true)
///     .build();
/// let response = api_client.request(update_invoice);
///
///match response {
///     Ok(success) => println!("Success: {:#?}", success),
///     Err(e) => println!("Error: {}", e),
///}
//
/// ```
/// See how to create the Heroku [`api_client`][httpApiClientConfig].
///
/// [httpApiClientConfig]: ../../../framework/struct.HttpApiClient.html
/// [response]: ../struct.InvoiceAddress.html
pub struct InvoiceAddressUpdate<'a> {
    /// The parameters to pass to the Heroku API
    pub params: InvoiceAddressUpdateParams<'a>,
}

#[cfg(feature = "builder")]
impl<'a> InvoiceAddressUpdate<'a> {
    pub fn new() -> InvoiceAddressUpdate<'a> {
        InvoiceAddressUpdate {
            params: InvoiceAddressUpdateParams {
                address_1: None,
                address_2: None,
                city: None,
                country: None,
                other: None,
                postal_code: None,
                state: None,


          # Remove last BR()
                    names_with_breaks.pop()
                    name = TAG[""](*names_with_breaks)

                if record.logo:
                    size = (60, None)
                    image = s3db.pr_image_library_represent(record.logo, size=size)
                    url_small = URL(c="default", f="download", args=image)
                    alt = "%s logo" % _name
                    logo = IMG(_src=url_small,
                               _alt=alt,
                               _width=60,
                               )

        if not logo:
            # Default to generic IFRC
            logo = IMG(_src="/%s/static/themes/IFRC/img/dummy_flag.png" %
                            current.request.application,
                       _alt=current.T("Red Cross/Red Crescent"),
                       _width=60,
                       )

        # Note: render using current.menu.org.render()[0] + current.menu.org.render()[1]
        return (name, logo)

# -----------------------------------------------------------------------------
# Shortcut
OM = S3OrgMenuLayout

# END =========================================================================


ment', lex:tag(lexer.COMMENT, lexer.to_eol('#')))

-- Equals.
lex:add_rule('equals', lex:tag(lexer.OPERATOR, '='))

-- Strings.
local sq_str = lexer.range("'")
local dq_str = lexer.range('"')
lex:add_rule('string', lex:tag(lexer.STRING, sq_str + dq_str))

-- Variables.
lex:add_rule('variable', lex:tag(lexer.OPERATOR, '$(') *
                 lex:tag(lexer.VARIABLE,
                         (lexer.nonnewline - lexer.space - ')') ^ 0) *
                 lex:tag(lexer.OPERATOR, ')'))

lexer.property['scintillua.comment'] = '#'

return lex


icon-50 {
  white-space: nowrap;
}
.bd-posticoncategory-9 .bd-icon-50 > span {
  white-space: normal;
}
.bd-icon-50:before {
  content: '\22f';
}
.bd-icon-50:before {
  visibility: inherit;
}
.bd-icon-50:before {
  color: #cccccc;
  margin-right: 10px;
}
#marker-end-L3N0eWxlLmNzcw.L2NvbnRyb2xzL3Bvc3RDYXRlZ29yeUljb24y {}
#marker-start-L3N0eWxlLmNzcw.L2NvbnRyb2xzL3Bvc3RDYXRlZ29yeUljb24z {}
.bd-posticoncategory-14 .bd-icon-62 {
  white-space: nowrap;
}
.bd-posticoncategory-14 .bd-icon-62 > span {
  white-space: normal;
}
#marker-end-L3N0eWxlLmNzcw.L2NvbnRyb2xzL3Bvc3RDYXRlZ29yeUljb24z {}
#marker-start-L3N0eWxlLmNzcw.L2NvbnRyb2xzL3Bvc3REYXRlSWNvbjI {}
.bd-posticondate-3 {
  line-height: 17.14285715px;
  font-size: 12px;
}
.bd-posticondate-4 {
  float: left;
  margin-right: 10px;
  position: relative;
}
.bd-posticondate-4 {
  text-transform: none;
}
.bd-posticondate-4 {
  float: left;
  margin-right: 10px;
  position: relative;
}
.bd-posticondate-4 .bd-icon-41 {
  white-space: nowrap;
}
.bd-posticondate-4 .bd-icon-41 > span {
  white-space: normal;
}
.bd-icon-41:before {
  content: '\23d';
}
.bd-icon-41:before {
  visibility: inherit;
}
.bd-icon-41:before {
  color: #cccccc;
  margin-right: 10px;
}
#marker-end-L3N0eWxlLmNzcw.L2NvbnRyb2xzL3Bvc3REYXRlSWNvbjI {}
#marker-start-L3N0eWxlLmNzcw.L2NvbnRyb2xzL3Bvc3REYXRlSWNvbjIy {}
.bd-posticondate-1 {
  line-height: 17.14285715px;
  font-size: 12px;
}
.bd-posticondate-2 {
  line-height: 17.14285715px;
  font-size: 12px;
}
.bd-posticondate-2 .bd-icon-36 {
  white-space: nowrap;
}
.bd-posticondate-2 .bd-icon-36 > span {
  white-space: normal;
}
.bd-icon-36:before {
  content: '\23d';
}
.bd-icon-36:before {
  visibility: inherit;
}
.bd-icon-36:before {
  color: #cccccc;
  margin-right: 5px;
}
#marker-end-L3N0eWxlLmNzcw.L2NvbnRyb2xzL3Bvc3REYXRlSWNvbjIy {}
#marker-start-L3N0eWxlLmNzcw.L2NvbnRyb2xzL3Bvc3REYXRlSWNvbjUy {}
.bd-posticondate-10 .bd-icon-54 {
  white-space: nowrap;
}
.bd-posticondate-10 .bd-icon-54 > span {


	if o == nil  {
		return nil, false
	}
	return &o.Status, true
}

// SetStatus sets field value
func (o *ProductStatus) SetStatus(v string) {
	o.Status = v
}

// GetLastStatusChange returns the LastStatusChange field value
func (o *ProductStatus) GetLastStatusChange() time.Time {
	if o == nil {
		var ret time.Time
		return ret
	}

	return o.LastStatusChange
}

// GetLastStatusChangeOk returns a tuple with the LastStatusChange field value
// and a boolean to check if the value has been set.
func (o *ProductStatus) GetLastStatusChangeOk() (*time.Time, bool) {
	if o == nil  {
		return nil, false
	}
	return &o.LastStatusChange, true
}

// SetLastStatusChange sets field value
func (o *ProductStatus) SetLastStatusChange(v time.Time) {
	o.LastStatusChange = v
}

// GetBreakdown returns the Breakdown field value
func (o *ProductStatus) GetBreakdown() ProductStatusBreakdown {
	if o == nil {
		var ret ProductStatusBreakdown
		return ret
	}

	return o.Breakdown
}

// GetBreakdownOk returns a tuple with the Breakdown field value
// and a boolean to check if the value has been set.
func (o *ProductStatus) GetBreakdownOk() (*ProductStatusBreakdown, bool) {
	if o == nil  {
		return nil, false
	}
	return &o.Breakdown, true
}

// SetBreakdown sets field value
func (o *ProductStatus) SetBreakdown(v ProductStatusBreakdown) {
	o.Breakdown = v
}

func (o ProductStatus) MarshalJSON() ([]byte, error) {
	toSerialize := map[string]interface{}{}
	if true {
		toSerialize["status"] = o.Status
	}
	if true {
		toSerialize["last_status_change"] = o.LastStatusChange
	}
	if true {
		toSerialize["breakdown"] = o.Breakdown
	}

	for key, value := range o.AdditionalProperties {
		toSerialize[key] = value
	}

	return json.Marshal(toSerialize)
}

func (o *ProductStatus) UnmarshalJSON(bytes []byte) (err error) {
	varProductStatus := _ProductStatus{}

	if err = json.Unmarshal(bytes, &varProductStatus); err == nil {
		*o = ProductStatus(varProductStatus)
	} else {
		return err
	}

	additionalProperties := make(map[string]interface{})

	if err = json.Unmarshal(bytes, &additionalProperties); err == nil {
		delete(additionalProperties, "status")
		delete(additionalProperties, "last_status_change")
		delete(additionalProperties, "breakdown")
		o.AdditionalProperties = additionalProperties
	}

	return err
}

type NullableProductStatus struct {
	value *ProductStatus
	isSet bool
}

func (v NullableProductStatus) Get() *ProductStatus {
	return v.value
}

func (v *NullableProductStatus) Set(val *ProductStatus) {
	v.value = val
	v.isSet = true
}

func (v NullableProductStatus) IsSet() bool {
	return v.isSet
}

func (v *NullableProductStatus) Unset() {
	v.value = nil
	v.isSet = false
}

func NewNullableProductStatus(val *ProductStatus) *NullableProductStatus {
	return &NullableProductStatus{value: val, isSet: true}
}

func (v NullableProductStatus) MarshalJSON() ([]byte, error) {
	return json.Marshal(v.value)
}

func (v *NullableProductStatus) UnmarshalJSON(src []byte) error {
	v.isSet = true
	return json.Unmarshal(src, &v.value)
}

/*
 * The Plaid API
 *
 * The Plaid REST API. Please see https://plaid.com/docs/api for more details.
 *
 * API version: 2020-09-14_1.667.0
 */

// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

package plaid

import (
	"encoding/json"
)

// CraCheckReportNetworkInsightsGetResponse CraCheckReportNetworkInsightsGetResponse defines the response schema for `/cra/chec


, #input, 2 do
		local Type, x1, y1, x2, y2 = getCircleSegmentIntersection( x, y, radius, input[i], input[i + 1], cycle( input, i + 2 ), cycle( input, i + 3 ) )
		if x2 then
			choices[#choices + 1] = { Type, x1, y1, x2, y2 }
		elseif x1 then choices[#choices + 1] = { Type, x1, y1 } end
	end

	local final = removeDuplicates4Points( choices )

	return #final > 0 and final
end

-- Returns whether the circle is inside the polygon.
-- x, y, radius, polygonPoints
local function isCircleInsidePolygon( x, y, radius, ... )
	local input = checkInput( ... )
	return checkPolygonPoint( x, y, input )
end

-- Returns whether the polygon is inside the polygon.
local function isPolygonInsidePolygon( polygon1, polygon2 )
	local bool = false
	for i = 1, #polygon2, 2 do
		local result = false
		result = isSegmentInsidePolygon( polygon2[i], polygon2[i + 1], cycle( polygon2, i + 2 ), cycle( polygon2, i + 3 ), polygon1 )
		if result then bool = true; break end
	end
	return bool
end

-- Checks if a segment is completely inside a polygon
local function isSegmentCompletelyInsidePolygon( x1, y1, x2, y2, ... )
	local polygon = checkInput( ... )
	if not checkPolygonPoint( x1, y1, polygon )
	or not checkPolygonPoint( x2, y2, polygon )
	or getPolygonSegmentIntersection( x1, y1, x2, y2, polygon ) then
		return false
	end
	return true
end

-- Checks if a polygon is completely inside another polygon
local function isPolygonCompletelyInsidePolygon( polygon1, polygon2 )
	for i = 1, #polygon1, 2 do
		local x1, y1 = polygon1[i], polygon1[i + 1]
		local x2, y2 = polygon1[i + 2] or polygon1[1], polygon1[i + 3] or polygon1[2]
		if not isSegmentCompletelyInsidePolygon( x1, y1, x2, y2, polygon2 ) then
			return false
		end
	end
	return true
end

-------------- Circle w/ Polygons --------------
-- Gets if a polygon is completely within a circle
-- circleX, circleY, circleRadius, polygonPoints
local function isPolygonCompletelyInsideCircle( circleX, circleY, circleRadius, ... )
	local input = checkInput( ... )
	local function isDistanceLess( px, py, x, y, circleRadius ) -- Faster, does not use math.sqrt
		local distanceX, distanceY = px - x, py - y
		return distanceX * distanceX + distanceY * distanceY < circleRadius * circleRadius -- Faster. For comparing distances only.
	end

	for i = 1, #input, 2 do
		if not checkCirclePoint( input[i], input[i + 1], circleX, circleY, circleRadius ) then return false end
	end
	return true
end

-- Checks if a circle is completely within a polygon
-- circleX, circleY, circleRadius, polygonPoints
local function isCircleCompletelyInsidePolygon( circleX, circleY, circleRadius, ... )
	local input = checkInput( ... )
	if not checkPolygonPoint( circleX, circleY, ... ) then return false end

	local rad2 = circleRadius * circleRadius

	for i = 1, #input, 2 do
		local x1, y1 = input[i], input[i + 1]
		local x2, y2 = input[i + 2] or input[1], input[i + 3] or input[2]
		if distance2( x1, y1, circleX, circleY ) <= rad2 then return false end
		if getCircleSegmentIntersection( circleX, circleY, circleRadius, x1, y1, x


="./First_Memory／Next_Memory.md" title="First Memory／Next Memory">First Memory/Next Memory （2016-05-08）
社团：Liz Triangle，暁Records
编曲：ACTRock
演唱：Stack
作词：azuki，kaztora
原曲：少女が見た日本の原風景

其他版本（点击展开/隐藏）

<img alt="First Memory／Next Memory" src="https://upload.thwiki.cc/thumb/f/f7/First_Memory%EF%BC%8FNext_Memory%E5%B0%81%E9%9D%A2.jpg/39px-First_Memory%EF%BC%8FNext_Memory%E5%B0%81%E9%9D%A2.jpg" decoding="async" loading="lazy" width="39" height="40" srcset="https://upload.thwiki.cc/thumb/f/f7/First_Memory%EF%BC%8FNext_Memory%E5%B0%81%E9%9D%A2.jpg/58px-First_Memory%EF%BC%8FNext_Memory%E5%B0%81%E9%9D%A2.jpg 1.5x, https://upload.thwiki.cc/thumb/f/f7/First_Memory%EF%BC%8FNext_Memory%E5%B0%81%E9%9D%A2.jpg/78px-First_Memory%EF%BC%8FNext_Memory%E5%B0%81%E9%9D%A2.jpg 2x" data-file-width="1447" data-file-height="1491">

	Next Memory(Non connect Ver)

First Memory/Next Memory （2016-05-08）

- 歌词语言：日文- 歌词翻译：[KOiSHIKI](https://music.163.com/user/home?id=67717256)@网易云音乐 （中文）

	<td clas


verse,
	.wp-block-video:not(.alignwide):not(.alignfull) {
		margin-bottom: 4rem;
		margin-top: 4rem;
	}

	/* BLOCK: COLUMNS */

	.wp-block-columns.alignwide + .wp-block-columns.alignwide,
	.wp-block-columns.alignfull + .wp-block-columns.alignfull {
		margin-top: -6rem;
	}

	.entry-content .wp-block-columns h1,
	.entry-content .wp-block-columns h2,
	.entry-content .wp-block-columns h3,
	.entry-content .wp-block-columns h4,
	.entry-content .wp-block-columns h5,
	.entry-content .wp-block-columns h6 {
		margin: 3.5rem 0 2rem;
	}

	/* BLOCK: COVER */

	.wp-block-cover-image .wp-block-cover__inner-container,
	.wp-block-cover .wp-block-cover__inner-container {
		width: calc(100% - 8rem);
	}

	.wp-block-cover-image h2,
	.wp-block-cover h2 {
		font-size: 4.8rem;
	}

	/* BLOCK: GALLERY */

	figure.wp-block-gallery.alignnone,
	figure.wp-block-gallery.aligncenter {
		margin-bottom: 4rem;
		margin-top: 4rem;
	}

	figure.wp-block-gallery.alignwide,
	figure.wp-block-gallery.alignfull {
		margin-bottom: 6rem;
		margin-top: 6rem;
	}

	/* BLOCK: GROUP */

	.wp-block-group.has-background {
		padding: 4rem;
		margin-top: 0;
		margin-bottom: 0;
	}

	.alignfull:not(.has-background) > .wp-block-group__inner-container > p:not(.has-background-color) {
		padding-left: 0;
		padding-right: 0;
	}

	/* BLOCK: MEDIA AND TEXT */

	.wp-block-media-text .wp-block-media-text__content {
		padding: 4rem;
	}

	/* BLOCK: PULLQUOTE */

	.wp-block-pullquote blockquote p {
		font-size: 3.2rem;
	}

	.wp-block-pullquote cite {
		margin-top: 2rem;
	}

	.wp-block-pullquote.alignfull:not(.is-style-solid-color) {
		padding-left: 1rem;
		padding-right: 1rem;
	}

	.wp-block-pullquote.alignwide::before,
	.wp-block-pullquote.alignfull::before {
		font-size: 11.272727272rem;
		height: 8rem;
		margin-bottom: 2rem;
		width: 8rem;
	}

	.wp-block-pullquote.alignwide blockquote p,
	.wp-block-pullquote.alignfull blockquote p {
		font-size: 4.8rem;
		line-height: 1.203125;
	}

	.wp-block-pullquote.alignleft p,
	.wp-block-pullquote.alignright p,
	.wp-block-pullquote.alignleft.is-style-solid-color blockquote p,
	.wp-block-pullquote.alignright.is-style-solid-color blockquote p {
		font-size: 3.2rem;
		line-height: 1.1875;
	}

	.wp-block-pullquote.is-style-solid-color.alignwide,
	.wp-block-pullquote.is-style-solid-color.alignfull {
		padding: 6rem 4rem 4rem;
	}

	.wp-block-pullquote.alignleft.is-style-solid-color blockquote p,
	.wp-block-pullquote.alignright.is-style-solid-color blockquote p {
		font-size: 2.


ram>
		/// <returns></returns>
		public abstract bool CanSetIP(DbgThread thread, DbgCodeLocation location);
	}

	/// <summary>
	/// Start kind
	/// </summary>
	public enum DbgStartKind {
		/// <summary>
		/// The program was started by the debugger
		/// </summary>
		Start,

		/// <summary>
		/// The debugger attached to the program after it was started by someone else
		/// </summary>
		Attach,
	}
}


default
import emotia.core.designsystem.generated.resources.ic_chatting_send_disabled
import emotia.core.designsystem.generated.resources.ic_chatting_send_pressed
import org.jetbrains.compose.resources.DrawableResource
import org.jetbrains.compose.resources.painterResource
import org.jetbrains.compose.ui.tooling.preview.Preview

internal enum class ChatTextFieldState {
    DISABLED,   // 비활성화 상태
    FOCUSED,    // 포커스 있고 비어있음 (입력 중)
    TYPING,     // 포커스 있고 텍스트 있음 (타이핑 중)
    TYPED       // 포커스 없고 텍스트 있음 (입력 완료)
}

internal fun getTextFieldState(
    enabled: Boolean,
    isFocused: Boolean,
    hasText: Boolean,
): ChatTextFieldState {
    return when {
        !enabled -> ChatTextFieldState.DISABLED
        isFocused && hasText -> ChatTextFieldState.TYPING
        isFocused && !hasText -> ChatTextFieldState.FOCUSED
        !isFocused && hasText -> ChatTextFieldState.TYPED
        else -> ChatTextFieldState.FOCUSED
    }
}

@Composable
internal fun ChatTextFieldState.getBorderColor(): Color {
    val colors = LocalEmotiaColors.current
    return when (this) {
        ChatTextFieldState.DISABLED -> colors.lightGray
        ChatTextFieldState.FOCUSED -> colors.primaryLight
        ChatTextFieldState.TYPING -> colors.primaryLight
        ChatTextFieldState.TYPED -> colors.primaryLight
    }
}

@Composable
internal fun getTextColor(): Color {
    val colors = LocalEmotiaColors.current
    return colors.white
}

@Composable
internal fun getPlaceholderColor(): Color {
    val colors = LocalEmotiaColors.current
    return colors.lightGray
}

internal fun ChatTextFieldState.getSendIconResource(): DrawableResource {
    return when (this) {
        ChatTextFieldState.DISABLED -> Res.drawable.ic_chatting_send_disabled
        ChatTextFieldState.FOCUSED -> Res.drawable.ic_chatting_send_disabled
        ChatTextFieldState.TYPING -> Res.drawable.ic_chatting_send_pressed
        ChatTextFieldState.TYPED -> Res.drawable.ic_chatting_send_default
    }
}

internal fun ChatTextFieldState.isSendEnabled(): Boolean {
    return when (this) {
        ChatTextFieldState.TYPING, ChatTextFieldState.TYPED -> true
        ChatTextFieldState.DISABLED, ChatTextFieldState.FOCUSED -> false
    }
}

@Composable
fun EmotiaChatTextField(
    value: String,
    onValueChange: (String) -> Unit,
    onSendClick: () -> Unit,
    modifier: Modifier = Modifier,
    placeholder: String = "",
    enabled: Boolean = true,
) {
    val interactionSource = remember { MutableInteractionSource() }
    val colors = LocalEmotiaColors.current
    val isFocused by interactionSource.collectIsFocusedAsState()

    val state = remember(enabled, isFocused, value) {
        getTextFieldState(
            enabled = enabled,
            isFocused = isFocused,
            hasText = value.isNotEmpty()
        )
    }

    OutlinedTextField(
        value = value,
        onValueChange = onValueChange,
        modifier = modifier
            .fillMaxWidth()
            .background(
                color = colors.darkGray,
                shape = RoundedCornerShape(200.dp)
            )
            .border(
                width = 2.dp,
                color = state.getBorderColor(),
                shape = RoundedCornerShape(200.dp)
            ),
        enabled = enabled,
        placeholder = {
            if (placeholder.isNotEmpty() && value.isEmpty()) {
                Text(
                    text = placeholder,
                    style


 (fakeTime: number | null): Time => {
  if (fakeTime === null) {
    return {
      hours: 0,
      minutes: 0,
      seconds: 0
    };
  }
  const crawlFakeTotalTimeStr = fakeTime.toString();
  let crawlTotalTimeStr = '';
  // '135' -> '000135'
  for (let i = 0; i < 6 - crawlFakeTotalTimeStr.length; i++) {
    crawlTotalTimeStr += '0';
  }
  crawlTotalTimeStr += crawlFakeTotalTimeStr;
  // '000135' -> '00时01分35秒'
  return {
    hours: parseInt(crawlTotalTimeStr.substr(0, 2)),
    minutes: parseInt(crawlTotalTimeStr.substr(2, 2)),
    seconds: parseInt(crawlTotalTimeStr.substr(4, 2))
  };
};

const timeAdd = (t1: Time, t2: Time) => {
  const res = {
    hours: t1.hours + t2.hours,
    minutes: t1.minutes + t2.minutes,
    seconds: t1.seconds + t2.seconds
  };

  if (res.seconds >= 60) {
    res.seconds -= 60;
    res.minutes += 1;
  }
  if (res.minutes >= 60) {
    res.minutes -= 60;
    res.hours += 1;
  }

  return res;
};

const getThisCrawlTime = (startCrawlTime: string): Time => {
  const thisCrawlTime = {
    hours: 0,
    minutes: 0,
    seconds: 0
  };

  if (startCrawlTime === '') {
    return thisCrawlTime;
  }

  let thisCrawlBarrageTime = moment(Date.now()).diff(moment(startCrawlTime), 'seconds');
  thisCrawlTime.hours = Math.floor(thisCrawlBarrageTime / 3600);
  thisCrawlBarrageTime -= thisCrawlTime.hours * 3600;
  thisCrawlTime.minutes = Math.floor(thisCrawlBarrageTime / 60);
  thisCrawlBarrageTime -= thisCrawlTime.minutes * 60;
  thisCrawlTime.seconds = thisCrawlBarrageTime;

  return thisCrawlTime;
};

const convertTimeToStr = (time: Time): string => {
  const { hours, minutes, seconds } = time;
  return `${hours}时${minutes}分${seconds}秒`;
};
import { Observable, PropertyChangeData } from "tns-core-modules/data/observable";
import { Sha256 } from 'nativescript-sha';

export class HomeViewModel extends Observable {
	constructor() {
		super();
		this.set("hint", "Enter text to hash");
		this.set("text", "");
		this.on(Observable.propertyChangeEvent, (propertyChangeData: PropertyChangeData) => {
			if(propertyChangeData.propertyName === "text") {
				this.set("text", propertyChangeData.value);
			}
		});
	}

	public doHash() {
		this.set("hash", Sha256(this.get("text")));
		console.log(`Data is ${this.get("text")}`);
		console.log(`Sha is ${this.get("hash")}`);
	}
}
/**
 * Copyright 2015 Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import * as crypto from 'crypto';
import * as events from 'events';
import * as fs from 'fs';
import * as path from 'path


':
        case 'icon':
        case 'id':
        case 'modifier':
        case 'pack':
        case 'sanMin':
        case 'sanMax':
        case 'sanReason':
          this.object.link.setValue(key, formData[key])
          break
        case 'hasModifiers':
        case 'hasLabel':
        case 'hasIcon':
          this.object[key] = formData[key]
          break
        case 'effect.label':
          effect.label = formData[key]
          hasEffect = true
          break
        case 'effect.icon':
          effect.icon = formData[key]
          hasEffect = true
          break
        case 'effect.tint':
          effect.tint = formData[key]
          hasEffect = true
          break
        case 'effect.disabled':
          effect.disabled = formData[key]
          hasEffect = true
          break
        case 'effect.duration.seconds':
          effect.duration.seconds = formData[key]
          hasEffect = true
          break
        case 'effect.duration.rounds':
          effect.duration.rounds = formData[key]
          hasEffect = true
          break
        case 'effect.duration.turns':
          effect.duration.turns = formData[key]
          hasEffect = true
          break
        default: {
          const match = key.match(/^effect\.changes\.(\d+)\.key$/)
          if (match) {
            effect.changes.push({
              key: formData[key],
              mode: formData['effect.changes.' + match[1] + '.mode'],
              value: formData['effect.changes.' + match[1] + '.value']
            })
            hasEffect = true
          }
        }
      }
    }
    if (hasEffect) {
      this.object.link.setValue('object', effect)
    }
    const target = event.currentTarget
    if (target) {
      switch (target.name) {
        case 'type':
          this.object.link.setValue('check', target.value)
          if (target.value === CoC7Link.CHECK_TYPE.CHECK) {
            this.object.link.setValue('linkType', CoC7Link.LINK_TYPE.SKILL)
            this.object.link.setValue('name', '')
          }
          break
        case 'check':
          this.object.link.setValue('linkType', target.value)
          if (target.value === CoC7Link.LINK_TYPE.CHARACTERISTIC) {
            this.object.link.setValue('name', CoCActor.getCharacteristicDefinition()[0].key)
          } else if (target.value === CoC7Link.LINK_TYPE.ATTRIBUTE) {
            this.object.link.setValue('name', 'lck')
          } else {
            this.object.link.setValue('name', '')
          }
          break
        case 'attributeKey':
        case 'characteristicKey':
          this.object.link.setValue('name', target.value)
          break
      }
      if (event.type === 'submit') {
        switch (event.submitter.dataset.action) {
          case 'clipboard':
            CoC7Utilities.copyToClipboard(this.object.link.link)
            break
          case 'chat':
            CoC7Link.toChatMessage(this.object.link.object)
            break
          case 'whisper-owner':
            CoC7Link.toWhisperMessage(this.object.link.object, this.object.actors)
            break
          case 'whisper-selected':
            if (!canvas.tokens.controlled.length) {
              ui.notifications.warn(
                game.i18n.localize('CoC7.ErrorNoTokensSelected')
              )
              return
            }
            CoC7Link.toWhisperMessage


 붉은십자군 환영을 보유하고 있는 동안 하스글렌으로 가서 티리온의 선물을 대영주 탤런 폴드링에게 전해야 합니다.\n\n하스글렌은 북쪽에 있으며 탤런은 마르덴홀드 요새 내부에서 찾을 수 있을 겁니다."}},
[5863] = {"모래망치 주둔지", nil, {"가젯잔에 있는 앤디 린이 모래망치 투사, 모래망치 집행자를 각각 10명씩 처치하고 파괴자 고르마로크를 처단하여 모래망치 주둔지를 처치해 달라고 했습니다."}},
[5881] = {"휴가 통지서", nil, {"마그그랜이 불모의 땅 구름 승강장에 있는 그리쉬 롱러너에게 통지서를 전해달라고 했습니다."}},
[5882] = {"사냥을 통한 고약 확보", nil, {"요구 조건:"}},
[5887] = {"사냥을 통한 고약 확보", nil, {"요구 조건:"}},
[5888] = {"채광을 통한 고약 확보", nil, {"요구 조건:"}},
[5889] = {"약초채집을 통한 고약 확보", nil, {"요구 조건:"}},
[5890] = {"무두질을 통한 고약 확보", nil, {"요구 조건:"}},
[5891] = {"마력 추출을 통한 고약 확보", nil, {"요구 조건:"}},
[5892] = {"깊은무쇠 광산 보급품", nil, {"던 발다르에 있는 얼라이언스 병참장교에게 깊은무쇠 광산 보급품 10개를 가져가야 합니다."}},
[5893] = {"얼음이빨 광산 보급품", nil, {"서리늑대 요새에 있는 서리늑대 병참장교에게 얼음이빨 광산 보급품 10개를 가져가야 합니다."}},
[5901] = {"역병 퍼뜨리기", nil, {"동부 역병지대


ort it.infn.mw.iam.core.oauth.scope.matchers.ScopeMatchersProperties.MatcherProperties.MatcherType;
import it.infn.mw.iam.core.oauth.scope.matchers.ScopeMatchersPropertiesParser;

@RunWith(MockitoJUnitRunner.class)
public class ScopeMatcherParsingTests {

  ScopeMatchersProperties p = new ScopeMatchersProperties();

  @Test
  public void testEmptyParsing() {

    ScopeMatchersPropertiesParser parser = new ScopeMatchersPropertiesParser();
    Set<ScopeMatcher> matchers = parser.parseScopeMatchersProperties(p);
    assertThat(matchers, not(nullValue()));
    assertThat(matchers, empty());

  }

  @Test
  public void testParsing() {

    MatcherProperties regex = new MatcherProperties();
    regex.setType(MatcherType.regexp);
    regex.setName("WLCG scope");
    regex.setRegexp("^wlcg$");

    MatcherProperties path = new MatcherProperties();
    path.setType(MatcherType.path);
    path.setName("storage.read");
    path.setPrefix("storage.read");
    path.setPath("/");

    p.setMatchers(asList(regex,path));

    ScopeMatchersPropertiesParser parser = new ScopeMatchersPropertiesParser();
    Set<ScopeMatcher> matchers = parser.parseScopeMatchersProperties(p);
    assertThat(matchers, not(nullValue()));
    assertThat(matchers, hasSize(2));

    assertThat(matchers, hasItem(structuredPathMatcher("storage.read", "/")));
    assertThat(matchers, hasItem(regexpMatcher("^wlcg$")));
  }

}
/**
 * Copyright (c) Istituto Nazionale di Fisica Nucleare (INFN). 2016-2021
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package it.infn.mw.iam.test.oauth.exchange;

import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.httpBasic;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.junit4.SpringRunner;

import it.infn.mw.iam.IamLoginService;
import it.infn.mw.iam.api.exchange_policy.ClientMatchingPolicyDTO;
import it.infn.mw.iam.api.exchange_policy.ExchangePolicyDTO;
import it.infn.mw.iam.api.exchange_policy.ExchangeScopePolicyDTO;
import it.infn.mw.iam.api.exchange_policy.TokenExchangePolicyService;
import it.infn.mw.iam.persistence.model.IamScopePolicy.MatchingPolicy;
import it.infn.mw.iam.persistence.model.PolicyRule;
import it.infn.mw.iam.test.oauth.EndpointsTestUtils;
import it.infn.mw.iam.test.util.annotation.IamMockMvcIntegrationTest;

@Run


n_Straight01_top=1, Garden_Straight02_top=10, Garden_Straight03_top=2 },
    wallStraightBottom = {Garden_Straight01_bottom=5,Garden_Straight02_bottom=5,Garden_Straight03_bottom=1},
    -- corners: North and South (compass halves)
    wallCornerNTop = {Garden_Corner_outer01_top=1},
    wallCornerNBottom = {Garden_Corner_outer01_bottom=1},
    wallCornerETop = {Garden_Corner_lb_top=1},
    wallCornerEBottom = {Garden_Corner_lb_bottom=1},
    wallCornerSTop = {Garden_Corner_inner01_top=1},
    wallCornerSBottom = {Garden_Corner_inner01_bottom=1},
    wallCornerWTop = {Garden_Corner_rb_top=1},
    wallCornerWBottom = {Garden_Corner_rb_bottom=1},
    -- T intersections: diagonal of the T base
    wallTNETop = {Garden_Corner_T_NE_top=1},
    wallTNEBottom = {Garden_Corner_T_NE_bottom=1},
    wallTSETop = {Garden_Corner_T_SE_top=1},
    wallTSEBottom = {Garden_Corner_T_SE_bottom=1},
    wallTSWTop = {Garden_Corner_T_SW_top=1},
    wallTSWBottom = {Garden_Corner_T_SW_bottom=1},
    wallTNWTop = {Garden_Corner_T_NW_top=1},
    wallTNWBottom = {Garden_Corner_T_NW_bottom=1},
    -- cross piece
    wallCrossTop = {Garden_Corner_cross_top=1},
    wallCrossBottom = {Garden_Corner_cross_bottom=1},
    -- standalone column
    wallColumnTop = {Garden_Corner_outer01_top=1},
    wallColumnBottom = {Garden_Corner_outer01_bottom=1},

    tAmbientLightColor = {0.5, 0.5, 0.5 },
    tRoomLights =
    {
        {
            tLightColor = {0.5, 1, 0.8},
            nLightTileGapX = 3,
            nLightTileGapY = 3,
            nLightRadius = 3,
        },
    },

    sLightSpriteName = 'directionalcast',
    clickSound = 'clickbar',
    portrait = 'Zone_Garden',
}
Zone.INFIRMARY =
{
    name='Infirmary',
    description="ZONEUI048TEXT",
    floorNames={ 'infirmary01', },
    associatedJob=Character.DOCTOR,

    wallStraightTop = { Infirmary_Straight02_top=10, Infirmary_Straight01_top=3,Infirmary_Straight03_top=5, },
    wallStraightBottom = {Infirmary_Straight01_bottom=10,},
    -- corners: North and South (compass halves)
    wallCornerNTop = {Infirmary_Corner_outer01_top=1},
    wallCornerNBottom = {Infirmary_Corner_outer01_bottom=1},
    wallCornerETop = {Infirmary_Corner_lb_top=1},
    wallCornerEBottom = {Infirmary_Corner_lb_bottom=1},
    wallCornerSTop = {Infirmary_Corner_inner01_top=1},
    wallCornerSBottom = {Infirmary_Corner_inner01_bottom=1},
    wallCornerWTop = {Infirmary_Corner_rb_top=1},
    wallCornerWBottom = {Infirmary_Corner_rb_bottom=1},
    -- T intersections: diagonal of the T base
    wallTNETop = {Infirmary_Corner_T_NE_top=1},
    wallTNEBottom = {Infirmary_Cor


p Select Assignment Register */
#define		AT91_EBI_CS0A		(1 << 0)		/* Chip Select 0 Assignment */
#define			AT91_EBI_CS0A_SMC		(0 << 0)
#define			AT91_EBI_CS0A_BFC		(1 << 0)
#define		AT91_EBI_CS1A		(1 << 1)		/* Chip Select 1 Assignment */
#define			AT91_EBI_CS1A_SMC		(0 << 1)
#define			AT91_EBI_CS1A_SDRAMC		(1 << 1)
#define		AT91_EBI_CS3A		(1 << 3)		/* Chip Select 2 Assignment */
#define			AT91_EBI_CS3A_SMC		(0 << 3)
#define			AT91_EBI_CS3A_SMC_SMARTMEDIA	(1 << 3)
#define		AT91_EBI_CS4A		(1 << 4)		/* Chip Select 3 Assignment */
#define			AT91_EBI_CS4A_SMC		(0 << 4)
#define			AT91_EBI_CS4A_SMC_COMPACTFLASH	(1 << 4)
#define AT91_EBI_CFGR		(AT91_MC + 0x64)	/* Configuration Register */
#define		AT91_EBI_DBPUC		(1 << 0)		/* Data Bus Pull-Up Configuration */

/* Static Memory Controller (SMC) registers */
#define	AT91_SMC_CSR(n)		(AT91_MC + 0x70 + ((n) * 4))/* SMC Chip Select Register */
#define		AT91_SMC_NWS		(0x7f <<  0)		/* Number of Wait States */
#define		AT91_SMC_WSEN		(1    <<  7)		/* Wait State Enable */
#define		AT91_SMC_TDF		(0xf  <<  8)		/* Data Float Time */
#define		AT91_SMC_BAT		(1    << 12)		/* Byte Access Type */
#define		AT91_SMC_DBW		(3    << 13)		/* Data Bus Width */
#define			AT91_SMC_DBW_16		(1 << 13)
#define			AT91_SMC_DBW_8		(2 << 13)
#define		AT91_SMC_DPR		(1 << 15)		/* Data Read Protocol */
#define		AT91_SMC_ACSS		(3 << 16)		/* Address to Chip Select Setup */
#define			AT91_SMC_ACSS_STD	(0 << 16)
#define			AT91_SMC_ACSS_1		(1 << 16)
#define			AT91_SMC_ACSS_2		(2 << 16)
#define			AT91_SMC_ACSS_3		(3 << 16)
#define		AT91_SMC_RWSETUP	(7 << 24)		/* Read & Write Signal Time Setup */
#define		AT91_SMC_RWHOLD		(7 << 28)		/* Read & Write Signal Hold Time */

#endif


ine _m100
#define _m101
#define _m102
#define _m103
#define _m104
#define _m105
#define _m106
#define _m107
#define _m108
#define _m109
#define _m11
#define _m110
#define _m111
#define _m112
#define _m113
#define _m114
#define _m115
#define _m116
#define _m117
#define _m118
#define _m119
#define _m12
#define _m120
#define _m121
#define _m122
#define _m123
#define _m124
#define _m125
#define _m126
#define _m127
#define _m128
#define _m129
#define _m13
#define _m130
#define _m131
#define _m132
#define _m133
#endif#if !IN_PARSER
#define _m00 _SDK_MAGIC_PROPERTY(_SDK_ESCAPE(uint16_t), "FxCollection.m_Type", m_type, 0x40, 0x10, true, 0x63e6c932f2c22dee)
#define _m01 _SDK_MAGIC_PROPERTY(_SDK_ESCAPE(uint16_t), "FxCollection.m_ObjectSize", m_object_size, 0x50, 0x10, true, 0xb0b5d95c889c7ca7)
#define _m02 _SDK_MAGIC_PROPERTY(_SDK_ESCAPE(int32_t), "FxCollection.m_Refcnt", m_refcnt, 0x60, 0x20, true, 0xe0366aa52945b5a9)
#define _m03 _SDK_MAGIC_PROPERTY(_SDK_ESCAPE(struct fx::driver_globals_t*), "FxCollection.m_Globals", m_globals, 0x80, 0x40, true, 0xa8e97d344e5182f8)
#define _m04 _SDK_MAGIC_PROPERTY(_SDK_ESCAPE(uint16_t), "FxCollection.m_ObjectFlags", m_object_flags, 0xc0, 0x10, true, 0xdf6d66f1b91ad266)
#define _m05 _SDK_MAGIC_BITFIELD(nop_t, _SDK_ESCAPE(uint1_t), "FxCollection.m_ObjectFlagsByName.PassiveCallbacks", passive_callbacks, 0x0, 0x1, true, 0xfd3111d18efc3af8, 1, uint16_t)
#define _m06 _SDK_MAGIC_BITFIELD(nop_t, _SDK_ESCAPE(uint1_t), "FxCollection.m_ObjectFlagsByName.NoDeleteDDI", no_delete_ddi, 0x1, 0x1, true, 0x454825403db774db, 1, uint16_t)
#define _m07 _SDK_MAGIC_BITFIELD(nop_t, _SDK_ESCAPE(uint1_t), "FxCollection.m_ObjectFlagsByName.DeleteCalled", delete_called, 0x2, 0x1, true, 0x782dc8710d81c1b1, 1, uint16_t)
#define _m08 _SDK_MAGIC_BITFIELD(nop_t, _SDK_ESCAPE(uint1_t), "FxCollection.m_ObjectFlagsByName.Committed", committed, 0x3, 0x1, true, 0x7d2a9a4ababff245, 1, uint16_t)
#define _m09 _SDK_MAGIC_BITFIELD(nop_t, _SDK_ESCAPE(uint1_t), "FxCollection.m_ObjectFlagsByName.PassiveDispose", passive_dispose, 0x4, 0x1, true, 0xc1fcb059b9f37be1, 1, uint16_t)
#define _m10 _SDK_MAGIC_BITFIELD(nop_t, _SDK_ESCAPE(uint1_t), "FxCollection.m_ObjectFlagsByName.ForceDis


e0e0}.dx-datagrid-filter-panel .dx-datagrid-filter-panel-clear-filter,.dx-datagrid-filter-panel .dx-datagrid-filter-panel-text,.dx-datagrid-filter-panel .dx-icon-filter{outline:0}.dx-datagrid-filter-panel.dx-state-focused .dx-datagrid-filter-panel-clear-filter:focus,.dx-datagrid-filter-panel.dx-state-focused .dx-datagrid-filter-panel-text:focus,.dx-datagrid-filter-panel.dx-state-focused .dx-icon-filter:focus{outline:#35baf6 solid 2px;outline-offset:3px}.dx-datagrid-form-buttons-container{float:right}.dx-datagrid-form-buttons-container .dx-button{margin-left:10px;margin-top:10px}.dx-datagrid-adaptive-more{cursor:pointer;font:21px/21px DXIcons}.dx-datagrid-adaptive-more::before{content:"\f06c"}.dx-datagrid-edit-popup .dx-error-message{background-color:#f88e86;white-space:normal;word-wrap:break-word;color:#fff;margin-bottom:20px}.dx-rtl .dx-datagrid .dx-datagrid-headers .dx-row td.dx-pointer-events-none,.dx-rtl .dx-datagrid .dx-datagrid-rowsview .dx-data-row td.dx-pointer-events-none,.dx-rtl .dx-datagrid .dx-datagrid-rowsview .dx-freespace-row td.dx-pointer-events-none,.dx-rtl .dx-datagrid .dx-datagrid-rowsview .dx-header-row td.dx-pointer-events-none,.dx-rtl .dx-datagrid .dx-datagrid-rowsview .dx-virtual-row td.dx-pointer-events-none{border-left:2px solid #e0e0e0;border-right:2px solid #e0e0e0}.dx-rtl .dx-datagrid .dx-datagrid-headers .dx-row td.dx-pointer-events-none.dx-first-cell,.dx-rtl .dx-datagrid .dx-datagrid-rowsview .dx-data-row td.dx-pointer-events-none.dx-first-cell,.dx-rtl .dx-datagrid .dx-datagrid-rowsview .dx-freespace-row td.dx-pointer-events-none.dx-first-cell,.dx-rtl .dx-datagrid .dx-datagrid-rowsview .dx-header-row td.dx-pointer-events-none.dx-first-cell,.dx-rtl .dx-datagrid .dx-datagrid-rowsview .dx-virtual-row td.dx-pointer-events-none.dx-first-cell{border-right:none}.dx-rtl .dx-datagrid .dx-datagrid-headers .dx-row td.dx-pointer-events-none.dx-last-cell,.dx-rtl .dx-datagrid .dx-datagrid-rowsview .dx-data-row td.dx-pointer-events-none.dx-last-cell,.dx-rtl .dx-datagrid .dx-datagrid-rowsview .dx-freespace-row td.dx-pointer-events-none.dx-last-cell,.dx-rtl .dx-datagrid .dx-datagrid-rowsview .dx-header-row td.dx-pointer-events-none.dx-last-cell,.dx-rtl .dx-datagrid .dx-datagrid-rowsview .dx-virtual-row td.dx-pointer-events-none.dx-last-cell{border-left:none}.dx-rtl .dx-datagrid .dx-datagrid-rowsview .dx-virtual-row>td::before{transform:scaleX(-1)}.dx-rtl .dx-datagrid .dx-datagrid-rowsview .dx-virtual-row>td[style*="text-align: left"]::before{transform:scale(1)}.dx-rtl .dx-datagrid .dx-column-lines>td:firs


n a stealth unit is currently not stealthed and doesn't autoacquire while stealthed,
			//then when the player specifically orders the unit to stop, we want to not autoacquire until
			//he is able to stealth again. Of course, if he's detected, then don't bother trying.
			if( !theUnit->getStatusBits().test( OBJECT_STATUS_STEALTHED ) && !theUnit->getStatusBits().test( OBJECT_STATUS_DETECTED ) )
			{
				//Not stealthed, not detected -- so do auto-acquire while stealthed?
				if( !ai->canAutoAcquireWhileStealthed() )
				{
          StealthUpdate *stealth = theUnit->getStealth();
					if( stealth )
					{
						//Delay the mood check time (for autoacquire) until after the unit can stealth again.
						UnsignedInt stealthFrames = stealth->getStealthDelay();
						//Skew it a little due to having a large group selected.
						UnsignedInt randomFrames = GameLogicRandomValue( 0, LOGICFRAMES_PER_SECOND );
						ai->setNextMoodCheckTime( TheGameLogic->getFrame() + stealthFrames + randomFrames );
					}
				}
			}
		}

		if( !addWaypoint )
		{
			ai->aiMoveToPosition( &dest, cmdSource );
		}
		else
		{
			ai->aiFollowPathAppend(&dest, cmdSource);
		}
	}
}

//-------------------------------------------------------------------------------------------------
// AI Command Interface implementation for AIGroup
//

/**
 * Scatter
 */
void AIGroup::groupScatter( CommandSourceType cmdSource )
{
	if (m_dirty)
		recompute();

	std::list<Object *>::iterator i;
	// compute current centroid of the team
	Coord3D center;
	Coord2D min;
	Coord2D max;
	Coord3D dest;

	getMinMaxAndCenter( &min, &max, &center );

	// Move.
	MemoryPoolObjectHolder iterHolder;
	SimpleObjectIterator *iter = newInstance(SimpleObjectIterator);
	iterHolder.hold(iter);
	for( i = m_memberList.begin(); i != m_memberList.end(); ++i )
	{
		Real dx, dy;
		if ((*i)->isDisabledByType( DISABLED_HELD ) )
		{
			continue; // don't bother telling the occupants to move.
		}
		if( (*i)->isKindOf( KINDOF_IMMOBILE ) )
		{
			continue;
		}
		if( (*i)->getAI()==NULL )
		{
			continue;
		}
		Coord3D unitPos = *((*i)->getPosition());
		TheAI->pathfinder()->removeGoal(*i);
		dx = unitPos.x - center.x;
		dy = unitPos.y - center.y;
		iter->insert((*i), dx*dx+dy*dy);
	}

	iter->sort(ITER_SORTED_FAR_TO_NEAR);
	Object *theUnit;
	for (theUnit = iter->first(); theUnit; theUnit = iter->next())
	{
		center.x -= 0.01f;
		AIUpdateInterface *ai = theUnit->getAIUpdateInterface();
		Coord3D unitPos = *theUnit->getPosition();
		Coord2D delta;
		dest = unitPos;
		delta.x = unitPos.x - center.x;
		delta.y = unitPos.y - center.y;
		delta.normalize();
		dest.x += delta.x*4*theUnit->getGeometryInfo().getBoundingCircleRadius();
		dest.y += delta.y*4*theUnit->getGeometryInfo().getBoundingCircleRadius();
		ai->aiMoveToPosition( &dest, cmdSource