Range.Bound bound) {
        if (version == null) {
            assertNull(bound);
        } else {
            assertNotNull(bound);
            assertNotNull(bound.getVersion());
            assertEquals(inclusive, bound.isInclusive());
            try {
                assertEquals(versionScheme.parseVersion(version), bound.getVersion());
            } catch (InvalidVersionSpecificationException e) {
                throw new IllegalArgumentException(e);
            }
        }
    }

    @Test
    void testGetLowerBound() {
        VersionRange range = UnionVersionRange.from(Collections.emptySet());
        assertBound(null, false, range.getLowerBound());

        range = UnionVersionRange.from(newRange("[1,2]"), newRange("[3,4]"));
        assertBound("1", true, range.getLowerBound());

        range = UnionVersionRange.from(newRange("[1,2]"), newRange("(,4]"));
        assertBound(null, false, range.getLowerBound());

        range = UnionVersionRange.from(newRange("[1,2]"), newRange("(1,4]"));
        assertBound("1", true, range.getLowerBound());

        range = UnionVersionRange.from(newRange("[1,2]"), newRange("(0,4]"));
        assertBound("0", false, range.getLowerBound());
    }

    @Test
    void testGetUpperBound() {
        VersionRange range = UnionVersionRange.from(Collections.emptySet());
        assertBound(null, false, range.getUpperBound());

        range = UnionVersionRange.from(newRange("[1,2]"), newRange("[3,4]"));
        assertBound("4", true, range.getUpperBound());

        range = UnionVersionRange.from(newRange("[1,2]"), newRange("[3,)"));
        assertBound(null, false, range.getUpperBound());

        range = UnionVersionRange.from(newRange("[1,2]"), newRange("[1,2)"));
        assertBound("2", true, range.getUpperBound());

        range = UnionVersionRange.from(newRange("[1,2]"), newRange("[1,3)"));
        assertBound("3", false, range.getUpperBound());
    }
}
/* $Id$ */

/**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.manifoldcf.authorities;

import java.io.*;
import org.apache.manifoldcf.core.interfaces.*;
import org.apache.manifoldcf.authorities.interfaces.*;
import org.apache.manifoldcf.authorities.system.*;

public class SynchronizeMappers extends BaseMappersInitializationCommand
{
  public static final String _rcsid = "@(#)$Id$";

  public SynchronizeMappers()
  {
  }

  protected void doExecute(IMappingConnectorManager mgr) throws ManifoldCFException
  {
    IResultSet classNames = mgr.getConnectors();
    int i = 0;
    while (i < classNames.getRowCount())
    {
      IResultRow row = classNames.getRow(i++);
      String classname = (String)row.getValue("classname");
      try
      {
        MappingConnectorFactory.getConnectorNoCheck(classname);
      }
      catch (ManifoldCFException e)
      {
        mgr.removeConnector(classname);
      }
    }
    Logging.root.info("Successfully synchronized all mappers");
  }

  pub


##### 图 2.6 生成管道的三个组件使得 RAG 系统的实时查询-响应过程成为可能。

让我们更详细地考虑这些内容：

+   *检索器*—这可能是整个系统中最关键的部分。使用高级搜索算法，检索器扫描知识库，根据用户的查询识别和检索最相关的信息。整个系统的总体有效性在很大程度上依赖于检索器的准确性。此外，搜索是一个计算密集型操作，可能需要时间。因此，检索器也对系统的总体延迟做出了重大贡献。我们将在第四章和第六章中讨论不同的检索器和检索策略。

+   *提示管理*—一旦检索器检索到相关信息，就需要将其与原始用户查询结合或增强。乍一看，这似乎是一个简单的任务。然而，提示的构建对生成响应的质量有重大影响。这个组件也属于提示工程的范围。我们将在第四章中探讨不同的提示和提示管理策略。

+   *LLM 设置*—最后，LLM 负责生成最终响应。RAG 系统可能依赖于多个 LLM。LLM 可以是已经预训练并通常可用的基础模型，例如 Meta 或 Mistral 的，或者通过管理服务，如 OpenAI 或 Anthropic。LLM 也可以针对特定任务进行微调。微调涉及在特定数据集或任务上训练现有的 LLM，以提高性能和适应性，用于专用应用。在罕见的情况下，开发者可能决定训练他们自己的 LLM。我们将在第四章中深入讨论 LLM。

## 2.5 评估和监控

索引和生成管道从使用角度完成了系统。有了这两个管道，至少在理论上，用户可以开始与系统交互并获得响应。然而，在这种情况下，我们没有系统质量的衡量标准。系统是否运行准确，或者它仍然容易产生幻觉？检索器检索到的信息是否与查询最相关？为了回答这些问题，我们必须建立一个评估框架。这个框架有助于在系统发布之前评估其质量，然后进行持续监控和改进。

建立在 LLMs 的进步之上，RAG 代表了 NLP 领域的一项最新创新。相关性分数、召回率和精确度等指标通常用于评估 RAG 系统的有效性。TruEra 提出的 RAG 指标三元组（[`mng.bz/Mw22`](https://mng.bz/Mw22)）提供了一个直观的框


",ForkDelta:"CAN"},
 {s:"CAN",a:"0x5f3789907b35dce5605b00c0be0a7ecdbfa8a841",d:18,n:"Content and Ad Network"},
 {s:"CAN",a:"0x79b966d76cfb72bd6a20edf02776b9af04914c43",d:18,n:"SolveCare Token",block:3,inactive:1},
 {s:"CANA",a:"0x62f57555d54bb3a623082ef478922a2838048b96",d:18,n:"cannabis seed token",block:1},
 {s:"CANADA",a:"0x7ea4c29d3d37f9b259be610b67b3125c4d095d02",d:18,n:"CANADACOIN",block:1,inactive:1,ForkDelta:"CANADA"},
 {s:"CANC",a:"0xab80f9b4b8f32a84e6b9e9eb83decab7bf031d44",d:0,n:"Cancer Coin",block:3,inactive:1},
 {s:"CANDY",a:"0x45555629aabfea138ead1c1e5f2ac3cce2add830",d:8,n:"CandyHCoin"},
 {s:"CANDY",a:"0x4d88238468e70673133090e3893b8770457361e1",d:18,block:1,inactive:1},
 {s:"Candy",a:"0xcd3673af09e76c74d889aabab68ca0645566a3a1",d:18,n:"Unicorn Candy Coin"},
 {s:"CANDY",a:"0xf2eab3a2034d3f6b63734d2e08262040e3ff7b48",d:18},
 {s:"CANDYCASH",a:"0xc9c261ba4c0fcc8a23d0829443e894801d507173",d:18,n:"CANDY CASH",inactive:1},
 {s:"CANG",a:"0x8f8bed23a644f3bbb4e227e28704c050e67c35be",d:18,n:"Hail Gocang",block:1,inactive:1},
 {s:"CANNA",a:"0x43a05ea406e039db56e0024e6369dd974a00ea6e",d:18,n:"Cannavest",block:1,inactive:1},
 {s:"CANNABIS",a:"0xb1d463018c65621e33ba69ac7f7c69a89aad1fb8",d:3,block:3,inactive:1},
 {s:"CANX",a:"0xa834150b855f7a1dd2ac1356059722dc2ac58393",d:8},
 {s:"CAP",a:"0x43044f861ec040db59a7e324c40507addb673142",d:18,n:"Cap",OneInch:"CAP"},
 {s:"CAPC",a:"0x3f8fd16e55cfee539b81cc47bb9682090988ebd4",d:18,n:"CampingCoin"},
 {s:"CAPC",a:"0x79a91ccaaa6069a571f0a3fa6ed257796ddd0eb4",d:18,n:"Cap Coin",block:1},
 {s:"CAPP",a:"0x04f2e7221fdb1b52a68169b25793e51478ff0329",d:2,n:"Cappasity",old:1},
 {s:"CAPP",a:"0x11613b1f840bb5a40f8866d857e24da126b79d73",d:2,n:"Cappasity"},
 {s:"CAPT",a:"0x84a8222618acd4ac60547b6e89cc2


源类型为直播源时，备源才会生效。
2. 将该参数置为空，则可将任务去除备源信息。
3. 主直播源拉流中断时，自动使用备源进行拉流。
4. 如果备源为点播文件时，则每次轮播完点播文件就检查主源是否恢复，如果主源恢复则自动切回到主源，否则继续拉备源。
     */
    public String getBackupSourceType() {
        return this.BackupSourceType;
    }

    /**
     * Set 备源的类型：
PullLivePushLive -直播，
PullVodPushLive -点播。
注意：
1. 仅当主源类型为直播源时，备源才会生效。
2. 将该参数置为空，则可将任务去除备源信息。
3. 主直播源拉流中断时，自动使用备源进行拉流。
4. 如果备源为点播文件时，则每次轮播完点播文件就检查主源是否恢复，如果主源恢复则自动切回到主源，否则继续拉备源。
     * @param BackupSourceType 备源的类型：
PullLivePushLive -直播，
PullVodPushLive -点播。
注意：
1. 仅当主源类型为直播源时，备源才会生效。
2. 将该参数置为空，则可将任务去除备源信息。
3. 主直播源拉流中断时，自动使用备源进行拉流。
4. 如果备源为点播文件时，则每次轮播完点播文件就检查主源是否恢复，如果主源恢复则自动切回到主源，否则继续拉备源。
     */
    public void setBackupSourceType(String BackupSourceType) {
        this.BackupSourceType = BackupSourceType;
    }

    /**
     * Get 备源 URL。
只允许填一个备源 URL
     * @return BackupSourceUrl 备源 URL。
只允许填一个备源 URL
     */
    public String getBackupSourceUrl() {
        return this.BackupSourceUrl;
    }

    /**
     * Set 备源 URL。
只允许填一个备源 URL
     * @param BackupSourceUrl 备源 URL。
只允许填一个备源 URL
     */
    public void setBackupSourceUrl(String BackupSourceUrl) {
        this.BackupSourceUrl = BackupSourceUrl;
    }

    /**
     * Get 水印信息列表。
注意：
1. 最多支持4个不同位置的水印。
2. 水印图片 URL 请使用合法外网可访问地址。
3. 支持的水印图片格式：png，jpg等。
4. 轮播任务修改水印后，轮播到下一个文件时新水印生效。
5. 直播源任务修改水印后，水印立即生效。
6. 清除水印时，需携带该水印列表参数，内容为空数组。
7. 暂不支持动图水印。
     * @return WatermarkList 水印信息列表。
注意：
1. 最多支持4个不同位置的水印。
2. 水印图片 URL 请使用合法外网可访问地址


user) {
            return done(null, false, {
              message: "존재하지 않는 사용자입니다.",
            });
          }

          if (pw === user.pw) {
            return done(null, user);
          }

          return done(null, false, { message: "비밀번호가 틀렸습니다." });
        } catch (error) {
          console.error(error);
          return done(error);
        }
      }
    )
  );
};
import { Constants } from "../managers/Constants";

export class CanvasGraphicsRenderer
{
    // CanvasRenderer.registerPlugin('graphics', CanvasGraphicsRenderer);
    /**
     * @param {PIXI.CanvasRenderer} renderer - The current PIXI renderer.
     */
    public renderer:any;
    public _prevTint:any;
    public dirty:any;
    public tint:any;

    constructor(renderer)
    {
        this.renderer = renderer;
    }

    /**
     * Renders a Graphics object to a canvas.
     *
     * @param {PIXI.Graphics} graphics - the actual graphics object to render
     */
    public render(graphics)
    {
        const renderer = this.renderer;
        const context = renderer.context;
        const worldAlpha = graphics.worldAlpha;
        const transform = graphics.transform.worldTransform;
        const resolution = renderer.resolution;

         // if the tint has changed, set the graphics object to dirty.
        if (this._prevTint !== this.tint)
        {
            this.dirty = true;
        }

        context.setTransform(
            transform.a * resolution,
            transform.b * resolution,
            transform.c * resolution,
            transform.d * resolution,
            transform.tx * resolution,
            transform.ty * resolution
        );

        if (graphics.dirty)
        {
            this.updateGraphicsTint(graphics);
            graphics.dirty = false;
        }

        renderer.setBlendMode(graphics.blendMode);

        for (let i = 0; i < graphics.graphicsData.length; i++)
        {
            const data = graphics.graphicsData[i];
            const shape = data.shape;

            const fillColor = data._fillTint;
            const lineColor = data._lineTint;

            context.lineWidth = data.lineWidth;

            if (data.type === Constants.SHAPES.POLY)
            {
                context.beginPath();

                this.renderPolygon(shape.points, shape.closed, context);

                for (let j = 0; j < data.holes.length; j++)
                {
                    this.renderPolygon(data.holes[j].points, true, context);
                }

                if (data.fill)
                {
                    context.globalAlpha = data.fillAlpha * worldAlpha;
                    context.fillStyle = `#${(`00000${(fillColor | 0).toString(16)}`).substr(-6)}`;
                    context.fill();
                }
                if (data.lineWidth)
                {
                    context.globalAlpha = data.lineAlpha * worldAlpha;
                    context.strokeStyle = `#${(`00000${(lineColor | 0).toString(16)}`).substr(-6)}`;
                    context.stroke();
                }
            }
            else if (data.type === Constants.SHAPES.RECT)
            {
                if (data.fillColor || data.fillColor === 0)
                {
                    context.globalAlpha = data.fillAlpha * worldAlpha;
                    context.fillStyle = `#${(`00000${(fillColor | 0).toString(16)}`).substr(-6)}`;
                    context.fillRect(shape.x, shape.y, shape.width, shape.height);
                }
                if (data.lineWidth)
                {
                    context.globalAlpha = data.lineAlpha * worldAlpha;
                    context.strokeStyle = `#${(`00000${(lineColor | 0).toString(16)}`).substr(-6)}`;
                    context.strokeRect


              double div = c[4] * c[2] / c[1] - c[5];
                rw = (c[3] + c[4] * location.X / c[1] - c[4] * c[0] / c[1] - location.Y) / div;
                cl = (location.X - c[2] * rw - c[0]) / c[1];
            }

            var iRow = (int)Math.Round(rw);
            var iCol = (int)Math.Round(cl);
            return new RcIndex(iRow, iCol);
        }

        #endregion

    }
}


t::db::schema::schedules::dsl;

    let conn = pool.get()?;
    let count = dsl::schedules
        .filter(dsl::external_id.eq(new.external_id))
        .filter(dsl::source.eq(new.source))
        .count()
        .get_result(&conn)?;

    Ok(count)
}

// MARK: add

fn add_schedule(
    pool: &ConnectionPool,
    external_id: i32,
    source: ExternalSource,
) -> Result<Schedule, QueryError> {
    use satelit_import::db::schedules::Schedules;

    let table = Schedules::new(pool.clone());
    let new = NewSchedule::new(external_id, source);
    table.put(&new)?;

    let schedule = fetch_schedule_from_new(&pool, &new)?;
    let mut update = UpdatedSchedule::default();
    update.next_update_at = Some(chrono::Utc::now());
    table.update(schedule.id, &update)?;

    fetch_schedule_from_new(&pool, &new)
}

// MARK: fetch

fn fetch_task_by_id(pool: &ConnectionPool, task_id: &Uuid) -> Result<Task, QueryError> {
    use satelit_import::db::schema::tasks::dsl;

    let conn = pool.get()?;
    let task: Task = dsl::tasks.find(&task_id).get_result(&conn)?;

    Ok(task)
}

fn fetch_queued_schedules(pool: &ConnectionPool, task: &Task) -> Result<Vec<Schedule>, QueryError> {
    use satelit_import::db::schema::{queued_jobs::dsl, schedules};

    let conn = pool.get()?;
    let schedules = dsl::queued_jobs
        .filter(dsl::task_id.eq(&task.id))
        .inner_join(schedules::table)
        .select(schedules::all_columns)
        .get_results(&conn)?;

    Ok(schedules)
}

fn fetch_schedule_from_new(
    pool: &ConnectionPool,
    new: &NewSchedule,
) -> Result<Schedule, QueryError> {
    use satelit_import::db::schema::schedules::dsl;

    let conn = pool.get()?;
    let schedule = dsl::schedules
        .filter(dsl::external_id.eq(new.external_id))
        .filter(dsl::source.eq(new.source))
        .get_result(&conn)?;

    Ok(schedule)
}

// MARK: delete

fn delete_task(pool: &ConnectionPool, task: &Task) -> Result<(), QueryError> {
    use satelit_import::db::schema::tasks::dsl;

    let conn = pool.get()?;
    diesel::delete(dsl::tasks.find(&task.id)).execute(&conn)?;

    Ok(())
}

fn delete_task_jobs(pool: &ConnectionPool, task: &Task) -> Result<(), QueryError> {
    use satelit_import::db::schema::queued_jobs::dsl;

    let conn = pool.get()?;
    diesel::delete(dsl::queued_jobs.filter(dsl::task_id.eq(&task.id))).execute(&conn)?;

    Ok(())
}

// DO NOT DELETE SCHEDULES IF YOU EVER BIND JOBS TO SCRAPING TASKS!!!!!
fn delete_schedules_by_ids(pool: &ConnectionPool, schedules: &[i32]) -> Result<(), QueryError> {
    use satelit_import::db::schema::schedules::dsl;

    if schedules.is_empty() {
        return Ok(());
    }

    let conn = pool.get()?;
    let target = dsl::id.eq(diesel::pg::expression::dsl::any(schedules));
    diesel::delete(dsl::schedules.filter(target)).execute


_mag": 0.017339878390888002}, {"class": "Scout", "name": "M1000 Classic (ABBBA) + Hoverclock", "expend_time": 0.1856138395285509, "dmg_per_mag": 0.008671547420113904}, {"class": "Scout", "name": "M1000 Classic (ABBBA) + Minimal Clips", "expend_time": 0.1672030889891996, "dmg_per_mag": 0.01150202283914218}, {"class": "Scout", "name": "M1000 Classic (ABBBA) + Active Stability System", "expend_time": 0.20067718087892925, "dmg_per_mag": 0.008671547420113904}, {"class": "Scout", "name": "M1000 Classic (ABBBA) + Hipster", "expend_time": 0.2679363389720441, "dmg_per_mag": 0.005609487648619677}, {"class": "Scout", "name": "M1000 Classic (ABBBA) + Electrocuting Focus Shots", "expend_time": 0.1856138395285509, "dmg_per_mag": 0.008671547420113904}, {"class": "Scout", "name": "M1000 Classic (ABBBA) + Supercooling Chamber", "expend_time": 0.12151095355971861, "dmg_per_mag": 0.008671547420113904}, {"class": "Scout", "name": "M1000 Classic (ABBBB) + Hoverclock", "expend_time": 0.1856138395285509, "dmg_per_mag": 0.008671547420113904}, {"class": "Scout", "name": "M1000 Classic (ABBBB) + Minimal Clips", "expend_time": 0.1672030889891996, "dmg_per_mag": 0.01150202283914218}, {"class": "Scout", "name": "M1000 Classic (ABBBB) + Active Stability System", "expend_time": 0.20067718087892925, "dmg_per_mag": 0.008671547420113904}, {"class": "Scout", "name": "M1000 Classic (ABBBB) + Hipster", "expend_time": 0.2679363389720441, "dmg_per_mag": 0.005609487648619677}, {"class": "Scout", "name": "M1000 Classic (ABBBB) + Electrocuting Focus Shots", "expend_time": 0.1856138395285509, "dmg_per_mag": 0.008671547420113904}, {"class": "Scout", "name": "M1000 Classic (ABBBB) + Supercooling Chamber", "expend_time": 0.12151095355971861, "dmg_per_mag": 0.008671547420113904}, {"class": "Scout", "name": "M1000 Classic (ABBBC) + Hoverclock", "expend_time": 0.17313570229481637, "dmg_per_mag": 0.008671547420113904}, {"class": "Scout", "name": "M1000 Classic (ABBBC) + Minimal Clips", "expend_time": 0.15749794552761026, "dmg_per_mag": 0.01150202283914218}, {"class": "Scout", "name": "M1000 Classic (ABBBC) + Active Stability System", "expend_time": 0.1881990436451947, "dmg_per_mag": 0.008671547420113904}, {"class": "Scout", "name": "M1000 Classic (ABBBC) + Hipster", "expend_time": 0.23776212306080402, "dmg_per_mag": 0.005609487648619677}, {"class": "Scout", "name": "M1000 Classic (ABBBC) + Electrocuting Focus Shots", "expend_time": 0.17313570229481637, "dmg_per_mag": 0.008671547420113904},


 edit_time(&mut self, time: &str) {
        let t = match NaiveTime::from_str(time) {
            Ok(t) => t,
            Err(_) => NaiveTime::from_hms(0, 0, 0),
        };
        self.execute_time = t;
    }

    pub fn edit_token(&mut self, token: &str) {
        self.device_token = token.into();
    }

    pub fn from(task: &Task) -> Self {
        Self {
            name: task.name.clone(),
            succeed_count: task.succeed_count,
            failed_count: task.failed_count,
            last_executed: task.last_executed,
            owner: task.owner.clone(),
            command: task.command.clone(),
            execute_time: task.execute_time,
            device_token: task.device_token.clone(),
            active: task.active,
        }
    }
}<gh_stars>0
use core::sync::atomic::*;
use {
    super::*, crate::object::*, alloc::sync::Arc, alloc::vec::Vec, bitflags::bitflags,
    kernel_hal::PageTable, spin::Mutex,
};

bitflags! {
    pub struct VmarFlags: u32 {
        #[allow(clippy::identity_op)]
        const COMPACT               = 1 << 0;
        const SPECIFIC              = 1 << 1;
        const SPECIFIC_OVERWRITE    = 1 << 2;
        const CAN_MAP_SPECIFIC      = 1 << 3;
        const CAN_MAP_READ          = 1 << 4;
        const CAN_MAP_WRITE         = 1 << 5;
        const CAN_MAP_EXECUTE       = 1 << 6;
        const REQUIRE_NON_RESIZABLE = 1 << 7;
        const ALLOW_FAULTS          = 1 << 8;
        const CAN_MAP_RXW           = Self::CAN_MAP_READ.bits | Self::CAN_MAP_EXECUTE.bits | Self::CAN_MAP_WRITE.bits;
        const ROOT_FLAGS            = Self::CAN_MAP_RXW.bits | Self::CAN_MAP_SPECIFIC.bits;
    }
}

/// Virtual Memory Address Regions
pub struct VmAddressRegion {
    flags: VmarFlags,
    base: KObjectBase,
    _counter: CountHelper,
    addr: VirtAddr,
    size: usize,
    parent: Option<Arc<VmAddressRegion>>,
    page_table: Arc<Mutex<PageTable>>,
    /// If inner is None, this region is destroyed, all operations are invalid.
    inner: Mutex<Option<VmarInner>>,
}

impl_kobject!(VmAddressRegion);
define_count_helper!(VmAddressRegion);

/// The mutable part of `VmAddressRegion`.
#[derive(Default)]
struct VmarInner {
    children: Vec<Arc<VmAddressRegion>>,
    mappings: Vec<Arc<VmMapping>>,
}

impl VmAddressRegion {
    /// Create a new root VMAR.
    pub fn new_root() -> Arc<Self> {
        // FIXME: workaround for unix
        static VMAR_ID: AtomicUsize = AtomicUsize::new(0);
        let i = VMAR_ID.fetch_add(1, Ordering::SeqCst);
        let addr: usize = 0x2_00000000 + 0x100_00000000 * i;
        Arc::new(VmAddressRegion {
            flags: VmarFlags::ROOT_FLAGS,
            base: KObjectBase::new(),
            _counter: CountHelper::new(),
            addr,
            size: 0x100_00000000,
            parent: None,
            page_table: Arc::new(Mutex::new(kernel_hal::PageTable::new())),
            inner: Mutex::new(Some(VmarInner::default())),
        })
    }
    /// Create a kernel root VMAR.
    pub fn new_kernel() -> Arc<Self> {
        let kernel_vmar_base = 0xffff_ff02_0000


ами в цельную и яркую историю, которая способна перевернуть ваш мир. И да, это любимая книга Букли!\n",
    },
    {
        name: "Преступление и наказание\n",
        author: "Федор Михайлович Достоевский\n",
        description: "Книга из школьной программы, которую трудно понять в нежном подростковом возрасте. Писатель показал двойственность человеческой души, когда черное переплетается с белым. История о Раскольникове, который переживает внутреннюю борьбу.\n",
    },
    {
        name: "Маленький принц\n",
        author: "Антуан де Сент-Экзюпери\n",
        description: "Небольшая история, в которой заключен огромный жизненный смысл. История, которая заставляет по-другому посмотреть на привычные вещи.\n",
    },
    {
        name: "Собачье сердце\n",
        author: "Михаил Булгаков\n",
        description: "Удивительно тонкая и саркастическая история о людях и их пороках. История об эксперименте, который доказал, что из животного можно сделать человека, а вот вывести «животное» из человека нельзя.\n",
    },
    {
        name: "Три товарища\n",
        author: "Эрих Мария Ремарк\n",
        description: "Рассказать о чем повествует этот роман невозможно. Роман нужно читать, и тогда придет понимание, что это не просто история, а исповедь. Исповедь о любви, дружбе, боли. История отчаяния и борьбы.\n",
    },
    {
        name: "Над пропастью во ржи\n",
        author: "Джером Сэлинджер\n",
        description: "История подростка, который своими глазами показывает свое восприятие мира, точку мировоззрения, отречение от привычных принципов и устоев морали общества, которые не вписываются в его индивидуальные рамки.\n",
    },
    {
        name: "Герой нашего времени\n",
        author: "Михаил Лермонтов\n",
        description: "Лирико-психологический роман, который повествует о человеке со сложным характером. Автор показывает его с разных сторон. А нарушенная хронология событий, заставляет полностью погрузиться в повествование.\n",
    },
    {
        name: "Приключения Шерлока Холмса\n",
        author: "Артур Конан Дойл\n",
        descrip


0x95,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80955551 <unknown>

fmops   za3.s, p3/m, p7/m, z13.s, z8.s
// CHECK-INST: fmops   za3.s, p3/m, p7/m, z13.s, z8.s
// CHECK-ENCODING: [0xb3,0xed,0x88,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 8088edb3 <unknown>

fmops   za3.s, p7/m, p7/m, z31.s, z31.s
// CHECK-INST: fmops   za3.s, p7/m, p7/m, z31.s, z31.s
// CHECK-ENCODING: [0xf3,0xff,0x9f,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 809ffff3 <unknown>

fmops   za1.s, p3/m, p0/m, z17.s, z16.s
// CHECK-INST: fmops   za1.s, p3/m, p0/m, z17.s, z16.s
// CHECK-ENCODING: [0x31,0x0e,0x90,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80900e31 <unknown>

fmops   za1.s, p1/m, p4/m, z1.s, z30.s
// CHECK-INST: fmops   za1.s, p1/m, p4/m, z1.s, z30.s
// CHECK-ENCODING: [0x31,0x84,0x9e,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 809e8431 <unknown>

fmops   za0.s, p5/m, p2/m, z19.s, z20.s
// CHECK-INST: fmops   za0.s, p5/m, p2/m, z19.s, z20.s
// CHECK-ENCODING: [0x70,0x56,0x94,0x80]
// CHECK-ERROR: instruction req


� 동시성에 대한 문제를 호출자에게 위임하라
* 멀티 스레드 환경에서의 빌드, 실행을 거부하라
* 두 가지 구현을 지원하라. 단일 스레드 환경을 위한 구현과 멀티 스레드 환경을 위한 것 모두

##### Exception

멀티 스레드 환경에서 절대 실행되지 않을 코드.

주의: 멀티 스레드 프로그램에서 절대로 돌아가지 않을 줄 "알았던" 코드들이 몇년 뒤엔 멀티 스레드 프로그램의 일부가 된 사례는 많이 있다. 일반적으로, 그런 프로그램들은 데이터 경쟁을 없애기 위한 고통스러운 노력으로 이어진다.
때문에, 멀티 스레드 환경에서 실행되는 것을 의도하지 않은 코드들은 분명하게 해당 사항이 기술되어야 하고, 이상적으로는 컴파일 또는 실행시간에 버그를 일찍 찾을 수 있는 메커니즘이 함께 사용되되어야 한다.

### CP.2: 데이터 경쟁을 피하라

##### Reason

데이터 경쟁이 있으면, 아무것도 보장할 수 없으며 미묘한 에러들이 계속될 것이다.

##### Note

쉽게 말해서, 만약 두 스레드가 같은 객체를 (동기화 없이) 동시적으로 접근할 수 있다면, 그리고 한 스레드가 쓰기(non-`const` 연산)를 수행한다면, 데이터 경쟁이 있는 것이다.
어떻게 동기화를 사용하고 데이터 경쟁을 없앨 것인지 더 알고 싶다면 동시성에 대한 좋은 책들을 참고하라.

##### Example, bad

데이터 경쟁이 존재하는 예시는 많다. 지금 이 순간 실행 중인 production 소프트웨어들 중에도 존재할 것이다.

간단한 예시를 들자면:

```c++
    int get_id() {
      static int id = 1;
      return id++;
    }
```

여기서 증가 연산은 데이터 경쟁의 예시다.

이 코드는 다음과 같이 잘못될 수 있다:

* 스레드 A가 `id`를 로드하고, OS가 A를 중지시킨다. 그 사이 다른 스레드가 ID를 수백 개 생성한다. 그 후에 A는 다시 실행되고, A의 문맥에서 증가한 `id`값이 다시 써지게 된다.
* 스레드 A와 B가 `id`를 로드하고 동시에 증가시킨다. 그 결과 두


ase) {
    _storableMethodBrand!: void;

    /**
     * @constructor
     *
     * Creates a storable method. Typically, instead of using this constructor, you would rather use the [`@method()`](https://layrjs.com/docs/v2/reference/storable#method-decorator) decorator.
     *
     * @param name The name of the method.
     * @param parent The [storable component](https://layrjs.com/docs/v2/reference/storable#storable-component-class) class, prototype, or instance that owns the method.
     * @param [options] An object specifying any option supported by the constructor of [`Method`](https://layrjs.com/docs/v2/reference/method#constructor) and [`StorableProperty`](https://layrjs.com/docs/v2/reference/storable-property#constructor).
     *
     * @returns The [`StorableMethod`](https://layrjs.com/docs/v2/reference/storable-method) instance that was created.
     *
     * @category Creation
     */

    // === Property Methods ===

    /**
     * See the methods that are inherited from the [`Property`](https://layrjs.com/docs/v2/reference/property#basic-methods) class.
     *
     * @category Property Methods
     */

    // === Finder ===

    /**
     * See the methods that are inherited from the [`StorableProperty`](https://layrjs.com/docs/v2/reference/storable-property#finder) class.
     *
     * @category Finder
     */

    // === Utilities ===

    static isStorableMethod(value: any): value is StorableMethod {
      return isStorableMethodInstance(value);
    }
  };

export function isStorableMethodClass(value: any): value is typeof StorableMethod {
  return typeof value?.isStorableMethod === 'function';
}

export function isStorableMethodInstance(value: any): value is StorableMethod {
  return isStorableMethodClass(value?.constructor) === true;
}

export class StorableMethod extends StorableMethodMixin(Method) {
  constructor(
    name: string,
    parent: typeof Component | Component,
    options: StorableMethodOptions = {}
  ) {
    assertIsStorableClassOrInstance(parent);

    super(name, parent, options);
  }
}
import { cmd } from "../CommandRunner";
import { TagFormatter } from "../formatting/TagFormatter";
import { LastReleaseResolver } from "./LastReleaseResolver";
import { ReleaseInformation } from "./ReleaseInformation";
import { ActionConfig } from "../ActionConfig";
import * as core from '@actions/core';

export class DefaultLastReleaseResolver implements LastReleaseResolver {

    private changePath: string;
    private useBranches: boolean;

    constructor(config: ActionConfig) {
        this.changePath = config.changePath;
        this.useBranches = config.useBranches;
    }

    async ResolveAsync(current: string, tagFormatter: TagFormatter): Promise<ReleaseInformation> {
        const releasePattern = tagFormatter.GetPattern();

        let currentTag = (await cmd(
            `git tag --points-at ${current} ${releasePattern}`
        )).trim();

        currentTag = tagFormatter.IsValid(currentTag) ? currentTag : '';
        const isTagged = currentTag !== '';

        const [currentMajor, currentMinor, currentPatch] = !!currentTag ? tagFormatter.Parse(currentTag) : [null, null, null];

        let tagsCount = 0;

        let tag = '';
        try {
            const refPrefixPattern = this.use


eo)
final hideVideoProvider = AutoDisposeNotifierProvider<HideVideo, bool>.internal(
  HideVideo.new,
  name: r'hideVideoProvider',
  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
      ? null
      : _$hideVideoHash,
  dependencies: null,
  allTransitiveDependencies: null,
);

typedef _$HideVideo = AutoDisposeNotifier<bool>;
String _$hideWebHash() => r'1c5e86e7cdfa3828d19b7fad69184cf3c7f27b5c';

/// See also [HideWeb].
@ProviderFor(HideWeb)
final hideWebProvider = AutoDisposeNotifierProvider<HideWeb, bool>.internal(
  HideWeb.new,
  name: r'hideWebProvider',
  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
      ? null
      : _$hideWebHash,
  dependencies: null,
  allTransitiveDependencies: null,
);

typedef _$HideWeb = AutoDisposeNotifier<bool>;
String _$hideAppHash() => r'd20b22def65bc68c2db70addae739dd24af2c7fc';

/// See also [HideApp].
@ProviderFor(HideApp)
final hideAppProvider = AutoDisposeNotifierProvider<HideApp, bool>.internal(
  HideApp.new,
  name: r'hideAppProvider',
  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
      ? null
      : _$hideAppHash,
  dependencies: null,
  allTransitiveDependencies: null,
);

typedef _$HideApp = AutoDisposeNotifier<bool>;
String _$hideUnknownHash() => r'dc2ed5459af103f4f0db607da90ca42ec755214f';

/// See also [HideUnknown].
@ProviderFor(HideUnknown)
final hideUnknownProvider =
    AutoDisposeNotifierProvider<HideUnknown, bool>.internal(
      HideUnknown.new,
      name: r'hideUnknownProvider',
      debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
          ? null
          : _$hideUnknownHash,
      dependencies: null,
      allTransitiveDependencies: null,
    );

typedef _$HideUnknown = AutoDisposeNotifier<bool>;
String _$matureShowStateHash() => r'fb044e357a784b7573cfbddc33e52f07e8dd202f';

/// See also [MatureShowState].
@ProviderFor(MatureShowState)
final matureShowStateProvider =
    AutoDisposeNotifierProvider<MatureShowState, MatureState>.internal(
      MatureShowState.new,
      name: r'matureShowStateProvider',
      debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
          ? null
          : _$matureShowStateHash,
      dependencies: null,
      allTransitiveDependencies: null,
    );

typedef _$MatureShowState = AutoDisposeNotifier<MatureState>;
String _$onlySaveImageHash() => r'f6060d1fc9216c6d70877022025d25cc9a6ac7ed';

/// See also [OnlySaveImage].
@ProviderFor(OnlySaveImage)
final onlySaveImageProvider =
    AutoDisposeNotifierProvider<OnlySaveImage, bool>.internal(
      OnlySave


g.select[0].selectedIndex = $(this).attr('index'); g.select[0].onchange();
                }
                var newIndex = parseInt($(this).attr('index'));
                g.select[0].selectedIndex = newIndex;
                g.select.trigger("change");
                g.selectBox.hide();
                var value = $(this).attr("value");
                var text = $(this).html();

                if (p.render)
                {
                    g.inputText.val(p.render(value, text));
                }
                else
                {
                    g.inputText.val(text);
                }

            });
            g._addClickEven();
        },
        _setData: function (data)
        {
            this.setData(data);
        },
        getRowIndex : function(value)
        {
            var g = this, p = this.options;
            if (!value) return -1;
            if (!g.data || !g.data.length) return -1;
            for (var i = 0; i < g.data.length; i++)
            {
                if (g.data[i] == null) continue;
                var val = g.data[i][p.valueField];
                if (val == value) return i;
            }
            return -1;
        },
        //获取行数据
        getRow : function(value)
        {
            var g = this, p = this.options;
            if (!value) return null;
            if (!g.data || !g.data.length) return null;
            for (var i = 0; i < g.data.length; i++)
            {
                if (g.data[i] == null) continue;
                var val = g.data[i][p.valueField];
                if (val == value) return g.data[i];
            }
            return null;
        },
        setData: function (data)
        {
            var g = this, p = this.options;
            if (g.select) return;
            if (p.selectBoxRender)
            {
                p.selectBoxRender.call(g, {
                    selectBox: g.selectBox,
                    data : data
                });
                return;
            }
            if (!data || !data.length) data = [];
            if (g.data != data) g.data = data;
            g.data = $.isFunction(g.data) ? g.data() : g.data;
            this.clearContent();
            if (p.columns)
            {
                g.selectBox.table.headrow = $("

");
                g.selectBox.table.append(g.selectBox.table.headrow);
                g.selectBox.table.addClass("l-box-select-grid");
                for (var j = 0; j < p.columns.length; j++)
                {
                    var headrow = $("" + p.columns[j].header + "	");
                    if (p.columns[j].width)
                    {
                        headrow.width(p.columns[j].width);
                    }
                    g.selectBox.table.headrow.append(headrow);

                }
            }
            var out = [];
            if (p.emptyText)
            {
                g.emptyRow = {};
                g.emptyRow[p.textField] = p.emptyText;
                g.emptyRow[p.valueField] = p.emptyValue != undefined ? p.emptyValue : "";
                data.splice(0, 0, g.emptyRow);
            }
            for (var i = 0; i < data.length; i++)
            {
                var val = data[i][p.valueField];
                var txt = data[i][p.textField];
                var isRowReadOnly = $.isFunction(p.isRowReadOnly) ? p.isRowReadOnly(data[i]) : false;
                if (!p.columns)
                {
                    out.push("<tr value='" + val + "'");

                    var cls = [];
                    if (isRowReadOnly) cls.push(" rowre


3046875,
			16.757530212402344,
		},
		alt_min_vector = {
			359.03668212890625,
			-238.91619873046875,
			7.132528781890869,
		},
		bottom_points = {
			{
				364.1884460449219,
				-238.41619873046875,
				7.132528781890869,
			},
			{
				355.66168212890625,
				-238.41619873046875,
				7.132528781890869,
			},
			{
				355.66168212890625,
				-239.41619873046875,
				7.132528781890869,
			},
			{
				364.25054931640625,
				-239.41619873046875,
				7.132528781890869,
			},
		},
		color = {
			255,
			255,
			125,
			0,
		},
		up_vector = {
			0,
			0,
			1.9489619731903076,
		},
	},
	{
		height = 8,
		name = "volume_blocker_tb_018",
		type = "content/volume_types/player_mover_blocker",
		alt_max_vector = {
			307.3312683105469,
			-222.0362091064453,
			13.552648544311523,
		},
		alt_min_vector = {
			307.3312683105469,
			-222.0362091064453,
			13.250816345214844,
		},
		bottom_points = {
			{
				307.7202453613281,
				-225.07029724121094,
				13.250816345214844,
			},
			{
				307.7202453613281,
				-220.3024444580078,
				13.250816345214844,
			},
			{
				305.1919250488281,
				-220.3024444580078,
				13.250816345214844,
			},
			{
				305.19189453125,
				-225.07028198242188,
				13.250816345214844,
			},
		},
		color = {
			255,
			255,
			125,
			0,
		},
		up_vector = {
			-0,
			[2] = 0,
			[3] = 0.03772899881005287,
		},
	},
	{
		height = 8,
		name = "volume_blocker_010",
		type = "content/volume_types/player_mover_blocker",
		alt_max_vector = {
			351.2984924316406,
			-129.92431640625,
			24.748201370239258,
		},
		alt_min_vector = {
			351.2984924316406,
			-129.92431640625,
			1.462391972541809,
		},
		bottom_points = {
			{
				347.291748046875,
				-128.7212371826172,
				1.462391972541809,
			},
			{
				347.2917785644531,
				-133.64431762695312,
				1.462391972541809,
			},
			{
				355.30523681640625,
				-133.644287109375,
				1.462391972541809,
			},
			{
				355.3052062988281,
				-128.72120666503906,
				1.462391972541809,
			},
		},
		color = {
			255,
			255,
			125,
			0,
		},
		up_vector = {
			0,
			0,


lf._check_error_rates(context)
        if not error_rates["valid"]:
            result["warnings"].append({
                "type": "error_rate",
                "reason": error_rates["reason"]
            })

        # Check resource utilization
        utilization = await self._check_resource_utilization(context)
        if not utilization["valid"]:
            result["warnings"].append({
                "type": "resource_utilization",
                "reason": utilization["reason"]
            })

    async def _validate_security(self, context: GPTContext, result: Dict):
        """Validate security aspects of a context."""
        # Check access controls
        access_controls = await self._check_access_controls(context)
        if not access_controls["valid"]:
            result["is_valid"] = False
            result["issues"].append({
                "type": "access_control",
                "reason": access_controls["reason"]
            })

        # Check data sharing security
        data_sharing = await self._check_data_sharing_security(context)
        if not data_sharing["valid"]:
            result["is_valid"] = False
            result["issues"].append({
                "type": "data_sharing",
                "reason": data_sharing["reason"]
            })

        # Check audit trail
        audit_trail = await self._check_audit_trail(context)
        if not audit_trail["valid"]:
            result["warnings"].append({
                "type": "audit_trail",
                "reason": audit_trail["reason"]
            })


ment, clazz: ClassEntity) : BaseWrapper<JavaObject>(env, clazz) {

    companion object {
        // 创建 PQueryBuilder 实例
        fun of(env: Environment, qb: IDbQueryBuilder): PQueryBuilder {
            val obj = PQueryBuilder(env, env.fetchClass(JkmvcOrmExtension.NS + "\\QueryBuilder"))
            obj.query = qb
            return obj
        }
    }

    // 代理的query builder
    lateinit var query: IDbQueryBuilder

    // 代理的orm query builder
    val ormQuery: OrmQueryBuilder
        get() = query as OrmQueryBuilder

    // 缓存php内存对象，因为链式调用多，一般会创建很多内存对象，因此要复用内存对象
    val objMem = ObjectMemory()
    init {
        objMem.value = this
    }

    /**
     * 设置表名
     *
     * @param table 表名
     * @param alias 别名
     * @return
     */
    @Reflection.Signature
    @JvmOverloads
    fun table(table:String, alias:String? = null): ObjectMemory {
        return from(table, alias)
    }

    /**
     * 设置表名
     *
     * @param table 表名
     * @param alias 别名
     * @return
     */
    @Reflection.Signature
    @JvmOverloads
    fun from(table:String, alias:String? = null): ObjectMemory{
        query.from(table, alias)
        return objMem
    }

    /**
     * 设置插入的列, insert时用
     *
     * @param column
     * @return
     */
    @Reflection.Signature
    fun insertColumns(vararg colums:String): ObjectMemory{
        query.insertColumns(*colums)
        return objMem
    }

    /**
     * 设置插入的单行值, insert时用
     *    插入的值的数目必须登录插入的列的数目
     * @param row
     * @return
     */
    @Reflection.Signature
    fun value(row: ArrayMemory): ObjectMemory{
        if(row.isMap)
            query.value(row.toPureMap())
        else
            query.value(*row.toPureArray())
        return objMem
    }

    /**
     * 设置更新的单个值, update时用
     *
     * @param column
     * @param value
     * @return
     */
    @Reflection.Signature
    fun set(column:String, value:Any?): ObjectMemory{
        query.set(column, value)
        return objMem
    }

    /**
     * 设置更新的多个值, update时用
     *
     * @param row
     * @return
     */
    @Reflection.Signature
    fun sets(row: ArrayMemory): ObjectMemory{
        query.sets(row.toPureMap() as Map<String, Any?>)
        return objMem
    }

    /**
     * 设置查询的字段, select时用
     *
     * @param columns 字段名数组，其元素类型是 String 或 Pair
     * @return
     */
    @Reflection.Signature
    fun select(columns:ArrayMemory): ObjectMemory{
        query.select(*buildSelectColumns(columns))
        return objMem
    }

    /**
     * 构建查询字段
     */
    private fun buildSelectColumns(columns: ArrayMemory): Array<CharSequence> {
        val cols: Array<CharSequence>
        if (columns.isMap) {
            cols = columns.toPureMap().entries.mapToArray { (k, v) ->
                if (k is Int)
                    v!!.toString()
                else
                    DbExpr(k.toString(), v.toString())
            }
        } else {
            cols = columns.toPureArray() as Array<Char


 */
public class PdfATtfUnicodeWriter extends TtfUnicodeWriter {
    final protected PdfAConformanceLevel pdfAConformanceLevel;

    /**
     * @see TtfUnicodeWriter#TtfUnicodeWriter(PdfWriter)
     */
    public PdfATtfUnicodeWriter(PdfWriter writer, PdfAConformanceLevel pdfAConformanceLevel) {
        super(writer);
        this.pdfAConformanceLevel = pdfAConformanceLevel;
    }

    /**
     * @see TtfUnicodeWriter#writeFont(TrueTypeFontUnicode, PdfIndirectReference, Object[], byte[])
     */
    public void writeFont(TrueTypeFontUnicode font, PdfIndirectReference ref, Object params[], byte[] rotbits) throws DocumentException, IOException {
        @SuppressWarnings("unchecked")
		HashMap<Integer, int[]> longTag = (HashMap<Integer, int[]>)params[0];
        font.addRangeUni(longTag, true, font.subset);
        int metrics[][] = longTag.values().toArray(new int[0][]);
        Arrays.sort(metrics, font);
        PdfIndirectReference ind_font;
        PdfObject pobj;
        PdfIndirectObject obj;
        if (font.cff) {
            byte b[] = font.readCffFont();
            if (font.subset || font.subsetRanges != null) {
                CFFFontSubset cff = new CFFFontSubset(new RandomAccessFileOrArray(b),longTag);
                try {
                    b = cff.Process(cff.getNames()[0]);
                    //temporary fix for cff subset failure
                } catch(Exception e) {
                    LoggerFactory.getLogger(PdfATtfUnicodeWriter.class).error("Issue in CFF font subsetting." +
                            "Subsetting was disabled", e);
                    font.setSubset(false);
                    font.addRangeUni(longTag, true, font.subset);
                    metrics = longTag.values().toArray(new int[0][]);
                    Arrays.sort(metrics, font);
                }
            }
            pobj = new BaseFont.StreamFont(b, "CIDFontType0C", font.compressionLevel);
            obj = writer.addToBody(pobj);
            ind_font = obj.getIndirectReference();
        } else {
            byte[] b;
            if (font.subset || font.directoryOffset != 0) {
                synchronized (font.rf) {
                    TrueTypeFontSubSet sb = new TrueTypeFontSubSet(font.fileName, new RandomAccessFileOrArray(font.rf), new HashSet<Integer>(longTag.keySet()), font.directoryOffset, false, false);
                    b = sb.process();
                }
            } else {
                b = font.getFullFont();
            }
            int lengths[] = new int[]{b.length};
            pobj = new BaseFont.StreamFont(b, lengths, font.compressionLevel);
            obj = writer.addToBody(pobj);
            ind_font = obj.getIndirectReference();
        }
        // CIDSet shall be based on font.maxGlyphId property of the font, it is maxp.numGlyphs for ttf,
        // because technically we convert all unused glyphs to space, e.g. just remove outlines.
        byte[] cidSetBytes = new byte[font.maxGlyphId / 8 + 1];
        for (int i = 0; i < font.maxGlyphId / 8; i++) {
            cidSetBytes[i] |= 0xff;
        }
        for (int i = 0; i < font.maxGlyphId % 8; i++) {
            cidSetBytes[cidSetBytes.length - 1] |= rotbits[i];
        }
        PdfStream stream = new PdfStream(cidSetBytes);
        stream.flateCompress(font.compressionLevel);
        PdfIndirectReference cidset = writer.addToBody(stream).getIndirectReference();

        String subsetPrefix = "";
        if (font.subset)
            subsetPrefix = BaseFont.createSubsetPrefix();
        PdfDictionary dic = font.getFontDescriptor(ind_font, subsetPrefix, cidset);


://mmpose.readthedocs.io/en/latest/model_zoo.html) page.

Supported algorithms:

- [x] [DeepPose](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/algorithms.html#deeppose-cvpr-2014) (CVPR'2014)
- [x] [CPM](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/backbones.html#cpm-cvpr-2016) (CVPR'2016)
- [x] [Hourglass](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/backbones.html#hourglass-eccv-2016) (ECCV'2016)
- [x] [SimpleBaseline3D](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/algorithms.html#simplebaseline3d-iccv-2017) (ICCV'2017)
- [ ] [Associative Embedding](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/algorithms.html#associative-embedding-nips-2017) (NeurIPS'2017)
- [x] [SimpleBaseline2D](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/algorithms.html#simplebaseline2d-eccv-2018) (ECCV'2018)
- [x] [DSNT](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/algorithms.html#dsnt-2018) (ArXiv'2021)
- [x] [HRNet](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/backbones.html#hrnet-cvpr-2019) (CVPR'2019)
- [x] [IPR](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/algorithms.html#ipr-eccv-2018) (ECCV'2018)
- [x] [VideoPose3D](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/algorithms.html#videopose3d-cvpr-2019) (CVPR'2019)
- [x] [HRNetv2](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/backbones.html#hrnetv2-tpami-2019) (TPAMI'2019)
- [x] [MSPN](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/backbones.html#mspn-arxiv-2019) (ArXiv'2019)
- [x] [SCNet](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/backbones.html#scnet-cvpr-2020) (CVPR'2020)
- [ ] [HigherHRNet](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/backbones.html#higherhrnet-cvpr-2020) (CVPR'2020)
- [x] [RSN](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/backbones.html#rsn-eccv-2020) (ECCV'2020)
- [ ] [InterNet](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/algorithms.html#internet-eccv-2020) (ECCV'2020)
- [ ] [VoxelPose](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/algorithms.html#voxelpose-eccv-2020) (ECCV'2020)
- [x] [LiteHRNet](https://mmpose.readthedocs.io/en/latest/model_zoo_papers/backbones.html#litehrnet-cv


10-15 minutes ago.\n",
      "\n",
      "Not sure what is happening.\n",
      "\n",
      "if you aware of the issue and we can maybe just a repair\n",
      "\n",
      "Tomorrow, if you need me to go on site, just please let me know early. And I can meet you over there and try to resolve all this issues before next Monday or business starts.\n",
      "\n",
      "Thank you very much, bye.\n",
      "\n",
      "## On 2025-01-04T04:45:45Z, OpsGenie wrote a note (2329853):\n",
      "[OpsGenie] Alexander Ross acknowledged alert: \"Ticket#1009892/Scout Technology Guides/New Voicemail from 16045005489 - Daniel Gu\" [URL removed]\n",
      "\n",
      "----------------------------------------------------\n",
      "# New Voicemail from 18327820275 - Texas\n",
      "\n",
      "----------------------------------------------------\n",
      "# Laptop Returned (21-131) - Does Scout Need To Do Anything With The Laptop Remotely?\n",
      "\n",
      "## On 2025-01-07T23:53:15Z, Samantha Fogel wrote a note (2331443):\n",
      "#### How many people is this affecting?\n",
      "* One user\n",
      "\n",
      "#### Tip: Common issues may be resolved by restarting your computer.\n",
      "\n",
      "#### Is this a recurring issue?\n",
      "* Yes, This Has Happened Before\n",
      "\n",
      "#### What time are you working till?\n",
      "9-4:30 every day this week.\n",
      "\n",
      "#### Preferred method of contact\n",
      "email\n",
      "\n",
      "#### Specific details about the problem/question?\n",
      "Neda Shadbakht recently returned her laptop (21-131) and I forget if I need to submit a ticket about this or not. Does Scout need to do anything with the laptop remotely before it can go in storage, to eventually be reassigned to someone else? Thanks!\n",
      "\n",
      "## On 2025-01-07T23:53:15Z, Samantha Fogel wrote a note (2331444):\n",
      "> Information recorded by desktop portal client-portal/5.3.1.0.\n",
      "\n",
      "- operation system: Win32NT/10.0.19045.0\n",
      "- portal dir: C:\\WINDOWS\\system32\n",
      "- user name: sfogel\n",
      "- machine name: DELL3050-18-01\n",
      "    - host name: Dell3050-18-01\n",
      "    - address: ::1; 192.168.1.117\n",
      "\n",
      "----------------------------------------------------\n",
      "# Drive Mapping Incorrect And System Unstable\n",
      "\n",
      "## On 2025-01-09T16:47:46Z, Michael McQuigge wrote a note (2333038):\n",
      "#### Office Hours Emergency Support\n",
      "Please note our office is open from Monday - Friday 7:30AM - 5:00PM Pacific time.\n",
      "\n",
      "If you submit this ticket outside these hours we will not see it until the next business day.\n",
      "\n",
      "#### How many people is this affecting?\n",
      "* One user\n",
      "\n",
      "#### Tip: Common issues may be resolved by restarting your computer.\n",
      "\n",
      "#### Is this a recurring issue?\n",
      "* No, First Time This Has Happened\n",
      "\n",
      "#### Specific details about the problem/question?\n",
      "Please urgently contact Namita Murti.\n",
      "After signing in this morning, her user profile is showing old data from the past and the wrong contents of her desktop. The system is also


or csid == 820) and option == 12 and player:getAssaultPoint(LEBROS_ASSAULT_POINT) >= 500 then
        player:setLocalVar("SalvageValid", 3)
    elseif (csid == 818 or csid == 820) and option == 13 and player:getAssaultPoint(PERIQIA_ASSAULT_POINT) >= 500 then
        player:setLocalVar("SalvageValid", 4)
    elseif (csid == 818 or csid == 820) and option == 14 and player:getAssaultPoint(ILRUSI_ASSAULT_POINT) >= 500 then
        player:setLocalVar("SalvageValid", 5)
    end
end

function onEventFinish(player, csid, option)
    local currentday = tonumber(os.date("%j"))

    if (csid == 818 or csid == 820) and option == 100 then
        if player:getLocalVar("SalvageValid") == 1 then
            player:addKeyItem(tpz.ki.REMNANTS_PERMIT)
            player:delCurrency("LEUJAOAM_ASSAULT_POINT", 500)
        elseif player:getLocalVar("SalvageValid") == 2 then
            player:delCurrency("MAMOOL_ASSAULT_POINT", 500)
            player:addKeyItem(tpz.ki.REMNANTS_PERMIT)
        elseif player:getLocalVar("SalvageValid") == 3 then
            player:delCurrency("LEBROS_ASSAULT_POINT", 500)
            player:addKeyItem(tpz.ki.REMNANTS_PERMIT)
        elseif player:getLocalVar("SalvageValid") == 4 then
            player:delCurrency("PERIQIA_ASSAULT_POINT", 500)
            player:addKeyItem(tpz.ki.REMNANTS_PERMIT)
        elseif player:getLocalVar("SalvageValid") == 5 then
            player:delCurrency("ILRUSI_ASSAULT_POINT", 500)
            player:addKeyItem(tpz.ki.REMNANTS_PERMIT)
        end
        player:setLocalVar("SalvageValid", 0)
        player:setCharVar("LAST_PERMIT", currentday)
    end
end


arlbrook: false });
    const deckJSON = deck.toJSON(true /* includePrivate */);
    expect(
      deckJSON.cards.filter((cardName) => {
        return Card.fromName(cardName).expansion === ExpansionType.PEARLBROOK;
      })
    ).to.eql([]);
  });

  it("should return pearlbrook cards if playing with pearlbrook", () => {
    const deck = initialDeck({ pearlbrook: true });
    const deckJSON = deck.toJSON(true /* includePrivate */);
    expect(
      deckJSON.cards.filter((cardName) => {
        return Card.fromName(cardName).expansion === ExpansionType.PEARLBROOK;
      })
    ).to.not.eql([]);
  });
});
import type { Episode, Note } from '../../lib/types';
import useLocalStorage from './useLocalStorage';

export default function useEpisodes(): {
  episodeData: Episode[];
  addEpisodeData: (episode: Episode) => void;
  removeEpisodeData: (episode: Episode) => void;
  addEpisodeNote: (title: string, note: Note) => void;
  updateEpisodeNote: (title: string, note: Note) => void;
  refetch: () => void;
} {
  const [episodeData, setEpisodeData, refetch] = useLocalStorage<Episode[]>(
    'episodes',
    []
  );

  function addEpisodeData(episode: Episode) {
    // const newData = episodeData.push(episode);
    setEpisodeData([...episodeData, episode]);
    // setEpisodeData(newData);
  }

  function addEpisodeNote(id: string, newNote: Note) {
    console.log(episodeData, 'hier');
    const newData = episodeData.map((episode) => {
      if (episode.id === id) {
        episode.notes = [...episode.notes, newNote];
        console.log('inside', episode.notes);
      }
      return episode;
    });
    console.log(newData);
    setEpisodeData(newData);
  }

  function updateEpisodeNote(id: string, newNote: Note) {
    const newData = episodeData.map((episode) => {
      if (episode.id === id) {
        const newNotes = episode.notes.map((note) => {
          if (note.id === newNote.id) {
            return (note = newNote);
          }
          return note;
        });
        episode.notes = [...newNotes];
      }
      return episode;
    });
    setEpisodeData(newData);
  }

  function removeEpisodeData(episode: Episode) {
    setEpisodeData(episodeData.filter((b) => b !== episode));
  }

  return {
    episodeData,
    addEpisodeData,
    removeEpisodeData,
    addEpisodeNote,
    updateEpisodeNote,
    refetch,
  };
}
import crypto from 'crypto'
import jwt from 'jsonwebtoken'
import generator from 'megalodon'

import { getInstance } from '@/features/instances/api'

export const encrypt = (token: string) => {
  const iv = crypto.randomBytes(16)
  const key = Buffer.from(process.env.ENCRYPT_KEY, 'hex')
  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv)
  let encrypted = cipher.update(token, 'utf8', 'hex')
  encrypted += cipher.final('hex')
  return iv.toString('hex') + ':' + encrypted
}

export const decrypt = (token: string) => {
  const [iv, encrypted] = token.split(':')
  const key = Buffer.from(process.env.ENCRYPT_KEY, 'hex')
  const decipher = crypto.createDecipheriv(
    'aes-256-cbc',
    key,
    Buffer.from(iv, 'hex')
  )
  let decrypted =


64 64 64h192c35.2 0 64-28.8 64-64V128H32V448zM96 304C96 295.2 103.2 288 112 288H160V240C160 231.2 167.2 224 176 224h32C216.8 224 224 231.2 224 240V288h48C280.8 288 288 295.2 288 304v32c0 8.799-7.199 16-16 16H224v48c0 8.799-7.199 16-16 16h-32C167.2 416 160 408.8 160 400V352H112C103.2 352 96 344.8 96 336V304zM360 0H24C10.75 0 0 10.75 0 24v48C0 85.25 10.75 96 24 96h336C373.3 96 384 85.25 384 72v-48C384 10.75 373.3 0 360 0z"],print:[512,512,[128424,128438,9113],"f02f","M448 192H64C28.65 192 0 220.7 0 256v96c0 17.67 14.33 32 32 32h32v96c0 17.67 14.33 32 32 32h320c17.67 0 32-14.33 32-32v-96h32c17.67 0 32-14.33 32-32V256C512 220.7 483.3 192 448 192zM384 448H128v-96h256V448zM432 296c-13.25 0-24-10.75-24-24c0-13.27 10.75-24 24-24s24 10.73 24 24C456 285.3 445.3 296 432 296zM128 64h229.5L384 90.51V160h64V77.25c0-8.484-3.375-16.62-9.375-22.62l-45.25-45.25C387.4 3.375 379.2 0 370.8 0H96C78.34 0 64 14.33 64 32v128h64V64z"],"pump-medical":[384,512,[],"e06a","M379.3 94.06l-43.32-43.32C323.1 38.74 307.7 32 290.8 32h-66.75c0-17.67-14.33-32-32-32H127.1c-17.67 0-32 14.33-32 32L96 128h128l-.0002-32h66.75l43.31 43.31c6.248 6.248 16.38 6.248 22.63 0l22.62-22.62C385.6 110.4 385.6 100.3 379.3 94.06zM235.6 160H84.37C51.27 160 23.63 185.2 20.63 218.2l-20.36 224C-3.139 479.7 26.37 512 64.01 512h191.1c37.63 0 67.14-32.31 63.74-69.79l-20.36-224C296.4 185.2 268.7 160 235.6 160zM239.1 333.3c0 7.363-5.971 13.33-13.33 13.33h-40v40c0 7.363-5.969 13.33-13.33 13.33h-26.67c-7.363 0-13.33-5.971-13.33-13.33v-40H93.33c-7.363 0-13.33-5.971-13.33-13.33V306.7c0-7.365 5.971-13.33 13.33-13.33h40v-40C133.3 245.1 139.3 240 146.7 240h26.67c7.363 0 13.33 5.969 13.33 13.33v40h40c7.363 0 13.33 5.969 13.33 13.33V333.3z"],"pump-soap":[384,512,[],"e06b","M235.6 160H84.37C51.27 160 23.63 185.2 20.63 218.2l-20.36 224C-3.139 479.7 26.37 512 64.01 512h191.1c37.


.removeAllEventListeners();

  $a('outside-explosions').undo();

  for (var i in engine.actors) {
    if (engine.actors[i].rect.attachedToDocumentBody) {
      engine.actors[i].rect.removeDomElement();
    }
  }

  engine.stopTicking = true;
};

/**
 * Detect various browser features such as <canvas> or touch support.
 */
engine.detectFeatures = function() {
  this.features = {};

  // Whether the browser supports touch. We do not query for it, but change
  // it later if we encounter touch events.

  this.features.touch = false;

  // Whether the browser supports hiding the mouse pointer.
  // Unfortunately, Opera fails at this and I don’t know of a way to
  // feature-detect it.
  this.features.hidingMousePointer = false;
  if (navigator.userAgent.indexOf('Opera/') == -1) {
    var el = document.createElement('div');
    el.style.cursor = 'none';
    if (el.style.cursor == 'none') {
      this.features.hidingMousePointer = true;
    }
  }

  // Whether the browser supports <canvas>.

  el = document.createElement('canvas');
  this.features.canvas = !!(el.getContext && el.getContext('2d'));

  if (this.features.canvas) {
    // Even though <canvas> is available in earlier Operas, we enable it
    // only for versions >= 10.5 since before it has terrible performance
    // and bugs.
    if (navigator.userAgent.indexOf('Opera/') != -1) {
      this.features.canvas = false;

      var match = navigator.userAgent.match(/Version\/([0-9]+).([0-9]+)/);

      if (match && match[1] && match[2]) {
        var versionMaj = parseInt(match[1], 10);
        var versionMin = parseInt(match[2], 10);

        if (versionMaj && versionMin) {
          if ((versionMaj >= 11) ||
              ((versionMaj == 10) && (versionMin >= 50))) {
            this.features.canvas = true;
          }
        }
      }
    }

    // We disable <canvas> on Firefox for Linux because it typically is
    // slower than DOM.
    if ((navigator.userAgent.indexOf('Firefox/') != -1) &&
        (navigator.userAgent.indexOf('Linux') != -1)) {
      this.features.canvas = false;
    }
  }

  // Whether the browser supports opacity natively.

  if (navigator.userAgent.indexOf('MSIE 5.') != -1 ||
      navigator.userAgent.indexOf('MSIE 6.') != -1 ||
      navigator.userAgent.indexOf('MSIE 7.') != -1 ||
      navigator.userAgent.indexOf('MSIE 8.') != -1) {
    this.features.filterOpacity = true;
  } else {
    this.features.filterOpacity = false;
  }

  // Whether the browser is IE <= 8.

  this.features.ie8OrLower = navigator.userAgent.indexOf('MSIE 5.') != -1 ||
                             navigator.userAgent.indexOf('MSIE 6.') != -1 ||
                             navigator.userAgent.indexOf('MSIE 7.') != -1 ||
                             navigator.userAgent.indexOf('MSIE 8.') != -1;

  // Whether we’re running on a Mac.

  if (navigator.userAgent.indexOf('Macintosh') != -1) {
    this.features.imAMac = true;
  } else {
    this.features.imAMac = false;
  }

  // HTML5 Web Storage.

  try {
    this.features.webStorage = !!window.localStorage.getItem;
  } catch (e) {
    this.features.webStorage = false;
  }

  // Fixing old IE background cachi


}
  return undefined;
};

export const memberExpressionMatch = (
  node: Node,
  object: string,
  member?: string
) => {
  if (node.type !== "MemberExpression") {
    return false;
  }
  return (
    node.object.type === "Identifier" &&
    node.object.name === object &&
    node.property.type === "Identifier" &&
    node.property.name === member
  );
};

export const makeMemberExpression = (object: string, member: string) => {
  return babel.types.memberExpression(
    babel.types.identifier(object),
    babel.types.identifier(member)
  );
};

export const isCallIgnoreArguments = (
  call: Node,
  object: string,
  member: string
): call is CallExpression => {
  if (call.type !== "CallExpression") {
    return false;
  }
  return memberExpressionMatch(call.callee, object, member);
};

export const isCallWithoutArguments = (
  call: Node,
  object: string,
  member: string
) => {
  return (
    isCallIgnoreArguments(call, object, member) && call.arguments.length === 0
  );
};

export class CodeVersion {
  // keyed by nameInId, which could be uuid, or name
  allTagOrComponents = new Map<string, PlasmicTagOrComponent>();
  // keyed by nameInId, which could be uuid, or name
  secondaryTagsOrComponents = new Map<string, PlasmicTagOrComponent>();
  // keyed by uuid
  tagOrComponentsByUuid = new Map<string, PlasmicTagOrComponent>();
  uuidToNameInId = new Map<string, string>();
  // The node of the jsx tree.
  root: PlasmicASTNode;

  private slotArgNameToUuid = new Map<string, string>();
  private uuidToSlotArgName = new Map<string, string>();

  constructor(
    rootExpr: string | Expression,
    // A map from nameInId to uuid
    readonly nameInIdToUuid: Map<string, string>
  ) {
    if (L.isString(rootExpr)) {
      this.root = parseFromJsxExpression(rootExpr);
    } else {
      this.root = parseNode(rootExpr, undefined, true);
    }
    findNodes(
      this.root,
      this.allTagOrComponents,
      this.secondaryTagsOrComponents
    );
    this.allTagOrComponents.forEach((n, nameInId) =>
      this.tagOrComponentsByUuid.set(
        ensure(this.nameInIdToUuid.get(nameInId)),
        n
      )
    );
    this.nameInIdToUuid.forEach((uuid, nameInId) => {
      this.uuidToNameInId.set(uuid, nameInId);
      if (nameInId.startsWith("$slot")) {
        const argName = L.lowerFirst(nameInId.substr(5));
        this.slotArgNameToUuid.set(argName, uuid);
        this.uuidToSlotArgName.set(uuid, argName);
      }
    });
  }

  renameJsxTree(targetCodeVersion: CodeVersion) {
    const revisedNameInIdToUuid = new Map<string, string>(
      targetCodeVersion.nameInIdToUuid
    );
    const renamedJsx = cloneDeepWithHook(this.root.rawNode, (n: Node) => {
      const helperMember = tryExtractPropertyNameOfMemberExpression(
        n,
        helperObject
      );
      if (helperMember) {
        const eventHandlers = [
          "onMouseUp",
          "onMouseDown",
          "onFocus",
          "onBlur",
          "onMouseEnter",
          "onMouseLeave",
        ];
        const regEx = new RegExp(
          `^(cls|props|show|childStr|${eventHandlers.join("|")})(.+)$`
        );
        const m = helperMember.match(regEx);
        if (m) {
          const prefix = m[1];
          const nameInId = m[2];


s% schneller. hält %s Sek. lang an"] = { { Stats.MeleeHaste, }, false, false, } -- s123936
L["stellt im verlauf von %s Sek. %s gesundheit wieder her. ihr müsst beim essen sitzen bleiben. wenn ihr mindestens %s sekunden mit essen verbringt, werdet ihr satt und erhaltet %s Sek. lang %s ausweichen"] = { false, false, false, false, { Stats.DodgeRating, }, ignoreSum = true } -- s124249
L["erhöht das tempo um %s. hält %s Sek. lang an"] = { { Stats.MeleeHasteRating, Stats.RangedHasteRating, Stats.SpellHasteRating, }, false, } -- s124151
L["erhöht die waffenkunde um %s. hält %s Sek. lang an"] = { { Stats.ExpertiseRating, }, false, } -- s124210
L["erhöht den kritischen trefferwert um %s. hält %s Sek. lang an"] = { { Stats.MeleeCritRating, Stats.RangedCritRating, Stats.SpellCritRating, }, false, } -- s124212
L["erhöht die meisterschaft um %s. hält %s Sek. lang an"] = { { Stats.MasteryRating, }, false, } -- s124213
L["erhöht den trefferwert um %s. hält %s Sek. lang an"] = { { Stats.MeleeHitRating, Stats.RangedHitRating, Stats.SpellHitRating, }, false, } -- s124215
L["stellt im verlauf von %s Sek. %s gesundheit wieder her. ihr müsst beim essen sitzen bleiben. wenn ihr mindestens %s sekunden mit essen verbringt, werdet ihr satt und erhaltet %s Sek. lang %s waffenkunde"] = { false, false, false, false, { Stats.ExpertiseRating, }, ignoreSum = true } -- s124239
L["stellt im verlauf von %s Sek. %s gesundheit wieder her. ihr müsst beim essen sitzen bleiben. wenn ihr mindestens %s sekunden mit essen verbringt, werdet ihr satt und erhaltet %s Sek. lang %s tempo"] = { false, false, false, false, { Stats.MeleeHasteRating, Stats.RangedHasteRating, Stats.SpellHasteRating, }, ignoreSum = true } -- s124240
L["stellt im verlauf von %s Sek. %s gesundheit wieder her. ihr müsst beim essen sitzen bleiben. wenn ihr mindestens %s sekunden mit essen verbringt, werdet ihr satt und erhaltet %s Sek. lang %s kritischen trefferwert"] = { false, false, false, false, { Stats.MeleeCritRating, Stats.RangedCritRating, Stats.SpellCritRating, }, ignoreSum = true } -- s124241
L["stellt im verlauf von %s Sek. %s gesundheit und %s mana wieder her. ihr müsst beim essen sitzen bleiben. wenn ihr mindestens %s sekunden mit essen verbringt, werdet ihr satt und erhaltet %s Sek. lang %s meisterschaft"] = { false, false, false, false, false, { Stats.MasteryRating, }, ignoreSum = true } -- s124242
L["stellt im verlauf von %s Sek. %s gesundheit wieder her. ihr müsst beim essen sitzen bleiben. wenn ihr mindestens %s sekunden mit essen verbringt, werdet ihr satt und erhaltet %s Sek. lang %s trefferwert"] = { false, false, false, false, { Stats.MeleeHitRating, Stats.RangedHitRating, Stats.SpellHitRating, }, ignoreSum = true } -


loadClass(packagz + ".TbMapper")));

                ObjectUtil columnField1 = new ObjectUtil(loader, packagz + ".TbKeys$Column#field1");
                // java 动态参数不能有两个会冲突，最后一个封装成Array!!!必须使用反射创建指定类型数组，不然调用invoke对了可变参数会检查类型！
                Object columns1 = Array.newInstance(columnField1.getCls(), 1);
                Array.set(columns1, 0, columnField1.getObject());

                String sql = SqlHelper.getFormatMapperSql(tbMapper.getObject(), "selectByPrimaryKeySelective", 1, columns1);
                Assert.assertEquals(sql, "select field1 from tb where id = 1");

                // 2. 测试xxxKey
                ObjectUtil tbKeysMapper = new ObjectUtil(sqlSession.getMapper(loader.loadClass(packagz + ".TbKeysMapper")));
                ObjectUtil tbKeysKey = new ObjectUtil(loader, packagz + ".TbKeysKey");
                tbKeysKey.set("key1", 1l);
                tbKeysKey.set("key2", "2");

                ObjectUtil columnField2 = new ObjectUtil(loader, packagz + ".TbKeys$Column#field2");
                // java 动态参数不能有两个会冲突，最后一个封装成Array!!!必须使用反射创建指定类型数组，不然调用invoke对了可变参数会检查类型！
                Object columns2 = Array.newInstance(columnField2.getCls(), 1);
                Array.set(columns2, 0, columnField2.getObject());

                sql = SqlHelper.getFormatMapperSql(tbKeysMapper.getObject(), "selectByPrimaryKeySelective", tbKeysKey.getObject(), columns2);
                Assert.assertEquals(sql, "select field2 from tb_keys where key1 = 1 and key2 = '2'");

                // 3. 执行sql
                Object tbKeys = tbKeysMapper.invoke("selectByPrimaryKeySelective", tbKeysKey.getObject(), columns1);
                Assert.assertEquals(new ObjectUtil(tbKeys).get("field1"), "fd1");
            }
        });
        // 测试Selective不传
        tool.generate(() -> DBHelper.resetDB("scripts/SelectSelectivePlugin/init.sql"), new AbstractShellCallback() {
            @Override
            public void reloadProject(SqlSession sqlSession, ClassLoader loader, String packagz) throws Exception {
                ObjectUtil tbMapper = new ObjectUtil(sqlSession.getMapper(loader.loadClass(packagz + ".TbMapper")));

                // sql
                String sql = SqlHelper.getFormatMapperSql(tbMapper.getObject(), "selectByPrimaryKeySelective", 4L);
                Assert.assertEquals(sql, "select id, field1, field2 from tb where id = 4");

                // 测试执行
                ObjectUtil result = new ObjectUtil(tbMapper.invoke("selectByPrimaryKeySelective", 4L, null));
                // 取数据出来比较
                Assert.assertEquals(result.get("id"), 4L);
                Assert.assertEquals(result.get("field1"), "fd3");
                Assert.assertEquals(result.get("field2"), 4);
            }
        });
        // 测试WithBLOBs的情况
        tool.generate(() -> DBHelper.resetDB("scripts/SelectSelectivePlugin/init.sql"), new AbstractShellCallback() {
            @Override
            public void reloadProject(SqlSession sqlSession, ClassLoader loader, String packagz) throws Exception {
                ObjectUtil tbBlobsMapper = new ObjectUtil(sqlSession.getMapper(loader.loadClass(packagz + ".TbBlobsMapper")));

                // selective
                // 从base model 和 WithBLOBs都各取一个，更有代表性
                ObjectUtil columnId = new ObjectUtil(loader, packagz + ".TbBlobsWithBLOBs$Column#id");
                ObjectUtil columnField2 = new ObjectUtil(loader, packagz + ".TbBlobsWithBLOBs$Column#field2");

                Object columns = Array.new


0:00-08:00').parseZone(),
            m;

        moment.updateOffset = function (mom, keepTime) {
            if (mom.isBefore(dstAt)) {
                mom.utcOffset(-8, keepTime);
            } else {
                mom.utcOffset(-7, keepTime);
            }
        };

        m = moment('2014-03-15T00:00:00-07:00').parseZone();
        m.year(2013);
        assert.equal(m.format(), '2013-03-15T00:00:00-08:00', 'year across +1');

        m = moment('2014-03-15T00:00:00-07:00').parseZone();
        m.month(0);
        assert.equal(m.format(), '2014-01-15T00:00:00-08:00', 'month across +1');

        m = moment('2014-03-15T00:00:00-07:00').parseZone();
        m.date(1);
        assert.equal(m.format(), '2014-03-01T00:00:00-08:00', 'date across +1');

        m = moment('2014-03-09T03:05:00-07:00').parseZone();
        m.hour(0);
        assert.equal(m.format(), '2014-03-09T00:05:00-08:00', 'hour across +1');

        moment.updateOffset = oldUpdateOffset;
    });

    test('setters across DST -1', function (assert) {
        var oldUpdateOffset = moment.updateOffset,
            // Based on a real story somewhere in America/Los_Angeles
            dstAt = moment('2014-11-02T02:00:00-07:00').parseZone(),
            m;

        moment.updateOffset = function (mom, keepTime) {
            if (mom.isBefore(dstAt)) {
                mom.utcOffset(-7, keepTime);
            } else {
                mom.utcOffset(-8, keepTime);
            }
        };

        m = moment('2014-11-15T00:00:00-08:00').parseZone();
        m.year(2013);
        assert.equal(m.format(), '2013-11-15T00:00:00-07:00', 'year across -1');

        m = moment('2014-11-15T00:00:00-08:00').parseZone();
        m.month(0);
        assert.equal(m.format(), '2014-01-15T00:00:00-07:00', 'month across -1');

        m = moment('2014-11-15T00:00:00-08:00').parseZone();
        m.date(1);
        assert.equal(m.format(), '2014-11-01T00:00:00-07:00', 'date across -1');

        m = moment('2014-11-02T03:30:00-08:00').parseZone();
        m.hour(0);
        assert.equal(m.format(), '2014-11-02T00:30:00-07:00', 'hour across -1');

        moment.updateOffset = oldUpdateOffset;
    });

}));

;(function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined'
       && typeof require === 'function' ? factory(require('../../moment')) :
   typeof define === 'function' && define.amd ? define(['../../moment'], factory) :
   factory(global.moment)
}(this, function (moment) { 'use strict';

    function each(array, callback) {
        var i;
        for (i = 0; i < array.length; i++) {
            callback(array[i], i, array);
        }
    }

    function objectKeys(obj) {
        if (Object.keys) {
            return Object.keys(obj);
        } else {
            // IE8
            var res = [], i;
            for (i in obj) {
                if (obj.hasOwnProperty(i)) {
                    res.push(i);
                }
            }
            return res;
        }
    }

    // Pick the first defined of two or three arguments.
    function defaults(a, b,


#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Licensed under the GNU General Public License, version 3.
# See the file http://www.gnu.org/copyleft/gpl.txt.

from pisi.actionsapi import autotools
from pisi.actionsapi import pisitools
from pisi.actionsapi import shelltools
from pisi.actionsapi import get

#WorkDir = "libvpx"
# libdir = "lib64" if get.ARCH() == "x86_64" else "lib"
libdir = "lib"

def setup():
    shelltools.export("LC_ALL", "en_US.UTF-8")
    shelltools.export("CFLAGS", get.CFLAGS().replace("-ggdb3", ""))

    autotools.rawConfigure("--prefix=/usr \
                            --libdir=/usr/%s \
                            --enable-pic \
                            --enable-vp8 \
                            --enable-shared \
                            --enable-runtime-cpu-detect \
                            --enable-postproc \
                            --enable-multithread \
                            --disable-install-docs \
                            --disable-debug \
                            --disable-debug-libs" % libdir)

def build():
    autotools.make("verbose=true")

def install():
    autotools.rawInstall("DESTDIR=%s" % get.installDIR())
    pisitools.remove("/usr/%s/*.a" % libdir)

    pisitools.dodoc("AUTHORS", "CHANGELOG", "LICENSE", "PATENTS")


 override fun protoUnmarshal(u: pbandk.Unmarshaller) = FieldDescriptorProto.protoUnmarshalImpl(u)
    }

    data class Type(override val value: Int) : pbandk.Message.Enum {
        companion object : pbandk.Message.Enum.Companion<Type> {
            val TYPE_DOUBLE = Type(1)
            val TYPE_FLOAT = Type(2)
            val TYPE_INT64 = Type(3)
            val TYPE_UINT64 = Type(4)
            val TYPE_INT32 = Type(5)
            val TYPE_FIXED64 = Type(6)
            val TYPE_FIXED32 = Type(7)
            val TYPE_BOOL = Type(8)
            val TYPE_STRING = Type(9)
            val TYPE_GROUP = Type(10)
            val TYPE_MESSAGE = Type(11)
            val TYPE_BYTES = Type(12)
            val TYPE_UINT32 = Type(13)
            val TYPE_ENUM = Type(14)
            val TYPE_SFIXED32 = Type(15)
            val TYPE_SFIXED64 = Type(16)
            val TYPE_SINT32 = Type(17)
            val TYPE_SINT64 = Type(18)

            override fun fromValue(value: Int) = when (value) {
                1 -> TYPE_DOUBLE
                2 -> TYPE_FLOAT
                3 -> TYPE_INT64
                4 -> TYPE_UINT64
                5 -> TYPE_INT32
                6 -> TYPE_FIXED64
                7 -> TYPE_FIXED32
                8 -> TYPE_BOOL
                9 -> TYPE_STRING
                10 -> TYPE_GROUP
                11 -> TYPE_MESSAGE
                12 -> TYPE_BYTES
                13 -> TYPE_UINT32
                14 -> TYPE_ENUM
                15 -> TYPE_SFIXED32
                16 -> TYPE_SFIXED64
                17 -> TYPE_SINT32
                18 -> TYPE_SINT64
                else -> Type(value)
            }
        }
    }

    data class Label(override val value: Int) : pbandk.Message.Enum {
        companion object : pbandk.Message.Enum.Companion<Label> {
            val LABEL_OPTIONAL = Label(1)
            val LABEL_REQUIRED = Label(2)
            val LABEL_REPEATED = Label(3)

            override fun fromValue(value: Int) = when (value) {
                1 -> LABEL_OPTIONAL
                2 -> LABEL_REQUIRED
                3 -> LABEL_REPEATED
                else -> Label(value)
            }
        }
    }
}

data class OneofDescriptorProto(
    val name: String? = null,
    val options: pbandk.wkt.OneofOptions? = null,
    val unknownFields: Map<Int, pbandk.UnknownField> = emptyMap()
) : pbandk.Message<OneofDescriptorProto> {
    override operator fun plus(other: OneofDescriptorProto?) = protoMergeImpl(other)
    override val protoSize by lazy { protoSizeImpl() }
    override fun protoMarshal(m: pbandk.Marshaller) = protoMarshalImpl(m)
    companion object : pbandk.Message.Companion<OneofDescriptorProto> {
        override fun protoUnmarshal(u: pbandk.Unmarshaller) = OneofDescriptorProto.protoUnmarshalImpl(u)
    }
}

data class EnumDescriptorProto(
    val name: String? = null,
    val value: List<pbandk.wkt.EnumValueDescriptorProto> = emptyList(),
    val options: pbandk.wkt.EnumOptions? = null,
    val reservedRange: List<pbandk.wkt.EnumDescriptorProto.EnumReservedRange> = emptyList(),
    val reservedName: List<String> = emptyList(),
    val unknownFields: Map<Int, pbandk.UnknownField> = emptyMap()
) : pbandk.Message<EnumDescriptorProto> {
    override operator fun plus(other: EnumDescriptorProto?) = protoMergeImpl(other)
    override val protoSize by lazy { protoSizeImpl() }
    override fun protoMarshal(m: pbandk.Marshaller)


x, al, ah, ebx, bl, bh, ecx, edx)
    ASMDECROUND( 1, ecx, cl, ch, edx, dl, dh, eax, ebx)
    ASMDECROUND( 0, eax, al, ah, ebx, bl, bh, ecx, edx)

    AS2(    movd  ebp, mm6                      )
    AS2(    movd  esi, mm0                      ) // k_
    #ifdef __GNUC__
        AS2(    movd  edi, mm3                  ) // outBlock
    #else
        AS2(    mov   edi, [ebp + 12]           ) // outBlock
    #endif

    AS2(    xor   eax, DWORD PTR [esi     ]     ) // k_[0]
    AS2(    xor   ebx, DWORD PTR [esi +  4]     ) // k_[1]
    AS2(    xor   ecx, DWORD PTR [esi +  8]     ) // k_[2]
    AS2(    xor   edx, DWORD PTR [esi + 12]     ) // k_[3]

    AS2(    mov   [edi],      eax               ) // write out
    AS2(    mov   [edi +  4], ebx               ) // write out
    AS2(    mov   [edi +  8], ecx               ) // write out
    AS2(    mov   [edi + 12], edx               ) // write out

    EPILOG()
}

#endif // defined(DO_TWOFISH_ASM)

} // namespace

/*
   Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; see the file COPYING. If not, write to the
   Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
   MA  02110-1301  USA.
*/

/* C++ part based on Wei Dai's des.cpp from CryptoPP */
/* x86 asm is original */

#if defined(TAOCRYPT_KERNEL_MODE)
    #define DO_TAOCRYPT_KERNEL_MODE
#endif                                  // only some modules now support this

#include "runtime.hpp"
#include "des.hpp"
#ifdef USE_SYS_STL
    #include <algorithm>
#else
    #include "algorithm.hpp"
#endif

namespace STL = STL_NAMESPACE;

namespace TaoCrypt {

/* permuted choice table (key) */
static const byte pc1[] = {
       57, 49, 41, 33, 25, 17,  9,
        1, 58, 50, 42, 34, 26, 18,
       10,  2, 59, 51, 43, 35, 27,
       19, 11,  3, 60, 52, 44, 36,

       63, 55, 47, 39, 31, 23, 15,
        7, 62, 54, 46, 38, 30, 22,
       14,  6, 61, 53, 45, 37, 29,
       21, 13,  5, 28, 20, 12,  4
};

/* number left rotations of pc1 */
static const byte totrot[] = {
       1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,


 00 */	li r3, 0
/* 803503A8 0034D2E8  48 00 01 24 */	b .L_803504CC
.L_803503AC:
/* 803503AC 0034D2EC  7F E3 FB 78 */	mr r3, r31
/* 803503B0 0034D2F0  4B DB 70 45 */	bl getStateID__Q24Game9EnemyBaseFv
/* 803503B4 0034D2F4  2C 03 00 04 */	cmpwi r3, 4
/* 803503B8 0034D2F8  40 80 00 14 */	bge .L_803503CC
/* 803503BC 0034D2FC  2C 03 00 01 */	cmpwi r3, 1
/* 803503C0 0034D300  41 82 00 20 */	beq .L_803503E0
/* 803503C4 0034D304  40 80 00 8C */	bge .L_80350450
/* 803503C8 0034D308  48 00 00 F8 */	b .L_803504C0
.L_803503CC:
/* 803503CC 0034D30C  2C 03 00 09 */	cmpwi r3, 9
/* 803503D0 0034D310  40 80 00 F0 */	bge .L_803504C0
/* 803503D4 0034D314  2C 03 00 07 */	cmpwi r3, 7
/* 803503D8 0034D318  40 80 00 08 */	bge .L_803503E0
/* 803503DC 0034D31C  48 00 00 E4 */	b .L_803504C0
.L_803503E0:
/* 803503E0 0034D320  C0 02 01 30 */	lfs f0, lbl_8051E490@sda21(r2)
/* 803503E4 0034D324  38 00 00 00 */	li r0, 0
/* 803503E8 0034D328  D0 1F 01 C8 */	stfs f0, 0x1c8(r31)
/* 803503EC 0034D32C  D0 1F 01 CC */	stfs f0, 0x1cc(r31)
/* 803503F0 0034D330  D0 1F 01 D0 */	stfs f0, 0x1d0(r31)
/* 803503F4 0034D334  D0 1F 01 D4 */	stfs f0, 0x1d4(r31)
/* 803503F8 0034D338  D0 1F 01 D8 */	stfs f0, 0x1d8(r31)
/* 803503FC 0034D33C  D0 1F 01 DC */	stfs f0, 0x1dc(r31)
/* 80350400 0034D340  98 1F 02 F1 */	stb r0, 0x2f1(r31)
/* 80350404 0034D344  80 7F 00 C0 */	lwz r3, 0xc0(r31)
/* 80350408 0034D348  88 03 09 99 */	lbz r0, 0x999(r3)
/* 8035040C 0034D34C  28 00 00 00 */	cmplwi r0, 0
/* 80350410 0034D350  41 82 00 18 */	beq .L_80350428
/* 80350414 0034D354  7F E3 FB 78 */	mr r3, r31
/* 80350418 0034D358  4B DB 4E 89 */	bl finishMotion__Q24Game9EnemyBaseFv
/* 8035041C 0034D35C  38 00 00 06 */	li r0, 6
/* 80350420 0034D360  90 1F 03 44 */	stw r0, 0x344(r31)
/* 80350424 0034D364  48 00 00 24 */	b .L_80350448
.L_80350428:
/* 80350428 0034D368  80 7F 03 80 */	lwz r3


ader-icon-size) / 18)); */

  /* margin: var(--header-margin);

  height='18' width='18'  */
}

.modal.mod-community-theme .community-modal-info .community-modal-info-repo > a:hover::before {
  color: var(--icon-color-hover);
  background-color: var(--background-modifier-hover);
  border-radius: var(--clickable-icon-radius);
  transition: opacity 0.15s ease-in-out;
  opacity: var(--icon-opacity-hover);
}

.modal.mod-community-theme .community-modal-info .community-modal-info-repo > a::after {
  position: relative;
  top: 0;
  right: 0;
  z-index: 1;
  display: block;
  width: var(--header-icon-size);
  height: var(--header-icon-size);
  margin: var(--header-padding);
  background-color: var(--icon-color);
  border-radius: var(--clickable-icon-radius);
  content: " ";
  mask-image: url("data:image/svg+xml,%3C%3Fxml version='1.0' encoding='UTF-8'%3F%3E%3Csvg stroke-width='2' viewBox='0 0 24 24' fill='none' xmlns='http://www.w3.org/2000/svg' color='%23000000'%3E%3Cpath d='M16 22.027v-2.87a3.37 3.37 0 00-.94-2.61c3.14-.35 6.44-1.54 6.44-7a5.44 5.44 0 00-1.5-3.75 5.07 5.07 0 00-.09-3.77s-1.18-.35-3.91 1.48a13.38 13.38 0 00-7 0c-2.73-1.83-3.91-1.48-3.91-1.48A5.07 5.07 0 005 5.797a5.44 5.44 0 00-1.5 3.78c0 5.42 3.3 6.61 6.44 7a3.37 3.37 0 00-.94 2.58v2.87M9 20.027c-3 .973-5.5 0-7-3' stroke='%23000000' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'%3E%3C/path%3E%3C/svg%3E");
  mask-repeat: no-repeat;
  mask-position: center;
}

.modal.mod-community-theme .community-modal-info .community-modal-button-container {
  grid-column: 1/-1; /* full width */
  grid-row: 3/4;
  display: grid;
  grid-template-columns: repeat(var(--grid-columns-container-comm-modal), 1fr); /* for the buttons */ /* are there more than 3? */
  gap: var(--spacing-comm-modal);
  margin-top: 0;
  padding-top: var(--spacing-comm-modal); /* switch margin to padding for the border */
  border-top: 1px solid var(--background-modifier-border);
  margin-bottom: 0; /* 1.5em is HUGE */
}

.modal.mod-community-theme .community-modal-info .community-modal-button-container > button {
  margin-right: 0; /* use grid, save margins! */
}

.modal.mod-community-theme .community-modal-info hr {
  display: none;
  grid-column: 1/-1; /* full width */
  grid-row: 4/5;
}

.modal.mod-community-theme .community-modal-info .community-modal-readme {
  grid-column: 1/-1; /* full width */
  grid-row: 5


music=ティアオイエツォン(withered leaf)&fromwiki=IOSYS_TOHO_MEGAMIX_-_GENSOKYO_SUGOIKYOKU_EDITION_-_Mixed_by_DJ_sada">
ティアオイエツォン(withered leaf)

东方妖妖梦　～ Perfect Cherry Blossom.

06	あたしまりさ (Visko & D.watt Remix)	01:45

	编曲	void

	再编曲	Visko，D.watt

	演唱	イザベル<a rel="nofollow" class="external text"


of the Toolkit that corresponds to the API version.

      MVNC_MYRIAD_ERROR
      An error has been reported by Intel® Movidius™ VPU. Use MVNC_DEBUGINFO to get more information.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
        "http://www.w3.org/TR/html4/loose.dtd">

    <title>帮助</title>
    <meta content="text/html; charset=utf-8" http-equiv="Content-Type"/>

    <link rel="stylesheet" type="text/css" href="help.css">

        <var id="lang_input_about"></var>
        <var id="lang_input_shortcuts"></var>

UEditor

<var id="lang_input_introduction"></var>

                    <var id="lang_Txt_shortcuts"></var>
                    <var id="lang_Txt_func"></var>

                    ctrl+b
                    <var id="lang_Txt_bold"></var>

                    ctrl+c
                    <var id="lang_Txt_copy"></var>

                    ctrl+x
                    <var id="lang_Txt_cut"></var>

                    ctrl+v
                    <var id="lang_Txt_Paste"></var>

                    ctrl+y
                    <var id="lang_Txt_undo"></var>

                    ctrl+z
                    <var id="lang_Txt_redo"></var>

                    ctrl+i
                    <var id="lang_Txt_italic"></var>

                    ctrl+u
                    <var id="lang_Txt_underline"></var>

                    ctrl+a
                    <var id="lang_Txt_selectAll"></var>

                    shift+enter
                    <var id="lang_Txt_visualEnter"></var>

                    alt+z


return nil, err
	}

	priv, err := unmarshalECDSA(k.Curve, k.KeyBytes, k.D)
	if err != nil {
		return nil, err
	}

	addedKey := &AddedKey{PrivateKey: priv, Comment: k.Comments}
	if err := setConstraints(addedKey, k.Constraints); err != nil {
		return nil, err
	}
	return addedKey, nil
}

func parseRSACert(req []byte) (*AddedKey, error) {
	var k rsaCertMsg
	if err := ssh.Unmarshal(req, &k); err != nil {
		return nil, err
	}

	pubKey, err := ssh.ParsePublicKey(k.CertBytes)
	if err != nil {
		return nil, err
	}

	cert, ok := pubKey.(*ssh.Certificate)
	if !ok {
		return nil, errors.New("agent: bad RSA certificate")
	}

	// An RSA publickey as marshaled by rsaPublicKey.Marshal() in keys.go
	var rsaPub struct {
		Name string
		E    *big.Int
		N    *big.Int
	}
	if err := ssh.Unmarshal(cert.Key.Marshal(), &rsaPub); err != nil {
		return nil, fmt.Errorf("agent: Unmarshal failed to parse public key: %v", err)
	}

	if rsaPub.E.BitLen() > 30 {
		return nil, errors.New("agent: RSA public exponent too large")
	}

	priv := rsa.PrivateKey{
		PublicKey: rsa.PublicKey{
			E: int(rsaPub.E.Int64()),
			N: rsaPub.N,
		},
		D:      k.D,
		Primes: []*big.Int{k.Q, k.P},
	}
	priv.Precompute()

	addedKey := &AddedKey{PrivateKey: &priv, Certificate: cert, Comment: k.Comments}
	if err := setConstraints(addedKey, k.Constraints); err != nil {
		return nil, err
	}
	return addedKey, nil
}

func parseDSACert(req []byte) (*AddedKey, error) {
	var k dsaCertMsg
	if err := ssh.Unmarshal(req, &k); err != nil {
		return nil, err
	}
	pubKey, err := ssh.ParsePublicKey(k.CertBytes)
	if err != nil {
		return nil, err
	}
	cert, ok := pubKey.(*ssh.Certificate)
	if !ok {
		return nil, errors.New("agent: bad DSA certificate")
	}

	// A DSA publickey as marshaled by dsaPublicKey.Marshal() in keys.go
	var w struct {
		Name       string
		P, Q, G, Y *big.Int
	}
	if err := ssh.Unmarshal(cert.Key.Marshal(), &w); err != nil {
		return nil, fmt.Errorf("agent: Unmarshal failed to parse public key: %v", err)
	}

	priv := &dsa.PrivateKey{
		PublicKey: dsa.PublicKey{
			Parameters: dsa.Parameters{
				P: w.P,
				Q: w.Q,
				G: w.G,
			},
			Y: w.Y,
		},
		X: k.X,
	}

	addedKey := &AddedKey{PrivateKey: priv, Certificate: cert, Comment: k.Comments}
	if err := setConstraints(addedKey, k.Constraints); err != nil {
		return nil, err
	}
	return addedKey, nil
}

func parseECDSACert(req []byte) (*AddedKey, error) {
	var k ecdsaCertMsg
	if err := ssh.Unmarshal(req, &k); err != nil {
		return nil, err
	}

	pubKey, err := ssh.ParsePublicKey(k.CertBytes)
	if err != nil {
		return nil, err
	}
	cert, ok := pubKey.(*ssh.Certificate)
	if !ok {
		return nil, errors.New("agent: bad ECDS


">

A office or house fire can be a scary and costly situation. House fires can damage not only the immediate property, but surrounding areas as ...
 >read more

<form action="/#gf_3" enctype="multipart/form-data" id="gform_3" method="post" target="gform_ajax_frame_3">

Full Name*
<input class="medium" id="input_3_1" name="input_1" tabindex="1" value="" type="text">

Phone Number*
<input class="medium" id="input_3_2" name="input_2" tabindex="2" value="" type="text">

Email*
<input class="medium" id="input_3_3" name="input_3" tabindex="3" value="" type="text">

Address
<input class="medium" id="input_3_4" name="input_4" tabindex="4" value="" type="text">

City, State, Zip
<input class="medium" id="input_3_5" name="input_5" tabindex="5" value="" type="text">

Type Of Work*
<select class="medium gfield_select" id="input_3_8" name="input_8" tabindex="6"><option value="Fire Damage">Fire Damage</option><option value="Water Damage">Water Damage</option><option value="Storm Damage">Storm Damage</option><option value="Mold Damage">Mold Damage</option><option value="Biohazard Clean Up">Biohazard Clean Up</option><option value="Board Up">Board Up</option><option value="Complete Restoration">Complete Restoration</option><option value="Other">Other</option></select>

<label class="gf


ixin_superInvokedNames_invokedToNot_method() async {
    await _runLibraryManifestScenario(
      initialCode: r'''
class A {
  void foo() {}
}

mixin M on A {
  void f() {
    super.foo();
  }
}
''',
      expectedInitialEvents: r'''
[operation] linkLibraryCycle SDK
[operation] linkLibraryCycle
  package:test/test.dart
    hashForRequirements: #H0
    declaredClasses
      A: #M0
        declaredMethods
          foo: #M1
        interface: #M2
          map
            foo: #M1
          implemented
            foo: #M1
    declaredMixins
      M: #M3
        declaredMethods
          f: #M4
        interface: #M5
          map
            f: #M4
            foo: #M1
          implemented
            f: #M4
          superImplemented
            [0]
              foo: #M1
          inherited
            foo: #M1
    exportMapId: #M6
    exportMap
      A: #M0
      M: #M3
''',
      updatedCode: r'''
class A {
  void foo() {}
}

mixin M on A {
  void f() {}
}
''',
      expectedUpdatedEvents: r'''
[operation] linkLibraryCycle
  package:test/test.dart
    hashForRequirements: #H1
    declaredClasses
      A: #M0
        declaredMethods
          foo: #M1
        interface: #M2
          map
            foo: #M1
          implemented
            foo: #M1
    declaredMixins
      M: #M7
        declaredMethods
          f: #M8
        interface: #M9
          map
            f: #M8
            foo: #M1
          implemented
            f: #M8
          superImplemented
            [0]
              foo: #M1
          inherited
            foo: #M1
    exportMapId: #M10
    exportMap
      A: #M0
      M: #M7
''',
    );
  }

  test_manifest_mixin_superInvokedNames_invokedToNot_setter() async {
    await _runLibraryManifestScenario(
      initialCode: r'''
class A {
  set foo(int _) {}
}

mixin M on A {
  void f() {
    super.foo = 0;
  }
}
''',
      expectedInitialEvents: r'''
[operation] linkLibraryCycle SDK
[operation] linkLibraryCycle
  package:test/test.dart
    hashForRequirements: #H0
    declaredClasses
      A: #M0
        declaredFields
          foo: #M1
        declaredSetters
          foo=: #M2
        interface: #M3
          map
            foo=: #M2
          implemented
            foo=: #M2
    declaredMixins
      M: #M4
        declaredMethods
          f: #M5
        interface: #M6
          map
            f: #M5
            foo=: #M2
          implemented
            f: #M5
          superImplemented
            [0]
              foo=: #M2
          inherited
            foo=: #M2
    exportMapId: #M7
    exportMap
      A: #M0
      M: #M4
''',
      updatedCode: r'''
class A {
  set foo(int _) {}
}

mixin M on A {
  void f() {}
}
''',
      expectedUpdatedEvents: r'''
[operation] linkLibraryCycle
  package:test/test.dart
    hashForRequirements: #H1
    declaredClasses
      A: #M0
        declaredFields
          foo: #M1
        declaredSetters
          foo=: #M2
        interface: #M3
          map


anged",
                        "below": 20,
                        "invalid": "invalid",
                    },
                    "action": {
                        "service": "test.automation",
                        "data_template": {"some": "target_humidity_changed"},
                    },
                },
            ]
        },
    )

    # Fake that the humidity is changing
    hass.states.async_set(entry.entity_id, STATE_ON, {const.ATTR_HUMIDITY: 7})
    await hass.async_block_till_done()
    # Should not trigger for invalid config
    assert len(calls) == 0

async def test_get_trigger_capabilities_on(hass: HomeAssistant) -> None:
    """Test we get the expected capabilities from a humidifier trigger."""
    capabilities = await device_trigger.async_get_trigger_capabilities(
        hass,
        {
            "platform": "device",
            "domain": "humidifier",
            "type": "turned_on",
            "entity_id": "01234568901234568901234568901",
            "above": "23",
        },
    )

    assert capabilities and "extra_fields" in capabilities

    assert voluptuous_serialize.convert(
        capabilities["extra_fields"], custom_serializer=cv.custom_serializer
    ) == [{"name": "for", "optional": True, "type": "positive_time_period_dict"}]

async def test_get_trigger_capabilities_off(hass: HomeAssistant) -> None:
    """Test we get the expected capabilities from a humidifier trigger."""
    capabilities = await device_trigger.async_get_trigger_capabilities(
        hass,
        {
            "platform": "device",
            "domain": "humidifier",
            "type": "turned_off",
            "entity_id": "01234568901234568901234568901",
            "above": "23",
        },
    )

    assert capabilities and "extra_fields" in capabilities

    assert voluptuous_serialize.convert(
        capabilities["extra_fields"], custom_serializer=cv.custom_serializer
    ) == [{"name": "for", "optional": True, "type": "positive_time_period_dict"}]

async def test_get_trigger_capabilities_humidity(hass: HomeAssistant) -> None:
    """Test we get the expected capabilities from a humidifier trigger."""
    capabilities = await device_trigger.async_get_trigger_capabilities(
        hass,
        {
            "platform": "device",
            "domain": "humidifier",
            "type": "target_humidity_changed",
            "entity_id": "01234568901234568901234568901",
            "above": "23",
        },
    )

    assert capabilities and "extra_fields" in capabilities

    assert voluptuous_serialize.convert(
        capabilities["extra_fields"], custom_serializer=cv.custom_serializer
    ) == [
        {
            "description": {"suffix": "%"},
            "name": "above",
            "optional": True,
            "type": "integer",
        },
        {
            "description": {"suffix": "%"},
            "name": "below",
            "optional": True,
            "type": "integer",
        },
        {"name": "for", "optional": True, "type": "positive_time_period_dict"},
    ]


ptree::value_type &v2, object.get_child("")) {
        ptree pt2 = v2.second;
        if (v2.first == "name") {
          string name = pt2.data();
          if (name_to_label.find(name) == name_to_label.end()) {
            LOG(FATAL) << "Unknown name: " << name;
          }
          int label = name_to_label.find(name)->second;
          bool found_group = false;
          for (int g = 0; g < anno_datum->annotation_group_size(); ++g) {
            AnnotationGroup* anno_group =
                anno_datum->mutable_annotation_group(g);
            if (label == anno_group->group_label()) {
              if (anno_group->annotation_size() == 0) {
                instance_id = 0;
              } else {
                instance_id = anno_group->annotation(
                    anno_group->annotation_size() - 1).instance_id() + 1;
              }
              anno = anno_group->add_annotation();
              found_group = true;
            }
          }
          if (!found_group) {
            // If there is no such annotation_group, create a new one.
            AnnotationGroup* anno_group = anno_datum->add_annotation_group();
            anno_group->set_group_label(label);
            anno = anno_group->add_annotation();
            instance_id = 0;
          }
          anno->set_instance_id(instance_id++);
        } else if (v2.first == "difficult") {
          difficult = pt2.data() == "1";
        } else if (v2.first == "content") {
          text_content = pt2.data();
        } else if (v2.first == "bndbox") {
          int xmin = pt2.get("xmin", 0);
          int ymin = pt2.get("ymin", 0);
          int xmax = pt2.get("xmax", 0);
          int ymax = pt2.get("ymax", 0);
          int x1 = pt2.get("x1", 0);
          int y1 = pt2.get("y1", 0);
          int x2 = pt2.get("x2", 0);
          int y2 = pt2.get("y2", 0);
          int x3 = pt2.get("x3", 0);
          int y3 = pt2.get("y3", 0);
          int x4 = pt2.get("x4", 0);
          int y4 = pt2.get("y4", 0);
          CHECK_NOTNULL(anno);
          LOG_IF(WARNING, xmin > width) << labelfile <<
              " bounding box exceeds image boundary.";
          LOG_IF(WARNING, ymin > height) << labelfile <<
              " bounding box exceeds image boundary.";
          LOG_IF(WARNING, xmax > width) << labelfile <<
              " bounding box exceeds image boundary.";
          LOG_IF(WARNING, ymax > height) << labelfile <<
              " bounding box exceeds image boundary.";
          LOG_IF(WARNING, xmin < 0) << labelfile <<
              " bounding box exceeds image boundary.";
          LOG_IF(WARNING, ymin < 0) << labelfile <<
              " bounding box exceeds image boundary.";
          LOG_IF(WARNING, xmax < 0) << labelfile <<
              " bounding box exceeds image boundary.";
          LOG_IF(WARNING, ymax < 0) << labelfile <<
              " bounding box exceeds image boundary.";
          LOG_IF(WARNING, xmin > xmax) << labelfile <<
              " bounding bo