-> Unit = {}
        ): StatusController {
            val delegate = StatusViewDelegate(container, contentView)
            return StatusController(delegate).apply(init)
        }
    }

    fun setLoadingView(view: View): StatusController {
        delegate.setLoadingView(view)
        return this
    }

    fun setEmptyView(view: View): StatusController {
        delegate.setEmptyView(view)
        return this
    }

    fun setErrorView(view: View): StatusController {
        delegate.setErrorView(view)
        return this
    }

    fun showLoading() = delegate.show(StatusViewState.LOADING)
    fun showEmpty() = delegate.show(StatusViewState.EMPTY)
    fun showError(message: String? = null) = delegate.show(StatusViewState.ERROR, message)
    fun showContent() = delegate.show(StatusViewState.CONTENT)
    fun setRetryAction(action: () -> Unit) = delegate.setRetry(action)
}

package com.example.basemodel.base.baseact

import androidx.viewbinding.ViewBinding
import com.example.basemodel.base.basevm.BaseViewModel
import com.kt.NetworkModel.ext.showToast

/**
 * @author 浩楠
 * @date 2025/5/22 14:44
 *      _              _           _     _   ____  _             _ _
 *     / \   _ __   __| |_ __ ___ (_) __| | / ___|| |_ _   _  __| (_) ___
 *    / _ \ | '_ \ / _` | '__/ _ \| |/ _` | \___ \| __| | | |/ _` | |/ _ \
 *   / ___ \| | | | (_| | | | (_) | | (_| |  ___) | |_| |_| | (_| | | (_) |
 *  /_/   \_\_| |_|\__,_|_|  \___/|_|\__,_| |____/ \__|\__,_|\__,_|_|\___/
 *  描述: TODO 添加 Toast 支持（自定义样式）
 */
abstract class BaseToastActivity<V : ViewBinding, VM : BaseViewModel> :
    BaseLoadingActivity<V, VM>() {

    override fun registerUIObservers() {
        super.registerUIObservers()
        mViewModel.uc.toastEvent().observe(this) { showMsg(it.toString()) }
    }

    protected fun showMsg(msg: String) {
        showToast(msg)
    }

    protected fun showMsgWithImage(msg: String, iconRes: Int) {
        showToast(msg, iconRes = iconRes)
    }
}
package com.example.basemodel.base.baseint

import androidx.lifecycle.DefaultLifecycleObserver
import androidx.lifecycle.LifecycleOwner

/**
 * @author 浩楠
 *
 * @date 2023/6/4-16:10
 *
 *      _              _           _     _   ____  _             _ _
 *     / \   _ __   __| |_ __ ___ (_) __| | / ___|| |_ _   _  __| (_) ___
 *    / _ \ | '_ \ / _` | '__/ _ \| |/ _` | \___ \| __| | | |/ _` | |/ _ \
 *   / ___ \| | | | (_| | | | (_) | | (_| |  ___) | |_| |_| | (_| | | (_) |
 *  /_/   \_\_| |_|\__,_|_|  \___/|_|\__,_| |____/ \__|\__,_|\__,_|_|\___/
 * @Description: TODO 通过接口类来实现我们需要的方法，并且便于后期我们对base的新增和修改
 */
interface IBaseView : DefaultLifecycleObserver {

    /**
     * 初始化界面传递参数，例如获取 intent 传值
     */
    fun initParam()

    /**
     * 初始化界面元素，例如 RecyclerView、按钮等 UI 元素
     */
    fun initView()

    /**
     * 初始化界面观察者的监听，例如 LiveData、Flow 等
     */
    fun initViewObservable()

    /**
     * 初始化数据，例如从网络/本地加载数据
     */
    fun initData()

    override fun onCreate(


through;
}
    .kanban-delay {
  color: #ff7575;
  background-color: #fff1f1 !important;
}
.kanban-delay .ibiz-rawitem__image {
  color: #ff7575;
}
    .kanban-time {
  height: 24px;
  padding: 0 10px;
  margin: 0 5px 5px 0;
  overflow: hidden;
  line-height: 12px;
  background: #e9e9e9;
  border-radius: 10px;
}

    .kanban-more-button{
    position: relative;
    width: 40px;
    margin: -8px 0px 0px -2px;
    height: 40px;
    visibility: hidden;
}
.el-card__body:hover .kanban-more-button {
    visibility: visible;
}
    .kanban-title .ibiz-span{
    padding: 10px 2px 10px 2px;
    font-size: 16px;
    font-weight: 600;
}
    .kanban-state {
  width: 80px;
  height: 24px;
  margin: 0 5px 5px 0;
}
.kanban-state .ibiz-code-list__item {
  --ibiz-code-list-item-color: #aaaaaa;
  justify-content: center;
  width: 80px;
  line-height: 24px;
  color: #fff;
  background-color: var(--ibiz-code-list-item-color);
  border-radius: 10px;
}

    .kanban-kind-icon {
  height: auto;
  margin: 5px 0 0;
  line-height: 24px;
}
.kanban-kind-icon .ibiz-code-list__item {
  font-size: 0;
}

    .kanban-assignee{
    margin: 0px 0px 0px 30px;
}

.kanban-assignee .ibiz-personnel-info-content__tip{
content-visibility: hidden;
}
    .wiki-page-title .ibiz-span{
    font-weight: 600;
    font-size: var(--ibiz-font-size-header-2);
    color: var(--ibiz-color-text-0);
}
.ibiz-form-group--grouppanel1:has(.wiki-page-title) .ibiz-form-item--icon .ibiz-span {
font-size: 24px;
}
    .wiki_page_title_style{
    padding-left: 10px !important;
}

.wiki_page_title_style .ibiz-span {
    font-size: 18px;
    color: var(--ibiz-color-text-0);
    margin-left: 5px;
    margin-right: 5px;
}

.wiki_page_title_style .ibiz-rawitem .ibiz-icon {
    font-size: 18px !important;
    margin-left: 5px;
}
    .confirm-remove-view .ibiz-form-item--formitem{
    background-color: rgba(255, 117, 117, 0.15);
    padding: 0px;
    height: auto;
    margin-top: 12px;
    border-radius: 5px;
    .ibiz-form-item-container__content>.ibiz-form-item-container__editor>span{
        display: inline-flex;
        align-items: center;
        margin: 0 10px;
        padding: 5px 10px;
        font-size: .875rem;
        line-height: 1;
        max-width: 33em;
        word-break: break-all;
        color: #ff7575;
    }
}
.confirm-remove-view .ibiz-form-item--remind{
    .ibiz-form-item-container__c


/49/d2/4919fcec189fe095d503e421cd9894d2.png?wh=1004*654>)

RMI的实现中，客户端的订单系统中的Stub是客户端的一个辅助对象，用于与服务端实现远程调用；服务端的支付系统中Skeleton是服务端的一个辅助对象，用于与客户端实现远程调用。

也就是说，客户端订单系统的Pay(Order)调用本地Stub对象上的方法，Stub对调用信息（比如变量、方法名等）进行打包，然后通过网络发送给服务端的Skeleton对象，Skeleton对象将收到的包进行解析，并调用服务端Pay(Order)系统中的相应对象和方法进行计算，计算结果又会以类似的方式返回给客户端。

为此，我们可以看出，**RMI与PRC最大的不同在于调用方式和返回结果的形式**，RMI通过对象作为远程接口来进行远程方法的调用，返回的结果也是对象形式，比如Java对象类型，或者是基本数据类型等。

RMI的典型实现框架有EJB（Enterprise JavaBean，企业级JavaBean），如果你需要深入了解这个框架的话，可以参考其官方文档。

### RPC与RMI对比分析

好了，上面我带你学习了RPC和RMI，接下来我通过一个表格来对比下它们的异同吧，以方便你进一步理解与记忆。

![](<https://static001.geekbang.org/resource/image/95/18/95f17b69cc412d690ef8c9abf9c47318.jpg?wh=3406*2277>)

## 知识扩展：远程过程调用存在同步和异步吗？

分布式领域中，我们经常会听到同步和异步这两个词，那么远程过程调用存在同步和异步吗？

答案是肯定的。

远程过程调用包括同步调用和异步调用两种，它们的含义分别是：

- 同步调用，指的是调用方等待被调用方执行完成并返回结果。这就好比在现实生活中，用户A让用户B完成一篇文章，用户A就在那里等着，一直等用户B将写好的文章交给用户A后才离开，并对文章进行审核。
- 异步调用，指的是调用方调用后不用等待被调用方执行结果即返回，返回结果调用方可以通过回调通知等方式获取。这就好比在现实生活中，用户A让用户B完成一篇文章，用户A告知用户B后，用户A离开去做其他事情，当用户B


# -*- encoding:utf-8 -*-
# __author__=='Gan'

# The set [1,2,3,…,n] contains a total of n! unique permutations.
# By listing and labeling all of the permutations in order,
# We get the following sequence (ie, for n = 3):
# "123"
# "132"
# "213"
# "231"
# "312"
# "321"
# Given n and k, return the kth permutation sequence.
# Note: Given n will be between 1 and 9 inclusive.

# Solution: Like Digits_Count.
# perm_index = k // (m - 1)! and m is the length of current perm_elements. it's very important.
# target_str += perm_elements.pop(perm_index)
# k %= divide

# 200 / 200 test cases passed.
# Status: Accepted
# Runtime: 35 ms
# Your runtime beats 83.66 % of python submissions.
from functools import reduce
class Solution(object):
    def getPermutation(self, n, k):
        """
        :type n: int
        :type k: int
        :rtype: str
        """
        perm_elements = [str(x) for x in range(1, n + 1)]
        target_str = ''
        k -= 1

        while k:
            divide = reduce(lambda x, y: x * y, range(1, len(perm_elements)))
            perm_index = k // divide
            target_str += perm_elements.pop(perm_index)
            k %= divide

        if perm_elements:
            target_str += ''.join(perm_elements)

        return target_str

if __name__ == '__main__':
    print(Solution().getPermutation(3, 1))


if (unitCode != null) 'unitCode': unitCode!,
  };
}

/// A message that represents custom attributes.
///
/// Exactly one of `value` or `group_values` must not be empty.
class CustomAttribute {
  /// Subattributes within this attribute group.
  ///
  /// If `group_values` is not empty, `value` must be empty.
  core.List<CustomAttribute>? groupValues;

  /// The name of the attribute.
  core.String? name;

  /// The value of the attribute.
  ///
  /// If `value` is not empty, `group_values` must be empty.
  core.String? value;

  CustomAttribute({this.groupValues, this.name, this.value});

  CustomAttribute.fromJson(core.Map json_)
    : this(
        groupValues:
            (json_['groupValues'] as core.List?)
                ?.map(
                  (value) => CustomAttribute.fromJson(
                    value as core.Map<core.String, core.dynamic>,
                  ),
                )
                .toList(),
        name: json_['name'] as core.String?,
        value: json_['value'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() => {
    if (groupValues != null) 'groupValues': groupValues!,
    if (name != null) 'name': name!,
    if (value != null) 'value': value!,
  };
}

/// The destination status of the product status.
class DestinationStatus {
  /// List of country codes (ISO 3166-1 alpha-2) where the offer is approved.
  core.List<core.String>? approvedCountries;

  /// List of country codes (ISO 3166-1 alpha-2) where the offer is disapproved.
  core.List<core.String>? disapprovedCountries;

  /// List of country codes (ISO 3166-1 alpha-2) where the offer is pending
  /// approval.
  core.List<core.String>? pendingCountries;

  /// The name of the reporting context.
  /// Possible string values are:
  /// - "REPORTING_CONTEXT_ENUM_UNSPECIFIED" : Not specified.
  /// - "SHOPPING_ADS" :
  /// [Shopping ads](https://support.google.com/merchants/answer/6149970).
  /// - "DISCOVERY_ADS" : Deprecated: Use `DEMAND_GEN_ADS` instead.
  /// [Discovery and Demand Gen ads](https://support.google.com/merchants/answer/13389785).
  /// - "DEMAND_GEN_ADS" :
  /// [Demand Gen ads](https://support.google.com/merchants/answer/13389785).
  /// - "DEMAND_GEN_ADS_DISCOVER_SURFACE" :
  /// [Demand Gen ads on Discover surface](https://support.google.com/merchants/answer/13389785).
  /// - "VIDEO_ADS" :
  /// [Video ads](https://support.google.com/google-ads/answer/6340491).
  /// - "DISPLAY_ADS" :
  /// [Display ads](https://support.google.com/merchants/answer/6069387).
  /// - "LOCAL_INVENTORY_ADS" :
  /// [Local inventory ads](https://support.google.com/merchants/answer/3271956).
  /// - "VEHICLE_INVENTORY_ADS" :
  /// [Vehicle inventory ads](https://support.google.com/merchants/answer/11544533).
  /// - "FREE_LISTINGS" :
  /// [Free product listings](https://support.google.com/merchants/answer/9199328).
  /// - "FREE_LOCAL_LISTINGS" :
  /// [Free local product listings](https://support.google.com/merchants/answer/9825611).
  /// - "FREE_LOCAL_VEHICLE_LISTINGS" :
  /// [Free local vehicle listings](https://support.google.com/merchants/answer/11544533).
  /// - "YOUTUBE_AFFILIATE" :
  /// [Youtube Affiliate](https://support.google.com/youtube/answer/13376398).
  /// - "YOUTUBE_SHOPPING" :
  /// [YouTube Sh


手】，有兴趣的朋友可以打开【作者其他软件.txt】查看源码和二进制地址，下载试用

# v4.0.3 2020.8.5
## bugfix
1. 将数据表中的公式改为最终值，避免后续使用代码修改数据表时公式不能解析而导致数据出错

## 其他
1. 更新默认模板配置

# v4.0.2 2020.7.30
## 切装
1. 修复切单件时，判定是否可以切神话的逻辑有误的问题
2. 默认包含手动切神话的方案

# v4.0.1 2020.7.29
## ui调整
1. 结果界面装备新增tips，方便查看名称

# v4.0.0 2020.7.29
## ui重构
1. 主界面增加tips
2. 一键点亮全部、重置可配置是否包含神话、武器
3. 重构ui布局逻辑，改为配置驱动，并支持嵌套打开多层次窗口，简化后续添加新装备的流程，可参考示例自行调整布局和层次结构
4. 移除原有的套装内装备顺序配置，改用新版ui布局配置来实现
5. 基于新版布局逻辑来重构获取装备和套装列表相关逻辑，如点击、检查装备和套装等
6. 修正一个可能因时序导致重置装备时，神话装备仍在闪烁的问题
7. 重构一键点亮、重置
8. 增加配置是否在启动时打开特定嵌套区域
9. 按照新本布局框架来重新布局装备
10. 增加代码内的默认布局配置，从而在配置文件无相关配置时也能正常显示

## 新增词条
1. 新增黄字和爆伤词条相关词条、数据、逻辑、周边处理等

## 数据更新
1. 从韩服同步一些数据
    1.1 深渊三件套的力智加成为1.03*1.02 = 1.0506
    1.2 深渊神话上衣应该加一级太阳和勇气
    1.3 修正传说装备数值
    1.4 歧路鞋子的勇气力智加成应为1.04*1.02=1.0608
2. 同步新的智慧产物、轮回、时空系列装备、超界板甲、普雷装备，并修正相关数据
3. 添加新装备对应图标、套装图标等各种数据
4. 根据新版ui框架新增新装备对应的ui配置
5. 录入新装备的暗抗、移速等数据，并特殊处理新装备的一些条件触发属性
6. 新增85ss智慧


_handler& handler) NOEXCEPT
{
    // Return to channel strand.
    boost::asio::post(channel_->strand(),
        std::bind(handler, ec, accepted));
}

} // namespace network
} // namespace libbitcoin
/**
 * Copyright (c) 2011-2025 libbitcoin developers (see AUTHORS)
 *
 * This file is part of libbitcoin.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include <bitcoin/network/net/distributor_client.hpp>

#include <bitcoin/network/define.hpp>
#include <bitcoin/network/async/async.hpp>
#include <bitcoin/network/messages/rpc/messages.hpp>

namespace libbitcoin {
namespace network {

using namespace system;

#define SUBSCRIBER(name) name##_subscriber_
#define MAKE_SUBSCRIBER(name) SUBSCRIBER(name)(strand)
#define STOP_SUBSCRIBER(name) SUBSCRIBER(name).stop_default(ec)
#define DO_NOTIFY(ec, name) \
    do_notify(ec, SUBSCRIBER(name), http::method::name{ request });
#define CASE_NOTIFY(ec, name) \
    case http::verb::name: { DO_NOTIFY(ec, name); return; }

distributor_client::distributor_client(asio::strand& strand) NOEXCEPT
  : MAKE_SUBSCRIBER(get),
    MAKE_SUBSCRIBER(head),
    MAKE_SUBSCRIBER(post),
    MAKE_SUBSCRIBER(put),
    MAKE_SUBSCRIBER(delete_),
    MAKE_SUBSCRIBER(trace),
    MAKE_SUBSCRIBER(options),
    MAKE_SUBSCRIBER(connect),
    MAKE_SUBSCRIBER(unknown)
{
}

void distributor_client::notify(
    const http::string_request_cptr& request) const NOEXCEPT
{
    if (!request)
    {
        DO_NOTIFY(error::operation_failed, unknown);
        return;
    }

    // Does not throw.
    BC_PUSH_WARNING(NO_THROW_IN_NOEXCEPT)
    switch (request->method())
    BC_POP_WARNING()
    {
        CASE_NOTIFY(error::success, get);
        CASE_NOTIFY(error::success, head);
        CASE_NOTIFY(error::success, post);
        CASE_NOTIFY(error::success, put);
        CASE_NOTIFY(error::success, delete_);
        CASE_NOTIFY(error::success, trace);
        CASE_NOTIFY(error::success, options);
        CASE_NOTIFY(error::success, connect);

        default:
        CASE_NOTIFY(error::success, unknown);
    }
}

void distributor_client::stop(const code& ec) NOEXCEPT
{
    STOP_SUBSCRIBER(get);
    STOP_SUBSCRIBER(head);
    STOP_SUBSCRIBER(post);
    STOP_SUBSCRIBER(put);
    STOP_SUBSCRIBER(delete_);
    STOP_SUBSCRIBER(trace);
    STOP_SUBSCRIBER(options);
    STOP_SUBSCRIBER(connect);
    STOP_SUBSCRIBER(unknown);
}

#undef SUBSCRIBER
#undef MAKE_SUBSCRIBER
#undef DO_NOTIFY
#undef CASE_NOTIFY
#undef STOP_SUBSCRIBER

} // namespace network
} // namespace libbitcoin
/**
 * Copyright (c) 2011-2025 libbitcoin developers (see AUTHORS)
 *
 * Th


     * @param batchSize         插入批次数量
     * @return 批处理结果
     */
    public static <T> List<BatchResult> execute(SqlSessionFactory sqlSessionFactory, Collection<T> dataList, boolean autoCommit, String statement, ParameterConvert<T> parameterConvert, int batchSize) {
        return new MybatisBatch<>(sqlSessionFactory, dataList, batchSize).execute(autoCommit, statement, parameterConvert);
    }

    /**
     * 执行批量操作
     *
     * @param sqlSessionFactory sqlSessionFactory {@link SqlSessionFactory}
     * @param dataList          数据集列表
     * @param batchMethod       批量操作方法
     * @param <T>               泛型
     * @return 批处理结果
     */
    public static <T> List<BatchResult> execute(SqlSessionFactory sqlSessionFactory, Collection<T> dataList, BatchMethod<T> batchMethod) {
        return new MybatisBatch<>(sqlSessionFactory, dataList).execute(batchMethod);
    }

    /**
     * 执行批量操作
     *
     * @param sqlSessionFactory sqlSessionFactory {@link SqlSessionFactory}
     * @param dataList          数据集列表
     * @param batchMethod       批量操作方法
     * @param <T>               泛型
     * @param batchSize         插入批次数量
     * @return 批处理结果
     */
    public static <T> List<BatchResult> execute(SqlSessionFactory sqlSessionFactory, Collection<T> dataList, BatchMethod<T> batchMethod, int batchSize) {
        return new MybatisBatch<>(sqlSessionFactory, dataList, batchSize).execute(batchMethod);
    }

    /**
     * 执行批量操作
     *
     * @param sqlSessionFactory sqlSessionFactory {@link SqlSessionFactory}
     * @param dataList          数据集列表
     * @param autoCommit        是否自动提交(这里生效的前提依赖于事务管理器 {@link org.apache.ibatis.transaction.Transaction})
     * @param batchMethod       批量操作方法
     * @param <T>               泛型
     * @return 批处理结果
     */
    public static <T> List<BatchResult> execute(SqlSessionFactory sqlSessionFactory, Collection<T> dataList, boolean autoCommit, BatchMethod<T> batchMethod) {
        return new MybatisBatch<>(sqlSessionFactory, dataList).execute(autoCommit, batchMethod);
    }

    /**
     * 执行批量操作
     *
     * @param sqlSessionFactory sqlSessionFactory {@link SqlSessionFactory}
     * @param dataList          数据集列表
     * @param autoCommit        是否自动提交(这里生效的前提依赖于事务管理器 {@link org.apache.ibatis.transaction.Transaction})
     * @param batchMethod       批量操作方法
     * @param <T>               泛型
     * @param batchSize         插入批次数量
     * @return 批处理结果
     */
    public static <T> List<BatchResult> execute(SqlSessionFactory sqlSessionFactory, Collection<T> dataList, boolean autoCommit, BatchMethod<T> batchMethod, int batchSize) {
        return new MybatisBatch<>(sqlSessionFactory, dataList, batchSize).execute(autoCommit, batchMethod);
    }

    /**
     * 批量保存或更新
     * 这里需要注意一下,如果在insertPredicate里判断调用其他sqlSession(类似mapper.xxx)时,要注意一级缓存问题或数据感知问题(因为当前会话数据还未提交)
     * 举个例子(事务开启状态下):
     * 如果当前


= 0x60;
        }

        flags.S = (temp & 0x80) ? 1 : 0;
        flags.Z = !(temp & 0xff) ? 1 : 0;
        flags.H = ((a & 0x10) ^ (temp & 0x10)) ? 1 : 0;
        flags.P = get_parity(temp & 0xff);
        // DAA never clears the carry flag if it was already set,
        //  but it is able to set the carry flag if it was clear.
        // Don't ask me, I don't know.
        // Note also that we check for a BCD carry, instead of the usual.
        flags.C = (flags.C || (a > 0x99)) ? 1 : 0;

        a = temp & 0xff;

        update_xy_flags(a);
    };
    // 0x28 : JR Z, n
    instructions[0x28] = function () {
        do_conditional_relative_jump(!!flags.Z);
    };
    // 0x29 : ADD HL, HL
    instructions[0x29] = function () {
        do_hl_add(l | (h << 8));
    };
    // 0x2a : LD HL, (nn)
    instructions[0x2a] = function () {
        pc = (pc + 1) & 0xffff;
        var address = core.mem_read(pc);
        pc = (pc + 1) & 0xffff;
        address |= core.mem_read(pc) << 8;

        l = core.mem_read(address);
        h = core.mem_read((address + 1) & 0xffff);
    };
    // 0x2b : DEC HL
    instructions[0x2b] = function () {
        var result = (l | (h << 8));
        result -= 1;
        l = result & 0xff;
        h = (result & 0xff00) >>> 8;
    };
    // 0x2c : INC L
    instructions[0x2c] = function () {
        l = do_inc(l);
    };
    // 0x2d : DEC L
    instructions[0x2d] = function () {
        l = do_dec(l);
    };
    // 0x2e : LD L, n
    instructions[0x2e] = function () {
        pc = (pc + 1) & 0xffff;
        l = core.mem_read(pc);
    };
    // 0x2f : CPL
    instructions[0x2f] = function () {
        a = (~a) & 0xff;
        flags.N = 1;
        flags.H = 1;
        update_xy_flags(a);
    };
    // 0x30 : JR NC, n
    instructions[0x30] = function () {
        do_conditional_relative_jump(!flags.C);
    };
    // 0x31 : LD SP, nn
    instructions[0x31] = function () {
        sp = core.mem_read((pc + 1) & 0xffff) |
            (core.mem_read((pc + 2) & 0xffff) << 8);
        pc = (pc + 2) & 0xffff;
    };
    // 0x32 : LD (nn), A
    instructions[0x32] = function () {
        pc = (pc + 1) & 0xffff;
        var address = core.mem_read(pc);
        pc = (pc + 1) & 0xffff;
        address |= core.mem_read(pc) << 8;

        core.mem_write(address, a);
    };
    // 0x33 : INC SP
    instructions[0x33] = function () {
        sp = (sp + 1) & 0xffff;
    };
    // 0x34 : INC (HL)
    instructions[0x34] = function () {
        var address = l | (h << 8);
        core.mem_write(address, do_inc(core.mem_read(address)));
    };
    // 0x35 : DEC (HL)
    instructions[0x35] = function () {


 {
        self.redirect = Some(mechanism);
        self.is_redirected = true;
        if self.all.is_some() {
            self.all = None;
        }
    }
    /// Clear the passed Kind which has been passed.
    /// Sets the passed mechanism to `None`
    ///
    /// # Note:
    /// This method clears all assocated Mechanism for the [`Kind`](Kind) provided.
    ///
    /// # Example:
    /// ```
    /// use decon_spf::mechanism::{Qualifier, Kind, Mechanism};
    /// use decon_spf::Spf;
    /// let mut new_spf_record = Spf::new();
    /// new_spf_record.set_v1();
    /// new_spf_record.append_mechanism(Mechanism::new_all(Qualifier::Pass));
    /// new_spf_record.append_mechanism(Mechanism::new_a_without_mechanism(Qualifier::Pass));
    /// new_spf_record.append_ip_mechanism(Mechanism::new_ip(Qualifier::Pass,
    ///                                                      "172.16.58.3/23".parse().unwrap()));
    /// assert_eq!(new_spf_record.to_string(), "v=spf1 a ip4:172.16.58.3/23 all".to_string());
    /// // Remove ip4 Mechanism
    /// new_spf_record.clear_mechanism(Kind::IpV4);
    /// assert_eq!(new_spf_record.to_string(), "v=spf1 a all".to_string());
    ///```
    pub fn clear_mechanism(&mut self, kind: Kind) {
        match kind {
            Kind::Redirect => {
                self.redirect = None;
                self.is_redirected = false;
            }
            Kind::A => self.a = None,
            Kind::MX => self.mx = None,
            Kind::Include => self.include = None,
            Kind::IpV4 => self.ip4 = None,
            Kind::IpV6 => self.ip6 = None,
            Kind::Exists => self.exists = None,
            Kind::Ptr => self.ptr = None,
            Kind::All => self.all = None,
        }
    }

    fn append_mechanism_of_a(&mut self, mechanism: Mechanism<String>) {
        if let Some(a) = &mut self.a {
            a.push(mechanism);
        } else {
            self.a = Some(vec![mechanism]);
        }
    }
    fn append_mechanism_of_mx(&mut self, mechanism: Mechanism<String>) {
        if let Some(mx) = &mut self.mx {
            mx.push(mechanism);
        } else {
            self.mx = Some(vec![mechanism]);
        }
    }
    fn append_mechanism_of_include(&mut self, mechanism: Mechanism<String>) {
        if let Some(include) = &mut self.include {
            include.push(mechanism);
        } else {
            self.include = Some(vec![mechanism]);
        }
    }
    fn append_mechanism_of_ip4(&mut self, mechanism: Mechanism<IpNetwork>) {
        if let Some(ip4) = &mut self.ip4 {
            ip4.push(mechanism);
        } else {
            self.ip4 = Some(vec![mechanism]);
        }
    }
    fn append_mechanism_of_ip6(&mut self, mechanism: Mechanism<IpNetwork>) {
        if let Some(ip6) = &mut self.ip6 {
            ip6.push(mechanism);
        } else {
            self.ip6 = Some(vec![mechanism]);
        }
    }
    fn append_mechanism_of_exists(&mut self, mechanism: Mechanism<String>) {
        if let Some(exists) = &mut self.exists {


 assert expected_text in actual_text, f"Expected text to contain: {expected_text}, but got: {actual_text}"
            logs.info(f"断言结果：元素文本内容包含预期文本，实际文本内容为：{actual_text}")
        except NoSuchElementException as e:
            # 捕获元素未找到的异常并记录错误日志
            logs.error(f"元素未找到，{e}")
            raise AssertionError('元素不存在')
        except AssertionError as e:
            # 捕获断言失败的异常并记录错误日志
            logs.error(f"文本断言失败，{e}")
            raise e

    def visibility_of_element_located(self, by, value):
        """
        等待元素可见性
        :param by:
        :param value:
        :return:
        """
        try:
            # 使用显式等待判断元素是否可见
            element = self.__wait.until(ec.visibility_of_element_located((by, value)))
            logs.info(f"找到元素：{by} = {value}")
            return element
        except Exception as e:
            # 捕获异常并记录错误日志
            logs.error(f"在设定时间内未找到元素：{by} = {value}")
            raise e


hash \"5dtLYB93Mi3NowoYurf1Ue76yrXtDC\"}}]], :nextjournal/render-opts {:id \"calculus/markdown-5dtDXo1nnEDjPcELAnEjwVHHmBan3Z\"}, :nextjournal/viewer {:name nextjournal.clerk.viewer/markdown-node-viewer, :render-fn #viewer-fn identity, :hash \"5dsg4Bx9A9L7WvvCgamUoRtxUsmYCe\"}} {:path [], :nextjournal/value \"(defn xsinx [x] (* x (m/sin x)))\", :nextjournal/render-opts {:loc {:line 57, :end-line 58, :column 1, :end-column 33}, :id \"calculus/xsinx-code\"}, :nextjournal/viewer {:name nextjournal.clerk.viewer/code-block-viewer, :render-fn #viewer-fn nextjournal.clerk.render/render-code-block, :hash \"5dru1FUcVRTRrVKJFbNw4FG2wXmiwB\"}} {:path [], :nextjournal/value [:div.viewer.markdown-viewer.w-full.max-w-prose.px-8 {:data-block-id \"calculus/markdown-5drVEjgkceiWaKULUyAHZPbYPpd9Rh\"} [:p [:<> \"And actual derivative\"]] [#viewer-eval nextjournal.clerk.render/inspect-presented {:nextjournal/value \"f'(x)=\\\\sin{x}+x\\\\cos{x}\", :nextjournal/viewer {:name :nextjournal.markdown/block-formula, :render-fn #viewer-fn nextjournal.clerk.render/render-katex, :hash \"5dtLYB93Mi3NowoYurf1Ue76yrXtDC\"}}]], :nextjournal/render-opts {:id \"calculus/markdown-5drVEjgkceiWaKULUyAHZPbYPpd9Rh\"}, :nextjournal/viewer {:name nextjournal.clerk.viewer/markdown-node-viewer, :render-fn #viewer-fn identity, :hash \"5dsg4Bx9A9L7WvvCgamUoRtxUsmYCe\"}} {:path [], :nextjournal/value \"(defn xsinx' [x] (+ (m/sin x) (* x (m/cos x))))\", :nextjournal/render-opts {:loc {:line 64, :end-line 65, :column 1, :end-column 48}, :id \"calculus/xsinx'-code\"}, :nextjournal/viewer {:name nextjournal.clerk.viewer/code-block-viewer, :render-fn #viewer-fn nextjournal.clerk.render/render-code-block, :hash \"5dru1FUcVRTRrVKJFbNw4FG2wXmiwB\"}} {:path [], :nextjournal/value [:div.viewer.markdown-viewer.w-full.max-w-prose.px-8 {:data-block-id \"calculus/markdown-5dtBuFSpywookWyf9qw2A2SqzJSkZf\"} [:p [:<> \"Value of derivative for \"] [#viewer-eval nextjournal.clerk.render/inspect-presented {:nextjournal/value \"x=0.5\", :nextjournal/viewer {:name :nextjournal.markdown/formula, :render-fn #viewer-fn (fn [tex] (nextjournal.clerk.render/render-katex tex {:inline? true})), :hash \"5dtTBivp9Yiw7XSqxv1opZHNencsu6\"}}] [:<> \" equals:\"]]], :nextjournal/render-opts {:id \"calculus/markdown-5dtBuFSpywookWyf9qw2A2SqzJSkZf\"}, :nextjournal/viewer {:name nextjournal.clerk.viewer/markdown-node-viewer, :render-fn #viewer-fn identity, :hash \"5dsg4Bx9A9L7WvvCgamUoRtxUsmYCe\"}} {:path [], :next


/* 8000BB04 00007044  38 21 00 20 */	addi r1, r1, 0x20
/* 8000BB08 00007048  4E 80 00 20 */	blr

.global func_8000BB0C
func_8000BB0C:
/* 8000BB0C 0000704C  94 21 FF 80 */	stwu r1, -0x80(r1)
/* 8000BB10 00007050  7C 08 02 A6 */	mflr r0
/* 8000BB14 00007054  90 01 00 84 */	stw r0, 0x84(r1)
/* 8000BB18 00007058  93 E1 00 7C */	stw r31, 0x7c(r1)
/* 8000BB1C 0000705C  40 86 00 24 */	bne cr1, lbl_8000BB40
/* 8000BB20 00007060  D8 21 00 28 */	stfd f1, 0x28(r1)
/* 8000BB24 00007064  D8 41 00 30 */	stfd f2, 0x30(r1)
/* 8000BB28 00007068  D8 61 00 38 */	stfd f3, 0x38(r1)
/* 8000BB2C 0000706C  D8 81 00 40 */	stfd f4, 0x40(r1)
/* 8000BB30 00007070  D8 A1 00 48 */	stfd f5, 0x48(r1)
/* 8000BB34 00007074  D8 C1 00 50 */	stfd f6, 0x50(r1)
/* 8000BB38 00007078  D8 E1 00 58 */	stfd f7, 0x58(r1)
/* 8000BB3C 0000707C  D9 01 00 60 */	stfd f8, 0x60(r1)
lbl_8000BB40:
/* 8000BB40 00007080  39 61 00 88 */	addi r11, r1, 0x88
/* 8000BB44 00007084  38 01 00 08 */	addi r0, r1, 8
/* 8000BB48 00007088  3D 80 03 00 */	lis r12, 0x300
/* 8000BB4C 0000708C  90 E1 00 18 */	stw


l Girouard", "$"],
    ["総督", "Governor General", "$"],
    [1908, 1909, null, "$", "Edouard Percy Cranwill Girouard", "$"],
    [1909, 1912, null, "$", "Henry Hesketh Joudou Bell", "$"],
    [1912, 1914, null, "$", "Frederick John Dealtry Lugard", "$"],
  ],
  [null, 1903, 9999,
    [1903, 9999, "pa", "パナマ共和国", "Republic of Panama", "巴拿马共和国", "パナマ", "Panama", "巴拿马", 1008, 810, 1],
    ["大统领", "President", "总统"],
    [1904, 1908, "m-amc/manuel-amador", "マヌエ儿・アマドー儿", "Manuel Amador Guerrero", "曼努埃尔・阿马多尔・格雷罗"],
    [1908, 1910, "m-amc/jose-domingo-de-obaldia", "ホセ・ドミンゴ・デ・オバ儿ディア", "José Domingo de Obaldía", "何塞・多明戈・德・欧巴迪亚"],
    [1910, 1912, "m-amc/pablo-arosemena", "パブロ・アロセメナ", "Pablo Arosemena Alba", "帕布洛・阿罗瑟梅纳"],
    [1912, 1916, "m-amc/belisario-porras", "ベリサリオ・ポラス", "Belisario Porras Barahona", "博里萨里奥・博拉斯"],
    [1916, 1918, "m-amc/ramon-valdes", "ラモン・マクシミリアーノ・バ儿デス", "Ramón Maximiliano Valdés", "拉蒙・马克西米连奥・瓦尔德斯"],
    [1918, 1924, "m-amc/belisario-porras", "ベリサリオ・ポラス", "Belisario Porras Barahona", "博里萨里奥・博拉斯"],
    [1924, 1928, "m-amc/rodolfo-chiari", "ロド儿フォ・チアリ", "Rodolfo Chiari", "洛多尔福・希亚里"],
    [1928, 1931, "m-amc/florencio-h-arosemena", "フロレンシオ・ア儿モディオ・アロセメナ", "Florencio Harmodio Arosemena", "弗朗西斯科・哈莫迪奥・阿罗瑟梅纳・纪廉"],
    [1931, 1932, "m-amc/ricard-j-alfaro", "リカ儿ド・ホアキン・ア儿ファロ・ホバネ", "Ricardo Joaquín Alfaro Jované", "理察多・尤库恩・阿尔法洛・尤瓦内"],
    [1932, 1936, null, "ア儿モディオ・アリアス", "Harmodio Arias Madrid", "阿尔莫迪奥・阿里亚斯"],
    [1936, 1939, null, "$", "Juan Demóstenes Arosemena", "胡安・德莫斯特内斯・阿罗瑟梅那・巴勒提"],
    [1939, 1940, null, "アウグスト・サムエ儿・ボイド", "Augusto Samuel Boyd", "奥古斯都・萨姆埃尔・博伊德"],
    [1940, 1941, "m-amc/arias-madrid", "ア儿ヌ儿フォ・アリアス", "Arnulfo Arias Madrid", "阿努尔


r (SizeType i = 0; i < a.Size(); i++)	// rapidjson uses SizeType instead of size_t.
			printf("a[%d] = %d\n", i, a[i].GetInt());

		// Note:
		//int x = a[0].GetInt();					// Error: operator[ is ambiguous, as 0 also mean a null pointer of const char* type.
		int y = a[SizeType(0)].GetInt();			// Cast to SizeType will work.
		int z = a[0u].GetInt();						// This works too.
		(void)y;
		(void)z;

		// Iterating array with iterators
		printf("a = ");
		for (Value::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr)
			printf("%d ", itr->GetInt());
		printf("\n");
	}

	// Iterating object members
	static const char* kTypeNames[] = { "Null", "False", "True", "Object", "Array", "String", "Number" };
	for (Value::ConstMemberIterator itr = document.MemberBegin(); itr != document.MemberEnd(); ++itr)
		printf("Type of member %s is %s\n", itr->name.GetString(), kTypeNames[itr->value.GetType()]);

	////////////////////////////////////////////////////////////////////////////
	// 3. Modify values in document.

	// Change i to a bigger number
	{
		uint64_t f20 = 1;	// compute factorial of 20
		for (uint64_t j = 1; j <= 20; j++)
			f20 *= j;
		document["i"] = f20;	// Alternate form: document["i"].SetUint64(f20)
		assert(!document["i"].IsInt());	// No longer can be cast as int or uint.
	}

	// Adding values to array.
	{
		Value& a = document["a"];	// This time we uses non-const reference.
		Document::AllocatorType& allocator = document.GetAllocator();
		for (int i = 5; i <= 10; i++)
			a.PushBack(i, allocator);	// May look a bit strange, allocator is needed for potentially realloc. We normally uses the document's.

		// Fluent API
		a.PushBack("Lua", allocator).PushBack("Mio", allocator);
	}

	// Making string values.

	// This version of SetString() just store the pointer to the string.
	// So it is for literal and string that exists within value's life-cycle.
	{
		document["hello"] = "rapidjson";	// This will invoke strlen()
		// Faster version:
		// document["hello"].SetString("rapidjson", 9);
	}

	// This version of SetString() needs an allocator, which means it will allocate a new buffer and copy the the string into the buffer.
	Value author;
	{
		char buffer[10];
		int len = sprintf(buffer, "%s %s", "Milo", "Yip");	// synthetic example of dynamically created string.

		author.SetString(buffer, len, document.GetAllocator());
		// Shorter but slower version:
		// document["hello"].SetString(buffer, document.GetAllocator());

		// Constructor version:
		// Value author(buffer, len, document.GetAllocator());
		// Value author(buffer, document.GetAllocator());
		memset(buffer, 0, sizeof(buffer)); // For demonstration purpose.
	}
	// Variable 'buffer' is unusable now but 'author' has already made a copy.
	document.AddMember("author", author, document.GetAllocator());

	assert(author.IsNull());		// Move semantic for assignment. After this variable is assigned as a member, the variable becomes null.

	////////////////////////////////////////////////////////////////////////////
	// 4. Stringify JSON

	printf("\nModified JSON with reformatting:\n");
	FileStream f(stdout);
	PrettyWriter<FileStream> writer(f);
	document.Accept(writer);


virtual void DisplayDutyStatus()
    {
        if (DataCenter.IsInMonsterHunterDuty)
        {
            ImGui.Spacing();
            ImGui.Text($"MegaPotionPvE Slotted: {MegaPotionPvE.Info.IsOnSlot}");
            ImGui.Text($"MegaPotionPvE Charges: {MegaPotionPvE.Cooldown.CurrentCharges}");
            ImGui.Spacing();
            ImGui.Text($"Rathalos Normal: {RathalosNormal}");
            ImGui.Text($"Rathalos EX: {RathalosEX}");
            ImGui.Spacing();
            ImGui.Spacing();
            ImGui.Text($"MegaPotionPvE_44247 Slotted: {MegaPotionPvE_44247.Info.IsOnSlot}");
            ImGui.Text($"MegaPotionPvE_44247 Charges: {MegaPotionPvE_44247.Cooldown.CurrentCharges}");
            ImGui.Spacing();
            ImGui.Text($"Arkveld Normal: {ArkveldNormal}");
            ImGui.Text($"Arkveld EX: {ArkveldEX}");
            ImGui.Spacing();
        }

        if (DataCenter.IsInOccultCrescentOp)
        {
            ImGui.Text($"ActivePhantomJob: {ActivePhantomJob ?? "N/A"}");
            ImGui.Spacing();

            if (string.Equals(ActivePhantomJob, "Oracle", StringComparison.OrdinalIgnoreCase))
            {
                ImGui.Text($"HasCleansing: {HasCleansing}");
                ImGui.Text($"HasStarfall: {HasStarfall}");
                ImGui.Text($"HasPhantomJudgment: {HasPhantomJudgment}");
                ImGui.Text($"HasBlessing: {HasBlessing}");
            }

            if (string.Equals(ActivePhantomJob, "Samurai", StringComparison.OrdinalIgnoreCase))
            {
                ImGui.Text($"Has item for Zeninage: {ZeninageItem.HasIt}");
            }

            if (string.Equals(ActivePhantomJob, "Chemist", StringComparison.OrdinalIgnoreCase))
            {
                ImGui.Text($"Has item for Occult Potion: {OccultPotionItem.HasIt}");
                ImGui.Text($"Has item for Occult Ether: {OccultPotionItem.HasIt}");
                ImGui.Text($"Has item for Occult Elixir: {OccultElixirItem.HasIt}");
            }
        }

        if (InVariantDungeon)
        {
            ImGui.Text($"VariantUltimatumPvE Status: {Player.HasStatus(true, StatusID.VariantUltimatumSet)}");
            ImGui.Spacing();
            ImGui.Text($"VariantSpiritDartPvE_33863  Status: {Player.HasStatus(true, StatusID.VariantSpiritDartSet)}");
            ImGui.Text($"VariantSpiritDartPvE_33863 Slotted: {VariantSpiritDartPvE_33863.Info.IsOnSlot}");
            ImGui.Spacing();
            ImGui.Text($"VariantSpiritDartPvE  Status: {Player.HasStatus(true, StatusID.VariantSpiritDartSet)}");
            ImGui.Text($"VariantSpiritDartPvE Slotted: {VariantSpiritDartPvE.Info.IsOnSlot}");
            ImGui.Spacing();
            ImGui.Text($"VariantRampartPvE_33864 Status: {Player.HasStatus(true, StatusID.VariantRampartSet)}");
            ImGui.Spacing();
            ImGui.Text($"VariantRampartPvE Status: {Player.HasStatus(true, StatusID.VariantRampartSet)}");
            ImGui.Spacing();
            ImGui.Text($"VariantCurePvE_33862  Status: {Player.HasStatus(true, StatusID.VariantCureSet)}");
            ImGui.Text($"VariantCurePvE_33862 Slotted: {VariantCurePvE_33862.Info.IsOnSlot}");
            Im


心，亚信安全服务器深度安全防护系统（Deep Security）是为虚拟化环境量身打造的专属安全防护系统，产品具备了虚拟补丁功能、以及Web应用层检测、IDS、IPS等深度检测包技术，可以有效发现和拦截APT攻击等高级网络威胁 。最为重要的是，亚信安全创新的“无代理”部署特性能帮助用户避免产生防毒风暴(AV Storm)，从而大幅提升虚拟机密度，帮助云计算运营平台实现更具弹性部署和更快的处理速度。

服务器深度安全防护系统统一控制平台

其次，通过亚信安全服务器深度安全防护系统中的Deep Security Manager，用户可以统一管控本地物理服务器、近端和云端虚拟化服务器，以及全面支持各大云服务商混合云方案和Docker等开源技术构建混合云平台。对于Docker的安全防护需求，亚信安全服务器深度安全防护系统中的Deep Security for Docker，可以保存Docker中镜像的配置文件、监控相同属性容器的活动，并在主机上检查网络情况，洞悉Docker中流动的网络安全威胁，从而阻拦黑客从外部、内部（不受限制节点）发动的网络攻击，为混合云环境打造一体化的安全管理平台。

在数据传输方面，亚信安全服务器深度安全防护系统可以侦测虚拟化网络恶意代码侦测，支持安全策略在云平台之间移动，以及自动追踪和防护休眠状态中的虚拟资源，避免安全防御间隙的产生。在混合云边境，亚信安全深度威胁安全网关 Deep Edge提供了VPN加密等保护特性，结合业界领先的云安全智能防护网络（Smart Protection Network，SPN）和新一代的高级威胁侦测分析引擎，可无缝对接亚信安全的深度威胁发现平台（DD），实现混合云中的数据安全传输。

<p


          String groupSearchTemplate, Map avPairs) throws AMException,
            SSOException {
        String filter;
        if (groupSearchTemplate != null && groupSearchTemplate.length() > 0) {
            filter = getSearchFilter(AMObject.GROUP, groupSearchTemplate);
        } else {
            filter = "(|" + getSearchFilter(AMObject.GROUP)
                    + getSearchFilter(AMObject.DYNAMIC_GROUP)
                    + getSearchFilter(AMObject.ASSIGNABLE_DYNAMIC_GROUP) + ")";
        }
        return searchObjects(AMNamingAttrManager.getNamingAttr(GROUP), filter,
                wildcard, avPairs, level);
    }

    public AMSearchResults searchGroups(String wildcard, Map avPairs,
            String groupSearchTemplate, AMSearchControl searchControl)
            throws AMException, SSOException {
        String filter;
        if (groupSearchTemplate != null && groupSearchTemplate.length() > 0) {
            filter = getSearchFilter(AMObject.GROUP, groupSearchTemplate);
        } else {
            filter = "(|" + getSearchFilter(AMObject.GROUP)
                    + getSearchFilter(AMObject.DYNAMIC_GROUP)
                    + getSearchFilter(AMObject.ASSIGNABLE_DYNAMIC_GROUP) + ")";
        }
        return searchObjects(AMNamingAttrManager.getNamingAttr(GROUP), filter,
                wildcard, avPairs, searchControl);
    }

    public AMSearchResults searchStaticGroups(String wildcard, Map avPairs,
            AMSearchControl searchControl) throws AMException, SSOException {
        String filter = getSearchFilter(AMObject.GROUP);

        return searchObjects(AMNamingAttrManager.getNamingAttr(GROUP), filter,
                wildcard, avPairs, searchControl);
    }

}
/**
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 2005 Sun Microsystems Inc. All Rights Reserved
 *
 * The contents of this file are subject to the terms
 * of the Common Development and Distribution License
 * (the License). You may not use this file except in
 * compliance with the License.
 *
 * You can obtain a copy of the License at
 * https://opensso.dev.java.net/public/CDDLv1.0.html or
 * opensso/legal/CDDLv1.0.txt
 * See the License for the specific language governing
 * permission and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL
 * Header Notice in each file and include the License file
 * at opensso/legal/CDDLv1.0.txt.
 * If applicable, add the following below the CDDL Header,
 * with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * $Id: AMObjectClassManager.java,v 1.5 2008/06/25 05:41:21 qcheng Exp $
 *
 */

package com.iplanet.am.sdk;

import com.iplanet.am.sdk.common.IDirectoryServices;
import com.sun.identity.shared.debug.Debug;
import java.util.HashMap;
import java.util.Map;

/**
 * A Class to manage the object class information.
 *
 * @deprecated  As of Sun Java System Access Manager 7.1.
 */
public class AMObjectClassManager {
    // Debug object
    static Debug debug = AMCommonUtils.debug;

    // Map storing the object types and corresponding object classes
    public static Map objectClassMap = new HashMap();

    // Map to store the objectclass with the matching object type (reverse of
    // above)
    public static Map objectTypeMap = new HashMap();

    public static String getObjectClass(int objectType) {
        String type = Integer.toString(objectType);
        String oc = (String) objectClassMap.get(type);
        if (oc == null) {
            oc = getObjectClassFromDS(objectType);
            if (oc.length() != 0) {
                objectClassMap.put(type, oc);
            } else {
                // The right thing to do is to throw an exception here.
            }
        }
        return oc;
    }

    private static String


            BEAST_EXPECT(r[jss::result][jss::channels].size() == 0);
            BEAST_EXPECT(r[jss::result][jss::validated]);
        }
        env(create(alice, bob, channelFunds, settleDelay, pk));
        env.close();
        auto const chan2Str = to_string(channel(*env.current(), alice, bob));
        {
            auto const r =
                env.rpc("account_channels", alice.human(), bob.human());
            BEAST_EXPECT(r[jss::result][jss::channels].size() == 2);
            BEAST_EXPECT(r[jss::result][jss::validated]);
            BEAST_EXPECT(chan1Str != chan2Str);
            for (auto const& c : {chan1Str, chan2Str})
                BEAST_EXPECT(
                    r[jss::result][jss::channels][0u][jss::channel_id] == c ||
                    r[jss::result][jss::channels][1u][jss::channel_id] == c);
        }

        auto sliceToHex = [](Slice const& slice) {
            std::string s;
            s.reserve(2 * slice.size());
            for (int i = 0; i < slice.size(); ++i)
            {
                s += "0123456789ABCDEF"[((slice[i] & 0xf0) >> 4)];
                s += "0123456789ABCDEF"[((slice[i] & 0x0f) >> 0)];
            }
            return s;
        };

        {
            // Verify chan1 auth
            auto const rs =
                env.rpc("channel_authorize", "alice", chan1Str, "1000");
            auto const sig = rs[jss::result][jss::signature].asString();
            BEAST_EXPECT(!sig.empty());
            {
                auto const rv = env.rpc(
                    "channel_verify", chan1PkStr, chan1Str, "1000", sig);
                BEAST_EXPECT(rv[jss::result][jss::signature_verified].asBool());
            }

            {
                // use pk hex to verify
                auto const pkAsHex = sliceToHex(pk.slice());
                auto const rv =
                    env.rpc("channel_verify", pkAsHex, chan1Str, "1000", sig);
                BEAST_EXPECT(rv[jss::result][jss::signature_verified].asBool());
            }
            {
                // malformed amount
                auto const pkAsHex = sliceToHex(pk.slice());
                auto rv =
                    env.rpc("channel_verify", pkAsHex, chan1Str, "1000x", sig);
                BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
                rv = env.rpc("channel_verify", pkAsHex, chan1Str, "1000 ", sig);
                BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
                rv = env.rpc("channel_verify", pkAsHex, chan1Str, "x1000", sig);
                BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
                rv = env.rpc("channel_verify", pkAsHex, chan1Str, "x", sig);
                BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
                rv = env.rpc("channel_verify", pkAsHex, chan1Str, " ", sig);
                BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
                rv = env.rpc(
                    "channel_verify", pkAsHex, chan1Str, "1000 1000", sig);
                BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
                rv = env.rpc("channel_verify", pkAsHex, chan1Str, "1,000", sig);
                BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
                rv = env.rpc("channel_verify", pkAsHex, chan1Str, "


，比如 for 循环中，我们要查看一个变量循环 3 次后的结果就可以使用该方式。

[![Debug 特殊技能使用](https://github.com/judasn/IntelliJ-IDEA-Tutorial/raw/master/images/xxiii-c-debug-use-3.jpg)](https://github.com/judasn/IntelliJ-IDEA-Tutorial/blob/master/images/xxiii-c-debug-use-3.jpg)

> - 如上图，对于某些不重要的断点，只要步入一次就够了，就可以勾选此选项，让它步入之后自动删除。

[![Debug 特殊技能使用](https://github.com/judasn/IntelliJ-IDEA-Tutorial/raw/master/images/xxiii-c-debug-use-4.jpg)](https://github.com/judasn/IntelliJ-IDEA-Tutorial/blob/master/images/xxiii-c-debug-use-4.jpg)

> - 如上图，对于某些场景的断点，需要其他断点先触发之后再进行触发，可以选择此项。默认选择的是： None

[![Debug 特殊技能使用](https://github.com/judasn/IntelliJ-IDEA-Tutorial/raw/master/images/xxiii-b-debug-use-5.gif)](https://github.com/judasn/IntelliJ-IDEA-Tutorial/blob/master/images/xxiii-b-debug-use-5.gif)

> - 有时候当我们步入方法体之后，还想回退到方法体外。如 Gif 演示，断点进入 `addNum` 方法后，点击 `Drop Frame` 按钮之后，断点重新回到方法体之外。

[![Debug 特殊技能使用](https://github.com/judasn/IntelliJ-IDEA-Tutorial/raw/master/images/xxiii-c-debug-use-1.jpg)](https://github.com/judasn/IntelliJ-IDEA-Tutorial/blob/master/images/xxiii-c-debug-use-1.jpg)

> - 上图 IntelliJ IDEA 版本：2017.1.3
> - 如上图左侧红框内容，可以看到当前断点线程执行的堆栈情况，最上面的为当前断点位置，下面的是断点前面执行的方法，如果需要看断点前面走过的路，可以查看该区域。并且可以用图上箭头按钮进行限制显示框架类代码的执行过程，而不是包括依赖 jar 里面的执行过程。
> - 如上图右侧红框内容，可以用来展示单点断点位置的内存情况，对于判断内存溢出相关问题很有帮助。### 示例

- 一次性部署多个Jar，要拆分的话自己按需拆分

```shell
#!/bin/bash
# 拉代码、Maven编译打包
cd /home/developer/jdy/JDY-Backend/jdy-parent
git pull
mvn clean install -DskipTests

# 杀进程
ps -ef | grep jdy-agent-service | grep -v grep |  awk '{print $2}' | xargs kill -9
ps -ef | grep jdy-system-service | grep -v grep |  awk '{print $2}' | xargs kill -9
ps -ef | grep jdy-insurance-service | grep -v grep |  awk '{print $2}' | xargs kill -9
ps -ef | grep jdy-mechanism-service | grep -v grep |  awk '{print $2}' | xargs kill -9
ps -ef | grep jdy-gateway | grep -v grep |  awk '{print $2}' | xargs kill -9

# 启动项目
nohup java -jar /home/developer/jdy/JDY-Backend/jdy-parent/jdy-agent/jdy-agent-service/target/jdy-agent-service.jar --spring.profiles.active=dev > /home/developer/jdy/logs/


The problems of WordMacro virus upconversion. Computers and Security 18, 241-255.

CLOUGH, B. & MUNGO, P. (1992). Approaching Zero: Data Crime and the Computer Underworld. London: Faber and Faber.

COHEN, F. B. (1994). A Short Course on Computer Viruses (2nd edn). New York: Wiley.

CORNWALL, H. (1990). Data Theft: Computer Fraud, Industrial Espionage and Information Crime. London: Mandarin.

CUSUMANO, M. A. & SELBY, R. W. (1997). How Microsoft builds software. Communications of the ACM, 40, 53-61.

DEMPSEY, M. (1997). Computer security. Financial Times, 2 April.

DENNING, P. J. Ed. (1990). Computers Under Attack. New York: ACM Press.

FITES, P., JOHNSTON, P. & KRATZ, M. (1992). The Computer Virus Crisis (2nd edn). New York: Van Nostrand Reinhold.

FLOWER, J. (1995). Catching Kevin and his friends. New Scientist, 2nd September, 147, 32.

FORCHT, K. A. (1994). Computer Security Management. Danvers MA. Boyd & Fraser Publishing Co.

FORD, R. (1999). No surprises in Melissa land. Computers and Security, 18, 300-302.

GORDON, S. (1994). The generic virus writer. Proceedings of the 4th International Virus Bulletin Conference. Jersey, UK. [http://www.av.ibm.com/Publish/Scientificpapers/Gordon/].

GORDON, S. (1995). Technologically enabled crime: shifting paradigms for the year 2000. Computers and Security, 14, 391-402.

GORDON, S., FORD, R. & WELLS, J. (1997). Hoaxes and hypes. Proceedings of the 7th International Virus Bulletin Conference. San Francisco, USA. [http://www.av.ibm.com/Publish/Scientificpapers/Gordon/HH.html].

GIBBS, G. (1995). Black Baron's computer virus plague. The Guardian, 16 November 1995, Home 2.

HOFFMAN, L. J. (1990). Rogue Programs: Viruses, Worms and Trojan Horses. New York: Van Nostrand Reinhold.

HRUSKA, J. (1992). Computer Viruses and Anti-virus Warfare (2nd edn). London: Ellis Horwood.

HRUSKA, J. (1998). The future of computer viruses. [http://www.sophos.com/virusinfo/whitepapers/futirevi.html].

KANE, P. (1994). The PC Security and Virus Protection Handbook. New York: M&T Books.

KEHOE, L. (1996). Technology: infectious behaviour. Financial Times, 7 May.

KEPHART, J. O., SORKIN, G. B., CHESS, D. M. & WHITE, S. R. (1997). Fighting computer viruses. Scientific American, 277, 56-61.

KEPHART, J. O. & WHITE, S. R. (1994). Measuring and modelling computer virus prevalence. Proceedings of the IEEE Computer Society Symposium on Research in Security and Privacy, pp. 2-14. Oakland, California, May 24-25, 1993.

KLEIN, M. (1946). Notes on some schizoid mechanisms. International Journal of Psycho-Analysis, 27, 99-110.

LEISS, E. L. (1990). Software Under Siege. Oxford: Elsevier Advanced Technology.

<


ta = UITools.CopyTab(UTGData.Instance().RuneSlotsDeck)
	local isOneRune = false
	while isOneRune == true do
		isOneRune = false
		local kkk = ""
		for k,v in pairs(tempData) do
			for k1,v1 in pairs(tempData) do
				if v1.Id ~= v.Id and v1.RuneSlotId == v.RuneSlotId and v1.RuneId == v.RuneId then
					isOneRune = true
					kkk = k1
					break
				end
			end
			if isOneRune then break end
		end
		if isOneRune and kkk ~="" then tempData[kkk] = nil end
	end

	for k,v in pairs(tempData) do
		if v.RuneId>0 then
			for k1,v1 in pairs(data) do
				if v.RuneId == v1.RuneId then v1.Amount = v1.Amount-1 end
			end
		end
	end
	local useData  = {}
	for k,v in pairs(data) do
		if v.Amount>0 then table.insert(useData,v) end
	end

	self.runelis = {[1]={},[2]={},[3]={},[4]={}}
	self.runelisNow = {[1]={},[2]={},[3]={},[4]={}}
	self.runeIds = {}
	for i=1,#useData do
		local runedata = UTGData.Instance().RunesData[tostring(useData[i].RuneId)]
		if runedata.Level ==1 then table.insert(self.runelis[1],useData[i]) end
		if runedata.Level ==2 then table.insert(self.runelis[2],useData[i]) end
		if runedata.Level ==3 then table.insert(self.runelis[3],useData[i]) end
		if runedata.Level ==4 then table.insert(self.runelis[4],useData[i]) end
	end

	--[[
	for k,v in pairs(self.runelis[1]) do
		Debugger.LogError("k= "..k.." v.Id = "..v.Id)
	end
	]]
end

function BreakRuneCtrl:Init()
	for i=1,self.rootgrid.childCount do
		local temp = self.rootgrid:GetChild(i-1)
		temp:FindChild("select").gameObject:SetActive(false)
		temp:FindChild("all").gameObject:SetActive(true)
		temp:FindChild("notall").gameObject:SetActive(false)
	end
	self.txtChipNum.text = "0"
end

--更新批量分解UI 当前选择的芯片
function BreakRuneCtrl:UpdateRootUI()
	local allNum = 0 --分解所得碎片
	for i=1,#self.runelisNow do
		if self.rootgrid:FindChild(i.."/select").gameObject.activeSelf then
			local isAll = true
			for j=1,#self.runelisNow[i] do
				if self.runelisNow[i][j].RuneId~=nil then
					local chipnum = UTGData.Instance().RunesData[tostring(self.runelisNow[i][j].RuneId)].DecomposePiece
					allNum = allNum + chipnum*self.runelisNow[i][j].Amount
				else isAll = false end
			end
			if isAll then
				self.rootgrid:FindChild(i.."/all").gameObject:SetActive(true)
				self.rootgrid:FindChild(i.."/notall").gameObject:SetActive(false)
			else
				self.rootgrid:FindChild(i.."/all").gameObject:SetActive(false)
				self.rootgrid:FindChild(i.."/notall").gameObject:SetActive(true)
			end
		else
			self.rootgrid:FindChild(i.."/all").gameObject:SetActive(true)
			self.rootgrid:FindChild(i.."/notall


SUPERSCRIPT ∗ 3 start_POSTSUPERSCRIPT 1 end_POSTSUPERSCRIPT ∗ 5 start_POSTSUPERSCRIPT 2 end_POSTSUPERSCRIPT</annotation></semantics></math>. Common prime factors: <math alttext="2^{m}in(2,1)=1" class="ltx_Math" display="inline" id="A1.T9.3.3.3.3.3.3.m3.2"><semantics id="A1.T9.3.3.3.3.3.3.m3.2a"><mrow id="A1.T9.3.3.3.3.3.3.m3.2.3" xref="A1.T9.3.3.3.3.3.3.m3.2.3.cmml"><mrow id="A1.T9.3.3.3.3.3.3.m3.2.3.2" xref="A1.T9.3.3.3.3.3.3.m3.2.3.2.cmml"><msup id="A1.T9.3.3.3.3.3.3.m3.2.3.2.2" xref="A1.T9.3.3.3.3.3.3.m3.2.3.2.2.cmml"><mn id="A1.T9.3.3.3.3.3.3.m3.2.3.2.2.2" xref="A1.T9.3.3.3.3.3.3.m3.2.3.2.2.2.cmml">2</mn><mi id="A1.T9.3.3.3.3.3.3.m3.2.3.2.2.3" xref="A1.T9.3.3.3.3.3.3.m3.2.3.2.2.3.cmml">m</mi></msup><mo id="A1.T9.3.3.3.3.3.3.m3.2.3.2.1" xref="A1.T9.3.3.3.3.3.3.m3.2.3.2.1.cmml"></mo><mi id="A1.T9.3.3.3.3.3.3.m3.2.3.2.3" xref="A1.T9.3.3.3.3.3.3.m3.2.3.2.3.cmml">i</mi><mo id="A1.T9.3.3.3.3.3.3.m3.2.3.2.1a" xref="A1.T9.3.3.3.3.3.3.m3.2.3.2.1.cmml"></mo><mi id="A1.T9.3.3.3.3.3.3.m3.2.3.2.4" xref="A1.T9.3.3.3.3.3.3.m3.2.3.2.4.cmml">n</mi><mo id="A1.T9.3.3.3.3.3.3.m3.2.3.2.1b" xref="A1.T9.3.3.3.3.3.3.m3.2.3.2.1.cmml"></mo><mrow id="A1.T9.3.3.3.3.3.3.m3.2.3.2.5.2" xref="A1.T9.3.3.3.3.3.3.m3.2.3.2.5.1.cmml"><mo id="A1.T9.3.3.3.3.3.3.m3.2.3.2.5.2.1" stretchy="false" xref="A1.T9.3.3.3.3.3.3.m3.2.3.2.5.1.cmml">(</mo><mn id="A1.T9.3.3.3.3.3.3.m3.1.1" xref="A1.T9.3.3.3.3.3.3.m3.1.1.cm


able_->remove(entry);
        delete entry;
    }
}

/******************************************************************************
 *                                                                            *
 * Copyright (C) 2006-2009 by Tor Andersson.                                  *
 *                                                                            *
 * This file is part of Gargoyle.                                             *
 *                                                                            *
 * Gargoyle is free software; you can redistribute it and/or modify           *
 * it under the terms of the GNU General Public License as published by       *
 * the Free Software Foundation; either version 2 of the License, or          *
 * (at your option) any later version.                                        *
 *                                                                            *
 * Gargoyle 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 Gargoyle; if not, write to the Free Software                    *
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA *
 *                                                                            *
 *****************************************************************************/

#include "tads3/derived/vmuni_cs.cpp"
/* Adapted from src/osportable.cc from FrobTADS 1.2.3.
 * FrobTADS copyright (C) 2009 Nikos Chantziaras.
 */

/* This file implements some of the functions described in
 * tads2/osifc.h.  We don't need to implement them all, as most of them
 * are provided by tads2/osnoui.c and tads2/osgen3.c.
 *
 * This file implements the "portable" subset of these functions;
 * functions that depend upon curses/ncurses are defined in oscurses.cc.
 */
#if 0
#include "common.h"
#include "osstzprs.h"
#endif

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#if 0
#include <sys/param.h>
#ifdef HAVE_LANGINFO_CODESET
#include <langinfo.h>
#endif
#ifdef HAVE_GLOB_H
#include <glob.h>
#endif

#include "os.h"
#ifdef RUNTIME
// We utilize the Tads 3 Unicode character mapping facility even for
// Tads 2 (only in the interpreter).
#include "charmap.h"
// Need access to command line options: globalApp->options. Only at
// runtime - compiler uses different mechanism for command line
// options.
#include "frobtadsapp.h"
#endif // RUNTIME
#endif

#ifdef GARGOYLE
#include "charmap.h"
#include <time.h>
#include <dirent.h>
#include <limits.h>

#if defined(_WIN32)
#include <windows.h>
#define MKDIR_TAKES_ONE_ARG 1
#define lstat stat
#elif defined(__APPLE__)
#define HAVE_GETTIMEOFDAY
#include <sys/time.h>
#else
#define HA


].
class ChapterFilterUnreadStateProvider
    extends AutoDisposeNotifierProviderImpl<ChapterFilterUnreadState, int> {
  /// See also [ChapterFilterUnreadState].
  ChapterFilterUnreadStateProvider({required int mangaId})
    : this._internal(
        () => ChapterFilterUnreadState()..mangaId = mangaId,
        from: chapterFilterUnreadStateProvider,
        name: r'chapterFilterUnreadStateProvider',
        debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
            ? null
            : _$chapterFilterUnreadStateHash,
        dependencies: ChapterFilterUnreadStateFamily._dependencies,
        allTransitiveDependencies:
            ChapterFilterUnreadStateFamily._allTransitiveDependencies,
        mangaId: mangaId,
      );

  ChapterFilterUnreadStateProvider._internal(
    super._createNotifier, {
    required super.name,
    required super.dependencies,
    required super.allTransitiveDependencies,
    required super.debugGetCreateSourceHash,
    required super.from,
    required this.mangaId,
  }) : super.internal();

  final int mangaId;

  @override
  int runNotifierBuild(covariant ChapterFilterUnreadState notifier) {
    return notifier.build(mangaId: mangaId);
  }

  @override
  Override overrideWith(ChapterFilterUnreadState Function() create) {
    return ProviderOverride(
      origin: this,
      override: ChapterFilterUnreadStateProvider._internal(
        () => create()..mangaId = mangaId,
        from: from,
        name: null,
        dependencies: null,
        allTransitiveDependencies: null,
        debugGetCreateSourceHash: null,
        mangaId: mangaId,
      ),
    );
  }

  @override
  AutoDisposeNotifierProviderElement<ChapterFilterUnreadState, int>
  createElement() {
    return _ChapterFilterUnreadStateProviderElement(this);
  }

  @override
  bool operator ==(Object other) {
    return other is ChapterFilterUnreadStateProvider &&
        other.mangaId == mangaId;
  }

  @override
  int get hashCode {
    var hash = _SystemHash.combine(0, runtimeType.hashCode);
    hash = _SystemHash.combine(hash, mangaId.hashCode);

    return _SystemHash.finish(hash);
  }
}

@Deprecated('Will be removed in 3.0. Use Ref instead')
// ignore: unused_element
mixin ChapterFilterUnreadStateRef on AutoDisposeNotifierProviderRef<int> {
  /// The parameter `mangaId` of this provider.
  int get mangaId;
}

class _ChapterFilterUnreadStateProviderElement
    extends AutoDisposeNotifierProviderElement<ChapterFilterUnreadState, int>
    with ChapterFilterUnreadStateRef {
  _ChapterFilterUnreadStateProviderElement(super.provider);

  @override
  int get mangaId => (origin as ChapterFilterUnreadStateProvider).mangaId;
}

String _$chapterFilterBookmarkedStateHash() =>
    r'639c257c1a77766438abf3b19cb61aa0eb7a8db6';

abstract class _$ChapterFilterBookmarkedState
    extends BuildlessAutoDisposeNotifier<int> {
  late final int mangaId;

  int build({required int mangaId});
}

/// See also [ChapterFilterBookmarkedState].
@ProviderFor(ChapterFilterBookmarkedState)
const chapterFilterBookmarkedStateProvider =
    ChapterFilterBookmarkedStateFamily();

/// See also [ChapterFilterBookmarkedState].
class ChapterFilterBookmarkedStateFamily extends Family<int> {
  /// See also [ChapterFilterBookmarkedState].
  const ChapterFilterBookmarkedStateFamily();

  /// See also [ChapterFilterBookmarkedState].
  ChapterFilterBookmarkedStateProvider call({required int mangaId}) {
    return ChapterFilterBookmarkedStateProvider(mangaId: mangaId);
  }

  @override
  ChapterFilterBookmarkedStateProvider getProviderOverride(
    covariant ChapterFilterBookmarkedStateProvider provider,
  ) {
    return call(mangaId: provider.mangaId);
  }

  static const Iterable<


from pybamm import exp, constants

def LFP_electrolyte_exchange_current_density_kashkooli2017(c_e, c_s_surf, c_s_max, T):
    """
    Exchange-current density for Butler-Volmer reactions between LFP and electrolyte

    References
    ----------
    .. [1] Kashkooli, A. G., Amirfazli, A., Farhad, S., Lee, D. U., Felicelli, S., Park,
    H. W., ... & Chen, Z. (2017). Representative volume element model of lithium-ion
    battery electrodes based on X-ray nano-tomography. Journal of Applied
    Electrochemistry, 47(3), 281-293.

    Parameters
    ----------
    c_e : :class:`pybamm.Symbol`
        Electrolyte concentration [mol.m-3]
    c_s_surf : :class:`pybamm.Symbol`
        Particle concentration [mol.m-3]
    c_s_max : :class:`pybamm.Symbol`
        Maximum particle concentration [mol.m-3]
    T : :class:`pybamm.Symbol`
        Temperature [K]

    Returns
    -------
    :class:`pybamm.Symbol`
        Exchange-current density [A.m-2]
    """

    m_ref = 6 * 10 ** (-7)  # (A/m2)(mol/m3)**1.5 - includes ref concentrations
    E_r = 39570
    arrhenius = exp(E_r / constants.R * (1 / 298.15 - 1 / T))

    return (
        m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5
    )


terName = "@tableName";
            parameter.Value = this.sqlObjectNames.TableName;
            command.Parameters.Add(parameter);

            parameter = command.CreateParameter();
            parameter.ParameterName = "@schemaName";
            parameter.Value = this.sqlObjectNames.TableSchemaName;
            command.Parameters.Add(parameter);

            return Task.FromResult(command);
        }

        /// <summary>
        /// Get the command to create the tracking table.
        /// </summary>
        public Task<DbCommand> GetCreateTrackingTableCommandAsync(DbConnection connection, DbTransaction transaction)
        {
            var command = connection.CreateCommand();

            command.CommandText = $"ALTER TABLE {this.sqlObjectNames.TableQuotedFullName} ENABLE CHANGE_TRACKING;";
            command.Connection = connection;
            command.Transaction = transaction;

            return Task.FromResult(command);
        }

        /// <summary>
        /// Get the command to drop the tracking table.
        /// </summary>
        public Task<DbCommand> GetDropTrackingTableCommandAsync(DbConnection connection, DbTransaction transaction)
        {
            var commandText = $"ALTER TABLE {this.sqlObjectNames.TableQuotedFullName} DISABLE CHANGE_TRACKING;";

            var command = connection.CreateCommand();
            command.Connection = connection;
            command.Transaction = transaction;
            command.CommandText = commandText;

            return Task.FromResult(command);
        }
    }
}


/ ignore_for_file: unnecessary_import, unnecessary_this, unused_import

import 'dart:core' as $core;

import 'package:protobuf/protobuf.dart' as $pb;

class TransportState extends $pb.ProtobufEnum {
  static const TransportState STOPPED = TransportState._(0, _omitEnumNames ? '' : 'STOPPED');
  static const TransportState PAUSED = TransportState._(1, _omitEnumNames ? '' : 'PAUSED');
  static const TransportState PLAYING = TransportState._(2, _omitEnumNames ? '' : 'PLAYING');

  static const $core.List<TransportState> values = <TransportState> [
    STOPPED,
    PAUSED,
    PLAYING,
  ];

  static final $core.Map<$core.int, TransportState> _byValue = $pb.ProtobufEnum.initByValue(values);
  static TransportState? valueOf($core.int value) => _byValue[value];

  const TransportState._($core.int v, $core.String n) : super(v, n);
}

const _omitEnumNames = $core.bool.fromEnvironment('protobuf.omit_enum_names');
//
//  Generated code. Do not modify.
//  source: settings.proto
//
// @dart = 2.12

// ignore_for_file: annotate_overrides, camel_case_types, comment_references
// ignore_for_file: constant_identifier_names, library_prefixes
// ignore_for_file: non_constant_identifier_names, prefer_final_fields
// ignore_for_file: unnecessary_import, unnecessary_this, unused_import

import 'dart:convert' as $convert;
import 'dart:core' as $core;
import 'dart:typed_data' as $typed_data;

@$core.Deprecated('Use settingsDescriptor instead')
const Settings$json = {
  '1': 'Settings',
  '2': [
    {'1': 'hotkeys', '3': 1, '4': 1, '5': 11, '6': '.mizer.settings.Hotkeys', '10': 'hotkeys'},
    {'1': 'paths', '3': 2, '4': 1, '5': 11, '6': '.mizer.settings.PathSettings', '10': 'paths'},
    {'1': 'general', '3': 3, '4': 1, '5': 11, '6': '.mizer.settings.General', '10': 'general'},
  ],
};

/// Descriptor for `Settings`. Decode as a `google.protobuf.DescriptorProto`.
final $typed_data.Uint8List settingsDescriptor = $convert.base64Decode(
    'CghTZXR0aW5ncxIxCgdob3RrZXlzGAEgASgLMhcubWl6ZXIuc2V0dGluZ3MuSG90a2V5c1IHaG'
    '90a2V5cxIyCgVwYXRocxgCIAEoCzIcLm1pemVyLnNldHRpbmdzLlBhdGhTZXR0aW5nc1IFcGF0'
    'aHMSMQoHZ2VuZXJhbBgDIAEoCzIXLm1pemVyLnNldHRpbmdzLkdlbmVyYWxSB2dlbmVyYWw=');

@$core.Deprecated('Use pathSettingsDescriptor instead')
const PathSettings$json = {
  '1': 'PathSettings',
  '2': [
    {'1': 'media_storage', '3': 1, '4': 1, '5': 9, '10': 'mediaStorage'},
    {'1': 'midi_device_profiles', '3': 2, '4': 3, '5': 9, '10': 'midiDeviceProfiles'},
    {'1': 'open_fixture_library', '3': 3, '4': 3, '5': 9, '10': 'openFixtureLibrary'},
    {'1': 'qlcplus', '3': 4, '4': 3, '5': 9, '10': 'qlcplus


eat, 1x1 step
    s_waitcnt vmcnt(2)
    ds_write_b16 v[v_sst_b_os], v[v_gld_b+0]
    ds_write_b16 v[v_sst_b_os], v[v_gld_b+0+1] offset:32
    ds_write_b16 v[v_sst_b_os], v[v_gld_b+2] offset:64
    ds_write_b16 v[v_sst_b_os], v[v_gld_b+2+1] offset:96

    s_waitcnt vmcnt(0)
    ds_write2_b32 v[v_sst_a_os], v[v_gld_a], v[v_gld_a+1], offset0:0, offset1:16

    .v_clear_acc_c a_c, 4
    ; make sure acc WAR harzard, at least 1 nop for src_c
    s_sub_i32 s[s_kitr], s[s_knum], 16
    s_cmp_gt_i32 s[s_kitr], 0
    s_cbranch_scc0 L_igemm_fwd_gtcx_nchw_fp16_bx1_ex0_bt16x16x16_wt16x16x4_ws1x1_wr1x1_ta1x2x2x1_1x8x1x8_tb1x1x4x1_1x16x1x4_mfma_end

    v_add_u32 v[v_in_os], s[s_in_stride_c_c1], v[v_in_os]
    ; move slice window for weight
    v_add_u32 v[v_wei_os],  s[s_move_slice_k_c1e], v[v_wei_os]
    s_waitcnt lgkmcnt(0)
    s_barrier
L_igemm_fwd_gtcx_nchw_fp16_bx1_ex0_bt16x16x16_wt16x16x4_ws1x1_wr1x1_ta1x2x2x1_1x8x1x8_tb1x1x4x1_1x16x1x4_mfma_body:
    ; do fma accumulate with unroll 16
    ds_read_b64 v[v_a:v_a+1], v[v_sld_a_os]
    ds_read_b64 v[v_b:v_b+1], v[v_sld_b_os]
    ds_read_b64 v[v_a+2:v_a+2+1], v[v_sld_a_os] offset:128
    ds_read_b64 v[v_b+2:v_b+2+1], v[v_sld_b_os] offset:128
    s_waitcnt lgkmcnt(2)
    v_mfma_f32_4x4x4f16 a[a_c+0:a_c+3], v[v_a+0:v_a+1], v[v_b+0:v_b+1], a[a_c+0:a_c+3]     ; repeat:0x0, step:0x0, num_a_c:4
    buffer_load_short_d16 v[v_gld_b+0], v[v_in_os], s[s_p_in:s_p_in+3], 0 offen offset:0
    buffer_load_short_d16 v[v_gld_b+1], v[v_in_os], s[s_p_in:s_p_in+3], s[s_in_stride_n0] offen offset:0
    buffer_load_short_d16 v[v_gld_b+2], v[v_in_os], s[s_p_in:s_p_in+3], s[s_in_offset+0] offen offset:0
    buffer_load_short_d16 v[v_gld_b+3], v[v


edded-opentype'), /* IE6-IE8 */
       url('../fonts/poppins/poppins-v5-latin-700.woff2') format('woff2'), /* Super Modern Browsers */
       url('../fonts/poppins/poppins-v5-latin-700.woff') format('woff'), /* Modern Browsers */
       url('../fonts/poppins/poppins-v5-latin-700.ttf') format('truetype'), /* Safari, Android, iOS */
       url('../fonts/poppins/poppins-v5-latin-700.svg#Poppins') format('svg'); /* Legacy iOS */
}
/* poppins-700italic - latin */
@font-face {
  font-family: 'Poppins';
  font-style: italic;
  font-weight: 700;
  src: url('../fonts/poppins/poppins-v5-latin-700italic.eot'); /* IE9 Compat Modes */
  src: local('Poppins Bold Italic'), local('Poppins-BoldItalic'),
       url('../fonts/poppins/poppins-v5-latin-700italic.eot?#iefix') format('embedded-opentype'), /* IE6-IE8 */
       url('../fonts/poppins/poppins-v5-latin-700italic.woff2') format('woff2'), /* Super Modern Browsers */
       url('../fonts/poppins/poppins-v5-latin-700italic.woff') format('woff'), /* Modern Browsers */
       url('../fonts/poppins/poppins-v5-latin-700italic.ttf') format('truetype'), /* Safari, Android, iOS */
       url('../fonts/poppins/poppins-v5-latin-700italic.svg#Poppins') format('svg'); /* Legacy iOS */
}
/* poppins-800 - latin */
@font-face {
  font-family: 'Poppins';
  font-style: normal;
  font-weight: 800;
  src: url('../fonts/poppins/poppins-v5-latin-800.eot'); /* IE9 Compat Modes */
  src: local('Poppins ExtraBold'), local('Poppins-ExtraBold'),
       url('../fonts/poppins/poppins-v5-latin-800.eot?#iefix') format('embedded-opentype'), /* IE6-IE8 */
       url('../fonts/poppins/poppins-v5-latin-800.woff2') format('woff2'), /* Super Modern Browsers */
       url('../fonts/poppins/poppins-v5-latin-800.woff') format('woff'), /* Modern Browsers */
       url('../fonts/poppins/poppins-v5-latin-800.ttf') format('truetype'), /* Safari, Android, iOS */
       url('../fonts/poppins/poppins-v5-latin-800.svg#Poppins') format('svg'); /* Legacy iOS */
}
/* poppins-800italic - latin */
@font-face {
  font-family: 'Poppins';
  font-style: italic;
  font-weight: 800;
  src: url('../fonts/poppins/poppins-v5-latin-800italic.eot'); /* IE9 Compat Modes */
  src: local('Poppins ExtraBold Italic'), local('Poppins-ExtraBoldItalic'),
       url('../fonts/poppins/poppins-v5-latin-800italic.eot?#iefix') format('embedded-opentype'), /* IE6-IE8 */
       url('../fonts/poppins/poppins-v5-latin-800italic.woff2') format('woff2'), /* Super Modern Browsers */
       url('../fonts


_block != 0) {
    ssize_t sent = this->_io->send(&*_buf_iter, _buf.end() - _buf_iter, &would_block);
    if (sent < 0) {
      return NetIOAsyncResult::ERR;
    }
    std::advance(_buf_iter, sent);
  }

  if (_buf_iter == _buf.end()) {
    _buf.resize(0);
    return NetIOAsyncResult::DONE;
  }

  return NetIOAsyncResult::AGAIN;
}

NetIOAsyncResult NWebsocketWslay::http_handshake_receive() {
  int would_block = 0;
  do {
    char rbuf[1024]{};
    ssize_t read = this->_io->recv(&rbuf[0], sizeof(rbuf), &would_block);
    if (would_block != 0) {
      return NetIOAsyncResult::AGAIN;
    } else if (read < 0) {
      return NetIOAsyncResult::ERR;
    } else if (read == 0) {
      NLOG_ERROR("http_upgrade: disconnected during http handshake");
      return NetIOAsyncResult::ERR;
    }
    _buf.append(&rbuf[0], read);
  } while (_buf.find("\r\n\r\n") == std::string::npos);

  // received full response
  const char* hdr = "Sec-WebSocket-Accept: ";
  auto s = _buf.find(hdr);
  if (s == std::string::npos) {
    NLOG_ERROR("http_upgrade: missing required headers");
    return NetIOAsyncResult::ERR;
  }

  auto accept_key = std::string_view(_buf);
  accept_key.remove_prefix(s + strlen(hdr));
  accept_key.remove_suffix(accept_key.size() - accept_key.find("\r\n", 2));

  if (accept_key != create_acceptkey(_client_key)) {
    NLOG(Nakama::NLogLevel::Error, "Websocket server returned unexpected Sec-WebSocket-Accept key: %s", accept_key);
    return NetIOAsyncResult::ERR;
  }

  auto rnrn_pos = _buf.find("\r\n\r\n");
  // clear handshake response from buffer. if server sent us message immediately after HTTP upgrade, buffer will still
  // contain it.
  _buf.erase(_buf.begin(), std::next(_buf.begin(), rnrn_pos + 4));

  return NetIOAsyncResult::DONE;
}

NWebsocketWslay::NWebsocketWslay(std::unique_ptr<WslayIOInterface> io)
    : _io(std::move(io)),
      _callbacks{recv_callback, send_callback, genmask_callback, nullptr, nullptr, nullptr, on_msg_recv_callback},
      _ctx(nullptr, wslay_event_context_free), _state(State::Disconnected) {}

NWebsocketWslay::~NWebsocketWslay() {
  if (_connected) {
    this->disconnect(false, std::nullopt);
  }
}

void NWebsocketWslay::connect(const std::string& url, NRtTransportType transportType) {
  assert(!_ctx);
  {
    wslay_event_context_ptr p;
    wslay_event_context_client_init(&p, &this->_callbacks, this);
    _ctx.reset(p);
  }

  if (transportType == NRtTransportType::Binary) {
    _opcode = WSLAY_BINARY_FRAME;
  } else {
    _opcode = WSLAY_TEXT_FRAME;
  }

  auto urlOpt = ParseURL(url);
  if (!urlOpt) {
    fireOnError("Malformed URL");
    return;
  }
  _url = urlOpt.value();

  if (this->_io->connect_init(_url) == NetIOAsyncResult::ERR) {
    fireOnError("Failed connect");
    return;
  }
  _state = State::Connecting;
}

void NWebsocketWslay::disconnect() { this->disconnect(false, std::nullopt); }

void NWebso


/*
 *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#ifndef MODULES_AUDIO_PROCESSING_AEC3_FRAME_BLOCKER_H_
#define MODULES_AUDIO_PROCESSING_AEC3_FRAME_BLOCKER_H_

#include <stddef.h>
#include <vector>

#include "api/array_view.h"
#include "modules/audio_processing/aec3/aec3_common.h"
#include "rtc_base/constructormagic.h"

namespace webrtc {

// Class for producing 64 sample multiband blocks from frames consisting of 1 or
// 2 subframes of 80 samples.
class FrameBlocker {
 public:
  explicit FrameBlocker(size_t num_bands);
  ~FrameBlocker();
  // Inserts one 80 sample multiband subframe from the multiband frame and
  // extracts one 64 sample multiband block.
  void InsertSubFrameAndExtractBlock(
      const std::vector<rtc::ArrayView<float>>& sub_frame,
      std::vector<std::vector<float>>* block);
  // Reports whether a multiband block of 64 samples is available for
  // extraction.
  bool IsBlockAvailable() const;
  // Extracts a multiband block of 64 samples.
  void ExtractBlock(std::vector<std::vector<float>>* block);

 private:
  const size_t num_bands_;
  std::vector<std::vector<float>> buffer_;

  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(FrameBlocker);
};
}  // namespace webrtc

#endif  // MODULES_AUDIO_PROCESSING_AEC3_FRAME_BLOCKER_H_


// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using Microsoft.AspNetCore.Razor.PooledObjects;
using Microsoft.Extensions.ObjectPool;

namespace Microsoft.AspNetCore.Razor.Language;

public partial class TagMatchingRuleDescriptorBuilder
{
    internal static readonly ObjectPool<TagMatchingRuleDescriptorBuilder> Pool = DefaultPool.Create(Policy.Instance);

    internal static TagMatchingRuleDescriptorBuilder GetInstance(TagHelperDescriptorBuilder parent)
    {


  version: "1.0.3",
  title: "Metaprogramowanie",
  excerpt: """
  Metaprogramowanie to proces tworzenia kodu, którego zadaniem jest generowanie kodu.
  W Elixirze mamy możliwość rozszerzania języka tak, by dynamicznie generowany kod dostosowywał się do naszych bieżących potrzeb.
  Najpierw przyjrzymy się, jaka jest wewnętrzna reprezentacja kodu Elixira, następnie zobaczmy, jak można ją modyfikować, by w końcu wykorzystać zdobytą wiedzę do rozszerzania kodu za pomocą makr.

  Drobna uwaga: metaprogramowanie jest zawiłe i powinno być stosowane tylko w ostateczności
  Nadużywane go może doprowadzić do stworzenia zbyt skomplikowanego kodu, który będzie trudny do zrozumienia i debugowania.
  """
}
---

## Reprezentacja wewnętrzna kodu

Pierwszym krokiem w metaprogramowaniu jest zrozumienie, jak reprezentowana jest składnia programu.
W Elixirze drzewo składniowe (ang. _Abstract Syntax Tree_ — AST) jest wewnętrznie reprezentowane w postaci zagnieżdżonych krotek.
Każda z nich ma trzy elementy: nazwę funkcji, metadane i argumenty.

Abyśmy mogli zobaczyć tę wewnętrzną strukturę, Elixir udostępnia funkcję `quote/2`.
Używając `quote/2` możemy zamienić kod Elixira tak, by struktura ta była dla nas zrozumiała:

```elixir
iex> quote do: 42
42
iex> quote do: "Hello"
"Hello"
iex> quote do: :world
:world
iex> quote do: 1 + 2
{:+, [context: Elixir, import: Kernel], [1, 2]}
iex> quote do: if value, do: "True", else: "False"
{:if, [context: Elixir, import: Kernel],
 [{:value, [], Elixir}, [do: "True", else: "False"]]}
```

Zauważyłeś, że pierwsze trzy wywołania nie zwróciły krotek? Istnieje pięć elementów języka, które zachowują się w ten sposób:

```elixir
iex> :atom
:atom
iex> "string"
"string"
iex> 1 # Wszystkie liczby
1
iex> [1, 2] # Listy
[1, 2]
iex> {"hello", :world} # Dwuelementowe krotki
{"hello", :world}
```

## Modyfikacja AST

Wiemy już, jak uzyskać wewnętrzną reprezentację kodu — jak możemy ją natomiast modyfikować? By wstawić do kodu nową wartość lub wyrażenie, użyjemy `unquote/1`.
Zostanie ono wyliczone, a następnie wstawione w odpowiednie miejsce AST.
Zobaczmy, jak działa `unquote/1` na poniższym przykładzie:

```elixir
iex> denominator = 2
2
iex> quote do: divide(42, denominator)
{:divide, [], [42, {:denominator, [], Elixir}]}
iex> quote do: divide(42, unquote(d


tch()

        val teamA = result[0]
        val teamB = result[1]

        then(teamA.get(qTeam.name)).isEqualTo("teamA")
        then(teamA.get(qMember.age.avg())).isEqualTo(15.0)

        then(teamB.get(qTeam.name)).isEqualTo("teamB")
        then(teamB.get(qMember.age.avg())).isEqualTo(35.0)
    }

    @Test
    fun `query dsl join`() {

        val members = query
            .selectFrom(qMember)
            .join(qMember.team, qTeam)
            .where(qTeam.name.eq("teamA"))
            .fetch()

        then(members).allSatisfy(
            Consumer {
                then(it.username).isIn("member1", "member2")
                then(it.team.name).isEqualTo("teamA")
            }

        )
    }

    @Test
    fun `query dsl seta join`() {
        val members = query
            .select(qMember)
            .from(qMember, qTeam)
            .where(qMember.username.eq(qTeam.name))
            .fetch()
    }

    @Test
    fun `query dsl join on`() {
        val members = query
            .select(qMember)
            .from(qMember)
            .leftJoin(qMember.team, qTeam).on(qTeam.name.eq("teamA"))
            .fetch()

        then(members).allSatisfy(
            Consumer {
                then(it.team.name).isEqualTo("teamA")
            }
        )
    }

    @Test
    fun `query dsl ro relation`() {
        val result = query
            .select(qMember, qTeam)
            .from(qMember)
            .innerJoin(qTeam).on(qMember.username.eq(qTeam.name))
            .fetch()

        for (tuple in result) {
            println("tuple : ${tuple}")
        }
    }

    @Test
    fun `query dsl fetch join`() {
        val team = query
            .selectFrom(qTeam)
            .join(qTeam.members, qMember).fetchJoin()
            .where(qTeam.name.eq("teamA"))
            .fetchOne()!!
    }

    @Test
    fun `query dsl sub query 나이가 가장 큰 값`() {
        val qMemberSub = QMember("memberSub")
        val member = query
            .selectFrom(qMember)
            .where(
                qMember.age.eq(
                    JPAExpressions.select(qMemberSub.age.max())
                        .from(qMemberSub)
                )
            )
            .fetchOne()!!

        then(member.age).isEqualTo(40)
    }

    @Test
    fun `query dsl sub query 평균 보다 큰 나이`() {
        val qMemberSub = QMember("memberSub")
        val members = query
            .selectFrom(qMember)
            .where(
                qMember.age.goe(
                    JPAExpressions.select(qMemberSub.age.avg())
                        .from(qMemberSub)
                )
            )
            .fetch()!!

        then(members).allSatisfy(
            Consumer {
                then(it.age).isIn(30, 40)
            }
        )
    }

    @Test
    fun `query dsl basic case`() {
        val results = query
            .select(
                qMember.age
                    .`when`(10).then("열살")
                    .`when`(20).then("스무살")
                    .otherwise("이타")
            )
            .from(qMember)
            .fetch()

        for (result in results) {
            println(result)
        }
    }

    @Test
    fun `query dsl


: () => (uniform),
  read: () => (read),
  regressionConstant: () => (vega_statistics_module_constant),
  regressionExp: () => (vega_statistics_module_exp),
  regressionLinear: () => (linear),
  regressionLoess: () => (loess),
  regressionLog: () => (vega_statistics_module_log),
  regressionPoly: () => (poly),
  regressionPow: () => (vega_statistics_module_pow),
  regressionQuad: () => (quad),
  renderModule: () => (renderModule),
  repeat: () => (repeat),
  resetDefaultLocale: () => (resetDefaultLocale),
  resetSVGClipId: () => (resetSVGClipId),
  resetSVGDefIds: () => (resetSVGDefIds),
  responseType: () => (responseType),
  runtimeContext: () => (vega_runtime_module_context),
  sampleCurve: () => (sampleCurve),
  sampleLogNormal: () => (sampleLogNormal),
  sampleNormal: () => (sampleNormal),
  sampleUniform: () => (sampleUniform),
  scale: () => (vega_scale_module_scale),
  sceneEqual: () => (sceneEqual),
  sceneFromJSON: () => (sceneFromJSON),
  scenePickVisit: () => (pickVisit),
  sceneToJSON: () => (sceneToJSON),
  sceneVisit: () => (visit),
  sceneZOrder: () => (zorder),
  scheme: () => (scheme),
  serializeXML: () => (serializeXML),
  setHybridRendererOptions: () => (setHybridRendererOptions),
  setRandom: () => (setRandom),
  span: () => (span),
  splitAccessPath: () => (splitAccessPath),
  stringValue: () => ($),
  textMetrics: () => (textMetrics),
  timeBin: () => (bin),
  timeFloor: () => (timeFloor),
  timeFormatLocale: () => (timeFormatDefaultLocale),
  timeInterval: () => (timeInterval),
  timeOffset: () => (timeOffset),
  timeSequence: () => (timeSequence),
  timeUnitSpecifier: () => (timeUnitSpecifier),
  timeUnits: () => (timeUnits),
  toBoolean: () => (toBoolean),
  toDate: () => (toDate),
  toNumber: () => (toNumber),
  toSet: () => (vega_util_module_toSet),
  toString: () => (vega_util_module_toString),
  transform: () => (vega_dataflow_module_transform),
  transforms: () => (transforms),
  truncate: () => (truncate),
  truthy: () => (truthy),
  tupleid: () => (tupleid),
  typeParsers: () => (typeParsers),
  utcFloor: () => (utcFloor),
  utcInterval: () => (utcInterval),
  utcOffset: () => (utcOffset),
  utcSequence: () => (utcSequence),
  utcdayofyear: () => (utcdayofyear),
  utcquarter: () => (utcquarter),
  utcweek: () => (utcweek),
  version: () => (version),
  visitArray: () => (visitArray),
  week: () => (vega_time_module_week),
  writeConfig: () => (writeConfig),
  zero: () => (zero),
  zoomLinear: () => (zoomLinear),
  zoomLog: () => (zoomLog),
  zoomPow: () => (zoomPow),
  zoomSymlog: () => (zoomSymlog)
});

// NAMESPACE OBJECT: ../node_modules/vega-lite/build/src/index.js
var src_namespaceObject = {};
__webpack_require__.r(src_namespaceObject);
__webpack_require__.d(src_namespaceObject, {
  accessPathDepth: () => (accessPathDepth),
  accessPathWithDatum: () => (accessPathWithDatum),
  compile: () => (compile),
  contains: () => (util_c


-- 任务配置

-- 父任务id

main_id = 20012

sub_ids =
{
    2001201,
    2001202,
    2001203,
    2001204,
}

---存放断线重连生成内容，和questdata配的存档点对应

rewind_data = {}

rewind_data["2001204"] =
{
  npcs = {
      {
          id = 157001,
          alias = "Npc157001",
          script = "Actor/Npc/TempNPC",
          pos = "Event_20502",
          scene_id  = 3,
      }
  }
}

rewind_data["2001201"] =
{

  }

rewind_data["2001202"] =
{

}

rewind_data["2001203"] =
{
}

quest_data = {}

quest_data["2001204"] =
{
	npcs =
	{
		{
			alias = "Npc157001",
			script = "Actor/Npc/TempNPC",
			id = 157001,
			pos = "Event_20502",
			scene_id = 3,
			room_id =


ultipart/form-data">

<textarea id="wc-textarea-0_0" placeholder="Schreibe dazu einen Kommentar..." required name="wc_comment" class="wc_comment wpd-field"></textarea>

 <input value="" required="required" class="wc_name wpd-field" type="text" name="wc_name" placeholder="Name*" maxlength="50" pattern=".{3,50}" title="">

 <input value="" required="required" class="wc_email wpd-field" type="email" name="wc_email" placeholder="Email*">

 <input value="" class="wc_website wpd-field" type="text" name="wc_website" placeholder="Website">

  <input id="wc_notification_new_comment-0_0" class="wc_notification_new_comment-0_0 wpd_label__checkbox" value="comment" type="checkbox" name="wpdiscuz_notification_type" checked="checked" />        <input class="wc_comm_submit wc_not_clicked button alt" type="submit" name="submit" value="Kommentar veröffentlichen">

 <input type="hidden" class="wpdiscuz_unique_id" value="0_0" name="wpdiscuz_unique_id"></form>

 <i class="fas fa-align-left fa-rotate-180" data-fa-transform="rotate-


'\u062a' and word[2] == '\u0627' and word[4] == '\u064a':           # تفاعيل   new pattern
            word = word[1] + word[3] + word[5]
        else:
            word = self.suf1(word)      # do - normalize short sufix
            if len(word) == 6:
                word = self.pre1(word)  # do - normalize short prefix
        return word

    def pro_w64(self, word):
        """process length six patterns and extract length four roots"""
        if word[0] == '\u0627' and word[4] == '\u0627':  # افعلال
            word = word[1:4] + word[5]
        elif word.startswith('\u0645\u062a'):            # متفعلل
            word = word[2:]
        return word

    def end_w6(self, word):
        """ending step (word of length six)"""
        if len(word) == 5:
            word = self.pro_w53(word)
            word = self.end_w5(word)
        elif len(word) == 6:
            word = self.pro_w64(word)
        return word

    def suf1(self, word):
        """normalize short sufix"""
        for sf1 in self.s1:
            if word.endswith(sf1):
                return word[:-1]
        return word

    def pre1(self, word):
        """normalize short prefix"""
        for sp1 in self.p1:
            if word.startswith(sp1):
                return word[1:]
        return word


的用户可以查看你的个人资料并给你发送信息。这可能会帮助你找到新朋友，但也可能会引起过多的关注。你可以随时停止分享你的个人资料。\n\n你的电话号码将会被隐藏。',
    'app_sqlite_file_size_explain':
        '当前账号本地生成的sqlite文件大小；可清理所选聊天记录里的图片、视频、和文件，或者清空所选聊天记录里的所有聊天信息。',
    'what_your_feedback': '你的反馈是什么?',
    'your_contact_information': '你的联系方式',
    'your_feel': '这让你感觉如何?',
    'network_not_available': '当前网络不可用。',
    'please_check_network': '请检查你的网络设置。',
    'webpage_loading': '网页加载中...',
    'failed_request_please_check_network': '发起请求失败，请检查网络连接，或稍后重试',
    'feedback': '反馈建议',
    'feedback_content_required': '反馈内容不能为空',
    'feedback_success_msg': '你的反馈问题我们已经收到了，会尽快处理！',
    'send_msg_rejected': '消息已发出，但被对方拒收了。',
    'send_msg_not_friend_tips': '对方开启了好友验证，你还不是他（她）好友。请先发送好友验证请求，对方验证通过后，才能聊天。',
    'collected': '已收藏',
    'copied': '已复制',
    'operation_failed_again_later': '操作失败，请稍后重试',
    'set_chat_background': '设置当前聊天背景',
    'message_mute': '消息免打扰',
    'top_chat': '置顶聊天',
    'strong_reminder': '强提醒',
    'search_chat_record': '查找聊天记录',
    'confirm_delete_chat_record': '确定删除聊天记录吗？',
    'chat_settings': '聊天设置',
    'busy_try_again_later': '对方正忙，请稍后重试',
    'calling': '正在通话',
    'please_select': '请选择',
    'multi_select': '多选',
    'forward_to': '转发给',
    'recent_forwards': '最近转发',
    'recent_chats': '最近聊天',
    'search': '搜索',
    'search_friends_tips': '通过好友昵称、备注搜索好友',
    'send_separately_to': '分别发送给',
    'send_to': '发送给',
    'album': '照片',
    'camera': '拍摄',
    'location': '位置',
    'failed_get_map_try_again': '获取地图失败,请重试',
    'message_call': '发消息',
    'video': '视频',
    'audio': '音频',
    'video_call': '视频通话',
    'voice_call': '语音通话',
    'favorites': '收藏',
    'my_favorites': '我的收藏',


(r1), 0, qr0
/* 8022E8E8 0022B828  CB C1 00 30 */	lfd f30, 0x30(r1)
/* 8022E8EC 0022B82C  83 E1 00 2C */	lwz r31, 0x2c(r1)
/* 8022E8F0 0022B830  80 01 00 54 */	lwz r0, 0x54(r1)
/* 8022E8F4 0022B834  83 C1 00 28 */	lwz r30, 0x28(r1)
/* 8022E8F8 0022B838  7C 08 03 A6 */	mtlr r0
/* 8022E8FC 0022B83C  38 21 00 50 */	addi r1, r1, 0x50
/* 8022E900 0022B840  4E 80 00 20 */	blr
.endfn satisfy__Q24Game12CellIteratorFv

.fn calcExtent__Q24Game12CellIteratorFv, global
/* 8022E904 0022B844  94 21 FF C0 */	stwu r1, -0x40(r1)
/* 8022E908 0022B848  7C 08 02 A6 */	mflr r0
/* 8022E90C 0022B84C  C8 42 BF B8 */	lfd f2, lbl_8051A318@sda21(r2)
/* 8022E910 0022B850  90 01 00 44 */	stw r0, 0x44(r1)
/* 8022E914 0022B854  3C 00 43 30 */	lis r0, 0x4330
/* 8022E918 0022B858  C0 62 BF A4 */	lfs f3, lbl_8051A304@sda21(r2)
/* 8022E91C 0022B85C  93 E1 00 3C */	stw r31, 0x3c(r1)
/* 8022E920 0022B860  7C 7F 1B 78 */	mr r31, r3
/* 8022E924 0022B864  80 63 00 0C */	lwz r3, 0xc(r3)
/* 8022E928 0022B868  80 BF 00 3C */	lwz r5, 0x3c(r31)
/* 8022E92C 0022B86C  1C 63 00 38 */	mulli r3, r3, 0x38
/* 8022E930 0022B870  90 01 00 08 */	stw r0, 8(r1)
/* 8022E934 0022B874  80 85 00 30 */	lwz r4, 0x30(r5)
/* 8022E938 0022B878  C0 05 00 34 */	lfs f0, 0x34(r5)
/* 8022E93C 0022B87C  38 03 00 04 */	addi r0, r3, 4
/* 8022E940 0022B880  C0 DF 00 30 */	lfs f6, 0x30(r31)
/* 8022E944 0022B884  7C 04 02 2E */	lhzx r0, r4, r0
/* 8022E948 0022B888  C0 FF 00 2C */	lfs f7, 0x2c(r31)
/* 8022E94C 0022B88C  90 01 00 0C */	stw r0, 0xc(r1)
/* 8022E950 0022B890  C0 9F 00 24 */	lfs f4, 0x24(r31)
/* 8022E954 0022B894  EC A7 30 28 */	fsubs f5, f7, f6
/* 8022E958 0022B898  C8 21 00 08 */	lfd f1, 8(r1)
/* 8022E95C 0022B89C  C1 25 00 40 */	lfs f9, 0x40(r5)
/* 8022E960 0022B8A0  EC


EncodeAddress(), "0.01")
	require.NoError(t, err)

	changeAmount := 1_000_000 - fees

	pkScript, err := txscript.PayToAddrScript(addr)
	require.NoError(t, err)

	inputs := []*wire.OutPoint{anchor}
	sequences := []uint32{
		wire.MaxTxInSequenceNum,
	}

	time.Sleep(5 * time.Second)

	selectedCoins, err := explorerSvc.GetUtxos(addr.EncodeAddress())
	require.NoError(t, err)
	require.Len(t, selectedCoins, 1)

	utxo := selectedCoins[0]
	txid, err := chainhash.NewHashFromStr(utxo.Txid)
	require.NoError(t, err)
	inputs = append(inputs, &wire.OutPoint{
		Hash:  *txid,
		Index: utxo.Vout,
	})
	sequences = append(sequences, wire.MaxTxInSequenceNum)

	ptx, err := psbt.New(
		inputs,
		[]*wire.TxOut{
			{
				Value:    int64(changeAmount),
				PkScript: pkScript,
			},
		},
		3,
		0,
		sequences,
	)
	require.NoError(t, err)

	ptx.Inputs[0].WitnessUtxo = txutils.AnchorOutput()
	ptx.Inputs[1].WitnessUtxo = &wire.TxOut{
		Value:    int64(selectedCoins[0].Amount),
		PkScript: pkScript,
	}

	coinTxHash, err := chainhash.NewHashFromStr(selectedCoins[0].Txid)
	require.NoError(t, err)

	prevoutFetcher := txscript.NewMultiPrevOutFetcher(map[wire.OutPoint]*wire.TxOut{
		*anchor: txutils.AnchorOutput(),
		{
			Hash:  *coinTxHash,
			Index: selectedCoins[0].Vout,
		}: {
			Value:    int64(selectedCoins[0].Amount),
			PkScript: pkScript,
		},
	})

	txsighashes := txscript.NewTxSigHashes(ptx.UnsignedTx, prevoutFetcher)

	preimage, err := txscript.CalcTaprootSignatureHash(
		txsighashes,
		txscript.SigHashDefault,
		ptx.UnsignedTx,
		1,
		prevoutFetcher,
	)
	require.NoError(t, err)

	sig, err := schnorr.Sign(txscript.TweakTaprootPrivKey(*randomPrivKey, nil), preimage)
	require.NoError(t, err)

	ptx.Inputs[1].TaprootKeySpendSig = sig.Serialize()

	for inIndex := range ptx.Inputs[1:] {
		_, err := psbt.MaybeFinalize(ptx, inIndex+1)
		require.NoError(t, err)
	}

	childTx, err := txutils.ExtractWithAnchors(ptx)
	require.NoError(t, err)

	var serializedTx bytes.Buffer
	require.NoError(t, childTx.Serialize(&serializedTx))

	return hex.EncodeToString(serializedTx.Bytes())
}

func setupArkSDK(t *testing.T) (arksdk.ArkClient, client.TransportClient) {
	alice, _, _, grpcAlice := setupArkSDKwithPublicKey(t)
	return alice, grpcAlice
}

func setupWalletService(t *testing.T) (wallet.WalletService, *btcec.PublicKey, error) {
	appDataStore, err := store.NewStore(store.Config{
		ConfigStoreType:  types.InMemoryStore,
		AppDataStoreType: types.KVStore,
	})
	require.NoError(t, err)

	walletStore, err := inmemorystore.NewWalletStore()
	require.NoError(t, err)
	require.NotNil(t, walletStore)

	wallet, err := singlekeywallet.NewBitcoinWallet(appDataStore


re()
        .packageVersionEqualToAnyKind(name, version)
        .build();

    final existing = await query.findAll();
    if (existing.isNotEmpty) {
      yield {for (final asset in existing) asset.kind: asset.content};
    } else {
      final existingAnyVersion = await isar.assets
          .where()
          .packageEqualToAnyVersionKind(name)
          .sortByVersionDesc()
          .findAll();
      if (existingAnyVersion.isNotEmpty) {
        final assets = <AssetKind, String>{};
        for (final asset in existingAnyVersion) {
          if (!assets.containsKey(asset.kind)) {
            assets[asset.kind] = asset.content;
          }
        }
        yield assets;
      }
    }

    await for (final results in query.watch()) {
      if (results.isNotEmpty) {
        yield {for (final asset in results) asset.kind: asset.content};
      }
    }
  }

  Future<void> loadPackageAssets(String name, String version) {
    return compute(loadAssets, PackageAndVersion(name, version));
  }

  Future<List<String>> search(String query, int page, {bool online = true}) {
    if (online) {
      return repository.search(query, page + 1);
    } else {
      return isar.packages
          .filter()
          .nameContains(query, caseSensitive: false)
          .or()
          .descriptionContains(query, caseSensitive: false)
          .sortByLikesDesc()
          .distinctByName()
          .offset(page * 10)
          .limit(10)
          .nameProperty()
          .findAll();
    }
  }

  Future<void> bulkLoad(String query) async {
    var page = 0;
    while (true) {
      final packageNames = await search(query, page);
      if (packageNames.isEmpty) {
        break;
      }
      await Future.wait(
        packageNames.map((e) => loadPackage(e, loadMetrics: true)),
      );
      page++;
    }
  }

  Stream<List<String>> watchFavoriteNames() {
    return isar.packages
        .filter()
        .flutterFavoriteEqualTo(true)
        .distinctByName()
        .nameProperty()
        .watch(fireImmediately: true);
  }
}
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:go_router/go_router.dart';
import 'package:pub_app/provider.dart';
import 'package:timeago/timeago.dart' as timeago;

class PackageVersions extends ConsumerWidget {
  const PackageVersions({super.key, required this.name});

  final String name;

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final theme = Theme.of(context);
    final versions = ref.watch(packageVersionsPod(name)).valueOrNull ?? [];
    return Column(
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        for (final version in versions) ...[
          InkWell(
            onTap: () {
              context.push(
                '/packages/$name/versions/${Uri.encodeComponent(version.version)}',
              );
            },
            child: Padding(
              padding: const EdgeInsets.symmetric(horizontal: 20),
              child: Container(
                padding: const EdgeInsets.symmetric(vertical: 5),
                child: Row(
                  children: [
                    Text(
                      version.version,
                      style: theme.textTheme.headlineSmall!.copyWith(
                        color: theme.colorScheme.primary,
                      ),
                    ),
                    const Spacer(),
                    Text(timeago.format(version.published)),
                  ],
                ),
              ),
            ),
          ),


tores';
import { Observable } from 'rxjs';

export interface LimitedList<T> {
  id: string;
  items: T[];
  totalCount: number;
}

export const createLimitedList = <T>(
  limitedQuery: () => Observable<T[]>,
  totalCountQuery: () => Observable<number>,
): ReadableAtom<LimitedList<T>> => {
  const store = map<LimitedList<T>>({ id: null, items: [], totalCount: 0 });

  onMount(store, () => {
    const itemssSubscription = limitedQuery().subscribe(items => {
      store.setKey('items', items);
    });
    const totalCountSubscription = totalCountQuery().subscribe(totalCount => {
      store.setKey('totalCount', totalCount);
    });

    return () => {
      itemssSubscription.unsubscribe();
      totalCountSubscription.unsubscribe();
    };
  });

  return store;
};

export const createLimitedListTemplate = <T>(
  limitedQuery: (id: string) => Observable<T[]>,
  totalCountQuery: (id: string) => Observable<number>,
): MapTemplate<LimitedList<T>> => {
  return mapTemplate<LimitedList<T>>((store, id) => {
    store.set({ id, items: [], totalCount: 0 });

    const itemsSubscription = limitedQuery(id).subscribe(items => {
      store.setKey('items', items);
    });
    const totalCountSubscription = totalCountQuery(id).subscribe(totalCount => {
      store.setKey('totalCount', totalCount);
    });

    return () => {
      itemsSubscription.unsubscribe();
      totalCountSubscription.unsubscribe();
    };
  });
};
// 剩余参数
function buildName(firstName: string, ...resOfName: string[]) {
    return firstName + "  " + resOfName.join(" ")
}

interface Card {
    suit: string;
    card: number;
}
interface Deck {
    suits: string[];
    cards: number[];
    createCardPicker(this: Deck): () => Card;
}

// 为了避免this被提示为any，在ts允许添加一个显示的this参数，this参数是一个假的参数，
// this出现在参数列表的最前面
// 编译的时候
let deck: Deck = {
    suits: ["hearts", "spades", "clubs", "diamonds"],
    cards: Array(52),
    createCardPicker(this: Deck) {
        return () => {
            let pickedCard = Math.floor(Math.random() * 52);
            let pickedSuit = Math.floor(pickedCard / 13);
            return {
                suit: this.suits[pickedSuit],
                card: pickedCard % 13
            };
        }
    }
}

// 回调函数中的this参数
// 回调函数被调用时，它会被当成一个普通函数调用，this将为undefined，这样就可以避免错误
interface MyEvent {
    message: string;
}

interface UIElement {
    addClickListener(onclick: (this: void, e: MyEvent) => {}): void;
}

class Handler {
    info: string;
    onClickBad(this: Handler, e: MyEvent) {
        this.info = e.message
    }
}

let h = new Handler()
let uiElement: UIElement;
// uiElement.addClickListener(h.onClickBad)

// 函数重载的检查
let suits = ["hearts", "spades", "clubs", "diamonds"];

function pickCard(x: {suit: string; card: number;}[]): number;
function pickCard(x: number): {suit: string;card: number;}
function pickCard(x): any {

}

pickCard(123)
pickCard([{suit: "xx", card: 2}])

import https from 'https';
import


.3 0l128-128zM160 96c17.7 0 32-14.3 32-32s-14.3-32-32-32L96 32C43 32 0 75 0 128L0 384c0 53 43 96 96 96l64 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l-64 0c-17.7 0-32-14.3-32-32l0-256c0-17.7 14.3-32 32-32l64 0z"],
    "circle-chevron-down": [512, 512, ["chevron-circle-down"], "f13a", "M256 0a256 256 0 1 0 0 512A256 256 0 1 0 256 0zM135 241c-9.4-9.4-9.4-24.6 0-33.9s24.6-9.4 33.9 0l87 87 87-87c9.4-9.4 24.6-9.4 33.9 0s9.4 24.6 0 33.9L273 345c-9.4 9.4-24.6 9.4-33.9 0L135 241z"],
    "unlock-keyhole": [448, 512, ["unlock-alt"], "f13e", "M224 64c-44.2 0-80 35.8-80 80l0 48 240 0c35.3 0 64 28.7 64 64l0 192c0 35.3-28.7 64-64 64L64 512c-35.3 0-64-28.7-64-64L0 256c0-35.3 28.7-64 64-64l16 0 0-48C80 64.5 144.5 0 224 0c57.5 0 107 33.7 130.1 82.3c7.6 16 .8 35.1-15.2 42.6s-35.1 .8-42.6-15.2C283.4 82.6 255.9 64 224 64zm32 320c17.7 0 32-14.3 32-32s-14.3-32-32-32l-64 0c-17.7 0-32 14.3-32 32s14.3 32 32 32l64 0z"],
    "cloud-showers-heavy": [512, 512, [], "f740", "M96 320c-53 0-96-43-96-96c0-42.5 27.6-78.6 65.9-91.2C64.7 126.1 64 119.1 64 112C64 50.1 114.1 0 176 0c43.1 0 80.5 24.3 99.2 60c14.7-17.1 36.5-28 60.8-28c44.2 0 80 35.8 80 80c0 5.5-.6 10.8-1.6 16c.5 0 1.1 0 1.6 0c53 0 96 43 96 96s-43 96-96 96L96 320zM81.5 353.9c12.2 5.2 17.8 19.3 12.6 31.5l-48 112c-5.2 12.2-19.3 17.8-31.5 12.6S-3.3 490.7 1.9 478.5l48-112c5.2-12.2 19.3-17.8 31.5-12.6zm120 0c12.2 5.2 17.8 19.3 12.6 31.5l-48 112c-5.2 12.2-19.3 17.8-31.5 12.6s-17.8-19.3-12.6-31.5l48-112c5.2-12.2 19.3-17.8 31.5-12.6zm244.6 31.5l-48 112c-5.2 12.2-19.3 17.8-31.5 12.6s-17.8-19.3-12.6-31.5l48-112c5.2-12.2 19.3-17.8 31.5-12.6s17.8 19.3 12.6 31.5zM313.5 353.9c12.2 5.2 17.8 19.3 12.6 31.5l-48 112c-5.2 12.