STR,
        ClassNameSize: DWORD,
        RequiredSize: PDWORD,
        MachineName: PCSTR,
        Reserved: PVOID,
    ) -> BOOL;
    pub fn SetupDiClassNameFromGuidExW(
        ClassGuid: *const GUID,
        ClassName: PWSTR,
        ClassNameSize: DWORD,
        RequiredSize: PDWORD,
        MachineName: PCWSTR,
        Reserved: PVOID,
    ) -> BOOL;
    pub fn SetupDiClassGuidsFromNameA(
        ClassName: PCSTR,
        ClassGuidList: LPGUID,
        ClassGuidListSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupDiClassGuidsFromNameW(
        ClassName: PCWSTR,
        ClassGuidList: LPGUID,
        ClassGuidListSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupDiClassGuidsFromNameExA(
        ClassName: PCSTR,
        ClassGuidList: LPGUID,
        ClassGuidListSize: DWORD,
        RequiredSize: PDWORD,
        MachineName: PCSTR,
        Reserved: PVOID,
    ) -> BOOL;
    pub fn SetupDiClassGuidsFromNameExW(
        ClassName: PCWSTR,
        ClassGuidList: LPGUID,
        ClassGuidListSize: DWORD,
        RequiredSize: PDWORD,
        MachineName: PCWSTR,
        Reserved: PVOID,
    ) -> BOOL;
    pub fn SetupDiGetHwProfileFriendlyNameA(
        HwProfile: DWORD,
        FriendlyName: PSTR,
        FriendlyNameSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupDiGetHwProfileFriendlyNameW(
        HwProfile: DWORD,
        FriendlyName: PWSTR,
        FriendlyNameSize: DWORD,
        RequiredSize: PDWORD,
    ) -> BOOL;
    pub fn SetupDiGetHwProfileFriendlyNameExA(
        HwProfile: DWORD,
        FriendlyName: PSTR,
        FriendlyNameSize: DWORD,
        RequiredSize: PDWORD,
        MachineName: PCSTR,
        Reserved: PVOID,
    ) -> BOOL;
    pub fn SetupDiGetHwProfileFriendlyNameExW(
        HwProfile: DWORD,
        FriendlyName: PWSTR,
        FriendlyNameSize: DWORD,
        RequiredSize: PDWORD,
        MachineName: PCWSTR,
        Reserved: PVOID,
    ) -> BOOL;
}
pub const SPWPT_SELECTDEVICE: DWORD = 0x00000001;
pub const SPWP_USE_DEVINFO_DATA: DWORD = 0x00000001;
extern "system" {
    pub fn SetupDiGetWizardPage(
        DeviceInfoSet: HDEVINFO,
        DeviceInfoData: PSP_DEVINFO_DATA,
        InstallWizardData: PSP_INSTALLWIZARD_DATA,
        PageType: DWORD,
        Flags: DWORD,
    ) -> HPROPSHEETPAGE;
    pub fn SetupDiGetSelectedDevice(
        DeviceInfoSet: HDEVINFO,
        DeviceInfoData: PSP_DEVINFO_DATA,
    ) -> BOOL;
    pub fn SetupDiSetSelectedDevice(
        DeviceInfoSet: HDEVINFO,
        DeviceInfoData: PSP_DEVINFO_DATA,
    ) -> BOOL;
    pub fn SetupDiGetActualModelsSectionA(
        Context: PINFCONTEXT,
        AlternatePlatformInfo: PSP_ALTPLATFORM_INFO,
        InfSectionWithExt: PSTR,
        InfSectionWithExtSize: DWORD,
        RequiredSize: PDWORD,
        Reserved: PVOID,
    ) -> BOOL;
    pub fn SetupDiGetActualModelsSectionW(
        Context: PINFCONTEXT,
        AlternatePlatformInfo: PSP_ALTPLATFORM_


width, s.minWidth, s.maxWidth)
//         }
//         if (Ext.isNumber(s.height)) {
//             s.height = Ext.Number.constrain(s.height, s.minHeight, s.maxHeight)
//         }
//         if (s.width !== null || s.height !== null) {
//             s.target.setSize(s.width, s.height)
//         }
//         t = s.el.dom.tagName.toUpperCase();
//         if (t === "TEXTAREA" || t === "IMG" || t === "TABLE") {
//             s.originalTarget = s.target;
//             c = h.isComponent ? h.getEl() : h;
//             s.el.addCls(s.wrappedCls);
//             s.target = s.el = s.el.wrap({
//                 role: "presentation",
//                 cls: s.wrapCls,
//                 id: s.el.id + "-rzwrap",
//                 style: c.getStyle(["margin-top", "margin-bottom"])
//             });
//             d = c.getPositioning();
//             s.el.setPositioning(d);
//             c.clearPositioning();
//             j = c.getBox();
//             if (d.position !== "absolute") {
//                 j.x = 0;
//                 j.y = 0
//             }
//             s.el.setBox(j);
//             c.setStyle("position", "absolute");
//             s.isTargetWrapped = true
//         }
//         s.el.position();
//         if (s.pinned) {
//             s.el.addCls(s.pinnedCls)
//         }
//         s.resizeTracker = new Ext.resizer.ResizeTracker({
//             disabled: s.disabled,
//             target: h,
//             el: s.el,
//             constrainTo: s.constrainTo,
//             handleCls: s.handleCls,
//             overCls: s.overCls,
//             throttle: s.throttle,
//             proxy: s.originalTarget ? s.el : null,
//             dynamic: s.originalTarget ? true : s.dynamic,
//             originalTarget: s.originalTarget,
//             delegate: "." + s.handleCls,
//             preserveRatio: s.preserveRatio,
//             heightIncrement: s.heightIncrement,
//             widthIncrement: s.widthIncrement,
//             minHeight: s.minHeight,
//             maxHeight: s.maxHeight,
//             minWidth: s.minWidth,
//             maxWidth: s.maxWidth
//         });
//         s.resizeTracker.on({
//             mousedown: s.onBeforeResize,
//             drag: s.onResize,
//             dragend: s.onResizeEnd,
//             scope: s
//         });
//         if (s.handles === "all") {
//             s.handles = "n s e w ne nw se sw"
//         }
//         a = s.handles = s.handles.split(s.delimiterRe);
//         b = s.possiblePositions;
//         p = a.length;
//         l = s.handleCls + " " + s.handleCls + "-{0}";
//         if (s.target.isComponent) {
//             e = s.target.baseCls;
//             l += " " + e + "-handle " + e + "-handle-{0}";
//             if (Ext.supports.CSS3BorderRadius) {
//                 l += " " + e + "-handle-{0}-br"
//             }
//         }
//         for (o = 0; o < p; o++) {
//             q = a[o];
//             if (q && b[q]) {
//                 g = b[q];
//                 k = s[g] = s.el.createChild({
//                     id: s.el.id + "-" + g + "-handle",
//                     cls: Ext.String.format(l, g) + " " + m,


.unitInfo.length - 1; i >= 0; i--) {
									var unit = _self.defaultPage.SYSTEM.unitInfo[i];
									if(unit.id == good.unitId){
										good.mainUnit = unit.name;
										good.unitName = unit.name;
									}
								};
							}
							if(good['delete'] && effective){
								defaultPage.Public.tips({type:2 , content:'该商品已经被禁用！'});
								return {};
							}
							//_self.goodsInfo.push(good);
							if(typeof callback === 'function'){
								callback(good);
							}
							return good;
						}else{
							//_self.defaultPage.Public.tips({type: 1, content : data.msg});
						}
					}
				})
				.done(function() {
					//console.log("success");
				})
				.fail(function() {
					console.log("error");
				})
				.always(function() {
					console.log("complete");
				});
			},
			getGoodsInfoByNumber:function(number, callback,effective){
				this.getGoodInfo({
					action:'queryByMatchCon',
					matchCon:number
				},callback, effective);
			},
			getGoodsInfoByBarCode:function(barCode, callback,effective){
				this.getGoodInfo({
					action:'queryByBarcode',
					barCode:barCode
				},callback, effective);
			}
		}
		Business.serNumManage = function(opts){
			var parentTr = opts.row,
			data = opts.data,
			serNumUsedList = opts.serNumUsedList,

			creatable = opts.creatable,
			enableStorage = opts.enableStorage,
			view = opts.view,
			$grid = parentTr.closest('table'),
			defaultPage = Public.getDefaultPage();

			var oldData = {
				goodsInfo: parentTr.data('goodsInfo'),
				storageInfo : parentTr.data('storageInfo') || {},
				unitInfo : parentTr.data('unitInfo')||{}
			}
			if(!view){
				//非查询模式
				$grid.jqGrid("restoreCell", curRow, curCol);
				parentTr.data('goodsInfo', null).data('storageInfo', null).data('unitInfo', null);
			}
			var params = {
				width: 650,
				height: 400,
				title: (serNumUsedList ? '修改' : '录入') + '【'+data.name+'】的序列号',
				content: 'url:/settings/serNumBatch.jsp',
				data: {
					invId: data.id,
					creatable:creatable,
					enableStorage : enableStorage,
					serNumUsedList : serNumUsedList,
					storageInfo : oldData.storageInfo || {},
					view : view,
					callback: function(serNumList,win){
						var curID = THISPAGE.curID;
						$grid.jqGrid("restoreCell", curRow, curCol);
						//根据仓库分组
						var storageList = {};
						if(!$.isArray(serNumList)){
							var _serNumList = [];
							for(var item in serNumList){
								_serNumList.push(serNumList[item]);
							}
							serNumList = _serNumList;
						}
						for (var i = 0; i < serNumList.length; i++) {
							var locationId = serNumList[i].locationId || -1;
							storageList[locationId] = storageList[locationId] || [];
							storageList[locationId].push(serNumList[i]);
						};
						for(item in storageList){
							var serNums = storageList[item];
							var addId = curID || THISPAGE.newId;
							if(curID) {
								$('#'+curID).data('goodsInfo', null).data('storageInfo',n


 true;
      const appearEvent = new CustomEvent<IntersectionObserverEntry>('appear', {
        detail: entry,
      });
      el.dispatchEvent(appearEvent);
    } else if (el.appeared) {
      delete el.appeared;
      const disappearEvent = new CustomEvent<IntersectionObserverEntry>(
        'disappear',
        { detail: entry },
      );
      el.dispatchEvent(disappearEvent);
    }
  });
}

function getObserving(options?: IntersectionObserverInit) {
  const serialized = serializeIntersectionObserverOptions(options);
  const observing = observingCollection[serialized];
  if (observing) {
    return observing;
  }
  const intersectionObserver = new IntersectionObserver(
    intersectionObserverCallback,
    options,
  );
  const newObserving = {
    serializedOptions: serialized,
    intersectionObserver,
    elements: [],
  };
  observingCollection[serialized] = newObserving;
  return newObserving;
}

export function observe(el: Element, options?: IntersectionObserverInit): void {
  if (!el) {
    return;
  }
  const observing = getObserving(options);
  if (observing.elements.indexOf(el) === -1) {
    observing.intersectionObserver.observe(el);
    observing.elements.push(el);
  }
}

export function unobserve(
  el: Element,
  options?: IntersectionObserverInit,
): void {
  if (!el) {
    return;
  }
  // strict observing retrieving
  const observing = getObserving(options);
  const { elements, intersectionObserver, serializedOptions } = observing;
  if (elements.indexOf(el) !== -1) {
    intersectionObserver.unobserve(el);
    elements.splice(elements.indexOf(el), 1);
    if (!elements.length) {
      intersectionObserver.disconnect();
      delete observingCollection[serializedOptions];
    }
  }
}
import {Prop, Vue} from 'vue-property-decorator';

export default abstract class Lightable extends Vue {
  @Prop({type: String, required: true}) readonly stroke!: string;
  @Prop({type: String, required: true}) readonly outFill!: string;
  @Prop({type: String, required: true}) readonly litFill!: string;
  @Prop({type: Boolean, default: true}) readonly lit!: boolean;

  get fill() {
    return this.lit ? this.litFill : this.outFill;
  }
}
import {
  PDFArray,
  PDFContext,
  PDFDict,
  PDFName,
  PDFPageLeaf,
  PDFPageTree,
  PDFRef,
} from 'src/index';

describe(`PDFPageLeaf`, () => {
  it(`can be constructed directly from a Map and PDFContext`, () => {
    const context = PDFContext.create();
    const dict = new Map();
    const pageTree = PDFPageLeaf.fromMapWithContext(dict, context);

    expect(pageTree).toBeInstanceOf(PDFPageLeaf);
    expect(pageTree.get(PDFName.of('Type'))).toBeUndefined();
    expect(pageTree.get(PDFName.of('Kids'))).toBeUndefined();
    expect(pageTree.get(PDFName.of('Count'))).toBeUndefined();
    expect(pageTree.get(PDFName.of('Parent'))).toBeUndefined();
  });

  it(`is constructed with the correct Type and entries`, () => {
    const context = PDFContext.create();
    const parentRef = PDFRef.of(1);
    const pageTree = PDFPageLeaf.withContextAndParent(context, parentRef);

    expect(pageTree).toBeInstanceOf(PDFPageLeaf);
    expect(pageTree.get(PDFName.of('Type'))).toBe(PDFName.of('Page'));
    expect(pageTree.get(PDFName.of('Parent'))).toBe(parentRef);
    expect(p


 without alloc */
/* Remove the ugly comments by controlling the output! */
/* Write tests for the variable name lengths */
//
// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Official repository: https://github.com/boostorg/beast
//
// This is a derivative work based on Zlib, copyright below:
/*
    Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler

    This software is provided 'as-is', without any express or implied
    warranty.  In no event will the authors be held liable for any damages
    arising from the use of this software.

    Permission is granted to anyone to use this software for any purpose,
    including commercial applications, and to alter it and redistribute it
    freely, subject to the following restrictions:

    1. The origin of this software must not be misrepresented; you must not
       claim that you wrote the original software. If you use this software
       in a product, an acknowledgment in the product documentation would be
       appreciated but is not required.
    2. Altered source versions must be plainly marked as such, and must not be
       misrepresented as being the original software.
    3. This notice may not be removed or altered from any source distribution.

    Jean-loup Gailly        Mark Adler
    jloup@gzip.org          madler@alumni.caltech.edu

    The data format used by the zlib library is described by RFCs (Request for
    Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950
    (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).
*/

#ifndef BOOST_BEAST_ZLIB_ZLIB_HPP
#define BOOST_BEAST_ZLIB_ZLIB_HPP

#include <boost/beast/core/detail/config.hpp>
#include <cstdint>
#include <cstdlib>

namespace boost {
namespace beast {
namespace zlib {

#if !defined(__MACTYPES__)
using Byte = unsigned char; // 8 bits
#endif
using uInt = unsigned int;  // 16 bits or more

/* Possible values of the data_type field (though see inflate()) */
enum kind
{
    binary    = 0,
    text      = 1,
    unknown   = 2
};

/** Deflate codec parameters.

    Objects of this type are filled in by callers and provided to the
    deflate codec to define the input and output areas for the next
    compress or decompress operation.

    The application must update next_in and avail_in when avail_in has dropped
    to zero.  It must update next_out and avail_out when avail_out has dropped
    to zero.  The application must initialize zalloc, zfree and opaque before
    calling the init function.  All other fields are set by the compression
    library and must not be updated by the application.

    The fields total_in and total_out can be used for statistics or progress
    reports.  After compression, total_in holds the total size of the
    uncompressed data and may be saved for use in the decompressor (particularly
    if the decompressor wants to decompress everything in a single step).
*/
struct z_params
{
    /** A pointer to the next input byte.

        If there is no more input, this may be set to `nullptr`.
    */
    void const* next_in;

    /** The number of bytes of input available at `next_in`.

        If there is no more input, this should be set to zero.
    */
    std::size_t avail_in;

    /** The total number of input bytes read so far.
    */
    std::size_t total_in = 0;

    /** A pointer to the next output byte.
    */
    void* next_out;

    /** The remaining bytes of space at `next_out`.
    */
    std::size_t avail_out;

    /** The tota


 := receiverTapTree.Proof(
		senderAsset.TapCommitmentKey(),
		senderAsset.AssetCommitmentKey(),
	)
	require.NoError(t, err)

	// The sender gets the transfer root, so we also need to the stxo
	// exclusion proofs.
	senderSTXOAsset, err := asset.MakeSpentAsset(
		senderAsset.PrevWitnesses[0],
	)
	require.NoError(t, err)
	_, senderSTXOExclusionProof, err := receiverTapTree.Proof(
		senderSTXOAsset.TapCommitmentKey(),
		senderSTXOAsset.AssetCommitmentKey(),
	)
	require.NoError(t, err)

	senderSTXOID := asset.ToSerialized(senderSTXOAsset.ScriptKey.PubKey)
	senderSTXOProofs := make(map[asset.SerializedKey]commitment.Proof, 1)
	senderSTXOProofs[senderSTXOID] = *senderSTXOExclusionProof

	_, receiverExclusionProof, err := senderTapTree.Proof(
		receiverAsset.TapCommitmentKey(),
		receiverAsset.AssetCommitmentKey(),
	)
	require.NoError(t, err)

	senderParams := proof.TransitionParams{
		BaseProofParams: proof.BaseProofParams{
			Block: &wire.MsgBlock{
				Header:       *blockHeader,
				Transactions: []*wire.MsgTx{spendTx},
			},
			BlockHeight:      2,
			Tx:               spendTx,
			TxIndex:          0,
			OutputIndex:      0,
			InternalKey:      &state.spenderPubKey,
			TaprootAssetRoot: senderTapTree,
			ExclusionProofs: []proof.TaprootProof{{
				OutputIndex: 1,
				InternalKey: &state.receiverPubKey,
				CommitmentProof: &proof.CommitmentProof{
					Proof:      *senderExclusionProof,
					STXOProofs: senderSTXOProofs,
				},
			}},
		},
		NewAsset: senderAsset,
	}

	receiverParams := proof.TransitionParams{
		BaseProofParams: proof.BaseProofParams{
			Block: &wire.MsgBlock{
				Header:       *blockHeader,
				Transactions: []*wire.MsgTx{spendTx},
			},
			BlockHeight:      3,
			Tx:               spendTx,
			TxIndex:          0,
			OutputIndex:      1,
			InternalKey:      &state.receiverPubKey,
			TaprootAssetRoot: receiverTapTree,
			ExclusionProofs: []proof.TaprootProof{{
				OutputIndex: 0,
				InternalKey: &state.spenderPubKey,
				CommitmentProof: &proof.CommitmentProof{
					Proof: *receiverExclusionProof,
				},
			}},
		},
		NewAsset:             receiverAsset,
		RootOutputIndex:      0,
		RootInternalKey:      &state.spenderPubKey,
		RootTaprootAssetTree: senderTapTree,
	}

	return []proof.TransitionParams{senderParams, receiverParams}
}

// TestProofVerify tests that a split spend can be used to append to a
// proof file and produce a valid updated proof file.
func TestProofVerify(t *testing.T) {
	t.Parallel()

	state := initSpendScenario(t)

	// Create a proof for the genesis of asset 2.
	createGenesisProof(t, &state)

	genesisProofFile, err := proof.NewFile(
		proof.V0, state.asset2GenesisProof,
	)
	require.NoError(t, err)

	var b bytes.Buffer
	err = genesisProofFile.Encode(&b)
	require.NoError(t, err)
	genesisProofBlob := b.Bytes()

	// Add a PrevID to represent our fake genesis TX.
	genesisOutPoint := &wire.


python
class ColoredConsoleHandler(logging.StreamHandler):
    """带颜色的控制台日志处理器"""
    COLORS = {
        'DEBUG': Fore.CYAN,
        'INFO': Fore.GREEN,
        'WARNING': Fore.YELLOW,
        'ERROR': Fore.RED,
        'CRITICAL': Fore.RED + Style.BRIGHT,
    }

class ProgressLogger:
    """带进度的日志记录器"""
    def step(self, message: str = ""):
        self.current_step += 1
        progress = (self.current_step / self.total_steps) * 100
        self.logger.info(f"[{progress:.1f}%] {message}")
```

### 4. 包安装配置 (setup.py)

**安装特性:**
- **pip安装支持**: 开发模式(`pip install -e .`)和正式安装
- **系统命令注册**: 自动创建系统可执行命令
- **依赖管理**: 自动安装所需的8个核心依赖
- **跨平台兼容**: 支持Python 3.8-3.12和多操作系统

**入口点配置:**
```python
entry_points={
    "console_scripts": [
        "star-summary=cli.main:cli",
        "star-summary-tools=cli.commands:tools",
    ],
},
```

## 📊 功能验证

### 验证脚本 (verify_task5.py)

**测试覆盖范围:**
1. ✅ CLI工具安装测试 (pip安装、命令注册)
2. ✅ CLI帮助系统测试 (8个命令的帮助文档)
3. ✅ CLI参数验证测试 (无效参数处理)
4. ✅ init命令测试 (配置文件创建、内容验证)
5. ✅ status命令测试 (系统状态检查)
6. ✅ dry-run功能测试 (预览模式显示)
7. ✅ 工具命令测试 (缓存管理、模板管理)
8. ✅ 日志功能测试 (文件日志、控制台输出)
9. ✅ 错误处理测试 (配置文件不存在、权限错误)

**测试结果:** 9/9项测试全部通过 ✅

## 🎨 用户体验设计

### 1. 视觉界面
```bash
🌟 GitHub 星标项目分类整理工具

使用示例:
$ star-summary generate --format both --max-repos 10
📡 正在获取星标项目...
🏷 正在分类项目...
📝 正在生成文档...
✅ 成功生成 10 个项目的分类文档
```

### 2. 帮助系统
- **层次化帮助**: 主命令 → 子命令 → 选项详情
- **emoji图标**: 增强视觉识别和用户体验
- **使用示例**: 每个命令都包含清晰的使用说明
- **错误提示**: 友好的错误信息和建议

### 3. 交互特性
- **进度条显示**: 长时间操作的实时进度
- **彩色输出**: 不同级别信息的颜色区分
- **预览模式**: 安全的操作预览功能
- **详细模式**: 开发者友好的详细日志

## 📈 性能指标

| 指标 | 数值 |
|------|------|
| CLI命令总数 | 8个 |
| 代码总行数 | ~


XT ·mulGFNI_5x8_64Xor(SB), $8-88
	// Loading 22 of 40 tables to registers
	// Destination kept in GP registers
	// Full registers estimated 50 YMM used
	MOVQ            n+80(FP), AX
	MOVQ            matrix_base+0(FP), CX
	SHRQ            $0x06, AX
	TESTQ           AX, AX
	JZ              mulGFNI_5x8_64Xor_end
	VBROADCASTF32X2 (CX), Z0
	VBROADCASTF32X2 8(CX), Z1
	VBROADCASTF32X2 16(CX), Z2
	VBROADCASTF32X2 24(CX), Z3
	VBROADCASTF32X2 32(CX), Z4
	VBROADCASTF32X2 40(CX), Z5
	VBROADCASTF32X2 48(CX), Z6
	VBROADCASTF32X2 56(CX), Z7
	VBROADCASTF32X2 64(CX), Z8
	VBROADCASTF32X2 72(CX), Z9
	VBROADCASTF32X2 80(CX), Z10
	VBROADCASTF32X2 88(CX), Z11
	VBROADCASTF32X2 96(CX), Z12
	VBROADCASTF32X2 104(CX), Z13
	VBROADCASTF32X2 112(CX), Z14
	VBROADCASTF32X2 120(CX), Z15
	VBROADCASTF32X2 128(CX), Z16
	VBROADCASTF32X2 136(CX), Z17
	VBROADCASTF32X2 144(CX), Z18
	VBROADCASTF32X2 152(CX), Z19
	VBROADCASTF32X2 160(CX), Z20
	VBROADCASTF32X2 168(CX), Z21
	MOVQ            in_base+24(FP), AX
	MOVQ            (AX), DX
	MOVQ            24(AX), BX
	MOVQ            48(AX), SI
	MOVQ            72(AX), DI
	MOVQ            96(AX), AX
	MOVQ            out_base+48(FP), R8
	MOVQ            out_base+48(FP), R8
	MOVQ            (R8), R9
	MOVQ            24(R8), R10
	MOVQ            48(R8), R11
	MOVQ            72(R8), R12
	MOVQ            96(R8), R13
	MOVQ            120(R8), R14
	MOVQ            144(R8), R15
	MOVQ            168(R8), R8
	MOVQ            start+72(FP), BP

	// Add start offset to output
	ADDQ BP, R9
	ADDQ BP, R10
	ADDQ BP, R11
	ADDQ BP, R12
	ADDQ BP, R13
	ADDQ BP, R14
	ADDQ BP, R15
	ADDQ BP, R8

	// Add start offset to input
	ADDQ BP, DX
	ADDQ BP, BX
	ADDQ BP, SI
	ADDQ BP, DI
	ADDQ BP, AX

	// Reload length to save a register
	MOVQ n+80(FP), BP
	SHRQ $0x06, BP

mulGFNI_5x8_64Xor_loop:
	// Load 8 outputs
	VMOVDQU64 (R9), Z22
	VMOVDQU64 (R10), Z23
	VMOVDQU64 (R11), Z24
	VMOVDQU64 (R12), Z25
	VMOVDQU64 (R13), Z26
	VM


: dBInstanceCount.toString(),
      if (reservedDBInstanceId != null)
        'ReservedDBInstanceId': reservedDBInstanceId,
      if (tags != null)
        if (tags.isEmpty)
          'Tags': ''
        else
          for (var i1 = 0; i1 < tags.length; i1++)
            for (var e3 in tags[i1].toQueryMap().entries)
              'Tags.Tag.${i1 + 1}.${e3.key}': e3.value,
    };
    final $result = await _protocol.send(
      $request,
      action: 'PurchaseReservedDBInstancesOffering',
      version: '2014-10-31',
      method: 'POST',
      requestUri: '/',
      exceptionFnMap: _exceptionFns,
      resultWrapper: 'PurchaseReservedDBInstancesOfferingResult',
    );
    return PurchaseReservedDBInstancesOfferingResult.fromXml($result);
  }

  /// You might need to reboot your DB cluster, usually for maintenance reasons.
  /// For example, if you make certain modifications, or if you change the DB
  /// cluster parameter group associated with the DB cluster, reboot the DB
  /// cluster for the changes to take effect.
  ///
  /// Rebooting a DB cluster restarts the database engine service. Rebooting a
  /// DB cluster results in a momentary outage, during which the DB cluster
  /// status is set to rebooting.
  ///
  /// Use this operation only for a non-Aurora Multi-AZ DB cluster.
  ///
  /// For more information on Multi-AZ DB clusters, see
  /// Multi-AZ DB cluster deployments in the Amazon RDS User Guide.
  ///
  /// May throw [DBClusterNotFoundFault].
  /// May throw [InvalidDBClusterStateFault].
  /// May throw [InvalidDBInstanceStateFault].
  ///
  /// Parameter [dBClusterIdentifier] :
  /// The DB cluster identifier. This parameter is stored as a lowercase string.
  ///
  /// Constraints:
  ///
  ///

  ///

  /// Must match the identifier of an existing DBCluster.
  ///

  ///

  Future<RebootDBClusterResult> rebootDBCluster({
    required String dBClusterIdentifier,
  }) async {
    final $request = <String, String>{
      'DBClusterIdentifier': dBClusterIdentifier,
    };
    final $result = await _protocol.send(
      $request,
      action: 'RebootDBCluster',
      version: '2014-10-31',
      method: 'POST',
      requestUri: '/',
      exceptionFnMap: _exceptionFns,
      resultWrapper: 'RebootDBClusterResult',
    );
    return RebootDBClusterResult.fromXml($result);
  }

  /// You might need to reboot your DB instance, usually for maintenance
  /// reasons. For example, if you make certain modifications, or if you change
  /// the DB parameter group associated with the DB instance, you must reboot
  /// the instance for the changes to take effect.
  ///
  /// Rebooting a DB instance restarts the database engine service. Rebooting a
  /// DB instance results in a momentary outage, during which the DB instance
  /// status is set to rebooting.
  ///
  /// For more information about rebooting, see Rebooting
  /// a DB Instance in the Amazon RDS User Guide.
  ///
  /// This command doesn't apply to RDS Custom.
  ///
  /// If your DB instance is part of a Multi-AZ DB cluster, you can reboot the
  /// DB cluster with the RebootDBCluster operation.
  ///
  /// May throw [InvalidDBInstanceState


        return;
      }

      // 直接映射，无需转换
      const targetPath = replacePathVariables(mapping.target_path, userConfig, result);
      createOrUpdatePath(result, targetPath, userValue, {
        conflict_strategy: mapping.conflict_strategy
      });

      // 处理依赖项
      if (mapping.dependencies && Array.isArray(mapping.dependencies)) {
        mapping.dependencies.forEach(dep => {
          // 检查是否应该覆盖已存在的值
          if (dep.override_if_exists === false) {
            const existingValue = getValueByPath(result, dep.target_path);
            if (existingValue !== undefined) {
              return;
            }
          }

          // 应用依赖项值
          createOrUpdatePath(result, dep.target_path, dep.value, {
            conflict_strategy: 'override'
          });
        });
      }
    } catch (error) {
      logger.error(`应用映射规则 ${mapping.user_path} -> ${mapping.target_path} 失败: ${error.message}`);
    }
  });

  return result;
}

/**
 * 评估条件表达式
 * @param {String} condition 条件表达式
 * @param {*} value 要评估的值
 * @returns {Boolean} 条件是否满足
 */
function evaluateCondition(condition, value) {
  if (!condition) return false;

  try {
    // 简单的条件评估，支持 value === true, value === false 等
    const expr = condition.replace(/value/g, JSON.stringify(value));
    return eval(expr);
  } catch (error) {
    logger.error(`评估条件失败: ${condition}, 错误: ${error.message}`);
    return false;
  }
}

/**
 * 在对象中递归替换变量
 * @param {Object} obj 要处理的对象
 * @param {Object} data 变量数据源
 * @param {Object} targetConfig 目标配置（可选，用于查找已存在的值）
 * @returns {Object} 处理后的对象
 */
function replaceObjectVariables(obj, data, targetConfig = null) {
  if (typeof obj !== 'object' || obj === null) {
    return obj;
  }

  if (Array.isArray(obj)) {
    return obj.map(item => replaceObjectVariables(item, data, targetConfig));
  }

  const result = {};
  for (const [key, value] of Object.entries(obj)) {
    if (typeof value === 'string' && value.includes('{') && value.includes('}')) {
      const replacedValue = replacePathVariables(value, data, targetConfig);

      if (key === 'server_port' || key === 'listen_port' || key === 'port') {
        const numValue = Number(replacedValue);
        result[key] = isNaN(numValue) ? replacedValue : numValue;
      } else if (key === 'disabled' || key === 'timestamp') {
        // 对于布尔字段，进行布尔转换
        if (replacedValue === 'true') {
          result[key] = true;
        } else if (replacedValue === 'false') {
          result[key] = false;
        } else {
          result[key] = Boolean(replacedValue);
        }
      } else if (key === 'output') {
        // 对于日志输出路径，确保目录存在
        try {
          const fs = require('fs');
          const path = require('path');
          if (replacedValue && typeof replacedValue === 'string') {
            const logDir = path.dirname(replacedValue);
            if (!fs.existsSync(logDir)) {
              fs.mkdirSync(logDir, { recursive: true });


f2 + 4.0F - 9.765625E-4F), (double)(f24 + 8.0F)).tex((f21 + 0.0F) * 0.00390625F + f16, (f22 + 8.0F) * 0.00390625F + f17).color(f3, f4, f5, 0.8F).normal(0.0F, 1.0F, 0.0F).endVertex();
							vertexbuffer.pos((double)(f23 + 8.0F), (double)(f2 + 4.0F - 9.765625E-4F), (double)(f24 + 8.0F)).tex((f21 + 8.0F) * 0.00390625F + f16, (f22 + 8.0F) * 0.00390625F + f17).color(f3, f4, f5, 0.8F).normal(0.0F, 1.0F, 0.0F).endVertex();
							vertexbuffer.pos((double)(f23 + 8.0F), (double)(f2 + 4.0F - 9.765625E-4F), (double)(f24 + 0.0F)).tex((f21 + 8.0F) * 0.00390625F + f16, (f22 + 0.0F) * 0.00390625F + f17).color(f3, f4, f5, 0.8F).normal(0.0F, 1.0F, 0.0F).endVertex();
							vertexbuffer.pos((double)(f23 + 0.0F), (double)(f2 + 4.0F - 9.765625E-4F), (double)(f24 + 0.0F)).tex((f21 + 0.0F) * 0.00390625F + f16, (f22 + 0.0F) * 0.00390625F + f17).color(f3, f4, f5, 0.8F).normal(0.0F, 1.0F, 0.0F).endVertex();
						}

						if (l1 > -1)
						{
							for (int k1 = 0; k1 < 8; ++k1)
							{
								vertexbuffer.pos((double)(f23 + (float)k1 + 0.0F), (double)(f2 + 0.0F), (double)(f24 + 8.0F)).tex((f21 + (float)k1 + 0.5F) * 0.00390625F + f16, (f22 + 8.0F) * 0.00390625F + f17).color(f25, f26, f27, 0.8F).normal(-1.0F, 0.0F, 0.0F).endVertex();
								vertexbuffer.pos((double)(f23 + (float)k1 + 0.0F), (double)(f2 + 4.0F), (double)(f24 + 8.0F)).tex((f21 + (float)k1 + 0.5F) * 0.00390625F + f16, (f22 + 8.0F) * 0.00390625F + f17).color(f25, f26, f27, 0.8F).normal(-1.0F, 0.0F, 0.0F).endVertex();
								vertexbuffer.pos((double)(f23 + (float)k1 + 0.0F), (double)(f2 + 4.0F), (double)(f24 + 0.0F)).tex((f21 + (float)k1 + 0.5F) * 0.00390625F + f16, (f22 + 0.0F) * 0.00390625F + f17).color(f25, f26, f27, 0.8F).normal(-1.0F, 0.0F, 0.0F).endVertex();
								vertexbuffer.pos((double)(f23 + (float)k1 + 0.0F), (double)(f2 + 0.0F), (double)(f24 + 0.0F)).tex((f21 + (float)k1 + 0.5F) * 0.00390625F + f16, (f22 + 0.0F) * 0.00390625F + f17).color(f25, f26, f27, 0.8


alToMountChildrenIntoHandler() const noexcept;

 private:
  void InitializeComponentView(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept;

  ViewPropsFactory m_propsFactory;
  ViewShadowNodeFactory m_shadowNodeFactory;
  ViewShadowNodeCloner m_shadowNodeCloner;
  InitialStateDataFactory m_initialStateDataFactory;
  winrt::Microsoft::ReactNative::MeasureContentHandler m_measureContent;
  winrt::Microsoft::ReactNative::LayoutHandler m_layoutHandler;
  ComponentViewFeatures m_features{ComponentViewFeatures::Default};
  std::function<winrt::Microsoft::ReactNative::ComponentView(
      const IReactContext &reactContext,
      int32_t tag,
      const Experimental::ICompositionContext &context,
      ComponentViewFeatures features,
      ReactCompositionViewComponentBuilder &builder)>
      m_fnCreateView;
  std::function<facebook::react::ComponentDescriptorConstructor *()> m_descriptorConstructorFactory;
  winrt::Microsoft::ReactNative::HandleCommandDelegate m_customCommandHandler;
  winrt::Microsoft::ReactNative::UpdateFinalizerDelegate m_finalizeUpdateHandler;
  winrt::Microsoft::ReactNative::UpdatePropsDelegate m_updatePropsHandler;
  winrt::Microsoft::ReactNative::UpdateStateDelegate m_updateStateHandler;
  winrt::Microsoft::ReactNative::UpdateEventEmitterDelegate m_updateEventEmitterHandler;
  winrt::Microsoft::ReactNative::MountChildComponentViewDelegate m_mountChildComponentViewHandler;
  winrt::Microsoft::ReactNative::UnmountChildComponentViewDelegate m_unmountChildComponentViewHandler;

  winrt::Microsoft::ReactNative::Composition::CreateVisualDelegate m_createVisualHandler;
  winrt::Microsoft::ReactNative::Composition::Experimental::IVisualToMountChildrenIntoDelegate
      m_visualToMountChildrenIntoHandler;
  UpdateLayoutMetricsDelegate m_updateLayoutMetricsHandler;
};

} // namespace winrt::Microsoft::ReactNative::Composition


org/pdf/2211.12860.pdf)] [[🤗 Huggingface Model](https://huggingface.co/zongzhuofan)]

## News

* ***[04/22/2024]*** We release a new MLLM framework [MoVA](https://github.com/TempleX98/MoVA), which adopts Co-DETR as the vision and achieves state-of-the-art performance on multimodal benchmarks.
* ***[10/19/2023]*** Our SOTA model Co-DETR w/ ViT-L is released now. Please refer to [our huggingface page](https://huggingface.co/zongzhuofan) for more details.
* ***[09/10/2023]*** We release LVIS inference configs and a stronger LVIS detector that achieves **64.5 box AP**.
* ***[08/21/2023]*** Our O365 pre-trained Co-DETR with Swin-L achieves **64.8 AP** on COCO test-dev. The config and weights are released.
* ***[07/20/2023]*** Code for Co-DINO is released: **55.4 AP** with ResNet-50 and **60.7 AP** with Swin-L.
* ***[07/14/2023]*** Co-DETR is accepted to ICCV 2023!
* ***[07/12/2023]*** We finetune Co-DETR on LVIS and achieve the best results **without TTA**: **72.0 box AP** and **59.7 mask AP** on LVIS minival, **68.0 box AP** and **56.0 mask AP** on LVIS val. For instance segmentation, we report the performance of the auxiliary mask branch.
* ***[07/03/2023]*** Co-DETR with [ViT-L](https://github.com/baaivision/EVA/tree/master/EVA-02) **(304M parameters)** sets a new record of <strike>65.6</strike> **66.0 AP** on COCO test-dev, surpassing the previous best model [InternImage-G](https://github.com/OpenGVLab/InternImage) **(~3000M parameters)**. It is the **first model to exceed 66.0 AP on COCO test-dev**.
* ***[07/03/2023]*** Code for Co-Deformable-DETR is released.
* ***[04/05/2023]*** [HoP](https://github.com/Sense-X/HoP) leverages Co-DETR as the backbone and achieves new SOTA performance on [nuScenes 3D detection leaderboard](https://www.nuscenes.org/object-detection?externalData=all&mapData=all&modalities=Camera).
* ***[11/19/2022]*** We achieved 64.4 AP on COCO minival and 64.5 AP on COCO test-dev with only ImageNet-1K as pre-training data. Codes will be available soon.

## Introduction

![teaser](figures/framework.png)

In this paper, we present a novel collaborative hybrid assignments training scheme, namely Co-DETR, to learn more efficient and effective DETR-based detectors from versatile label assignment manners.
1. **Encoder optimization**: The proposed training scheme can easily enhance the encoder's learning ability in end-to-end detectors by training multiple parallel auxiliary heads supervised by one-to-many label assignments.
2. **Decoder optimization**: We conduct extra customized positive queries by extracting the positive coordinates from these auxiliary heads to improve attention learning of the decoder.
3.


 DRAFT_MODEL_TAG=deepseek-ai/DeepSeek-R1-MTP
export QUANT_MODE=weight_only_int8
export DRAFT_MODEL_QUANT_MODE=weight_only_int8
export TOTAL_MAX_LENGTH=8192
export MAX_DEC_LEN=2048
# 算子加速策略
export CUDA_VISIBLE_DEVICES="0,1,2,3,4,5,6,7"
python -m paddle.distributed.launch --ips "192.168.0.1,192.168.0.2"\
  --gpus ${CUDA_VISIBLE_DEVICES} \
  predictor.py \
  --model_name_or_path ${MODEL_TAG} \
  --dtype bfloat16 \
  --mode dynamic \
  --inference_model 1 \
  --append_attn 1 \
  --total_max_length ${TOTAL_MAX_LENGTH} \
  --quant_type ${QUANT_MODE} \
  --max_length ${MAX_DEC_LEN} \
  --speculate_method mtp \
  --draft_model_name_or_path ${DRAFT_MODEL_TAG} \
  --draft_model_quant_type ${DRAFT_MODEL_QUANT_MODE} \
  --speculate_max_draft_token_num 1 \
  --return_full_hidden_states 1 \
  --mla_use_matrix_absorption 1

$ bash run_dynamic_mtp.sh
```

2. DeepSeek_R1 使用 FP8, MTP 使用 FP8

node1 和 node2 脚本相同
```shell
$ cat run_dynamic_mtp.sh

export MODEL_TAG=deepseek-ai/DeepSeek-R1-FP8
export DRAFT_MODEL_TAG=deepseek-ai/DeepSeek-R1-MTP-FP8
export QUANT_MODE=a8w8_fp8
export DRAFT_MODEL_QUANT_MODE=a8w8_fp8
export TOTAL_MAX_LENGTH=8192
export MAX_DEC_LEN=2048
# 算子加速策略
export CUDA_VISIBLE_DEVICES="0,1,2,3,4,5,6,7"
python -m paddle.distributed.launch --ips "192.168.0.1,192.168.0.2"\
  --gpus ${CUDA_VISIBLE_DEVICES} \
  predictor.py \
  --model_name_or_path ${MODEL_TAG} \
  --dtype bfloat16 \
  --mode dynamic \
  --inference_model 1 \
  --append_attn 1 \
  --total_max_length ${TOTAL_MAX_LENGTH} \
  --quant_type ${QUANT_MODE} \
  --max_length ${MAX_DEC_LEN} \
  --speculate_method mtp \
  --draft_model_name_or_path ${DRAFT_MODEL_TAG} \
  --draft_model_quant_type ${DRAFT_MODEL_QUANT_MODE} \
  --speculate_max_draft_token_num 1 \
  --return_full_hidden_states 1 \
  --mla_use_matrix_absorption 1

$ bash run_dynamic_mtp.sh
```
#### DeepSeek_R1 动态图 + MTP 动态图, 单机 TP8
1. DeepSeek_R1 使用 weight_only_int8, MTP 使用 weight_only_int8
```shell
$ cat run_dynamic_mtp.sh

export MODEL_TAG=deepseek-ai/DeepSeek-R1
export DRAFT_MODEL_TAG=deepseek-ai/DeepSeek-R1-MTP
export QUANT_MODE=weight_only_int4
export DRAFT_MODEL_QUANT_MODE=weight_only_int8
export TOTAL_MAX_LENGTH=8192
export MAX_DEC_LEN=2048
# 算子加速策略
export CUDA_VISIBLE_DEV


Inner
  {
    void test()
    {
      syso(x);
    }
  }
  }

  答题时，也要能察言观色，揣摩提问者的心思，显然人家希望你说的是静态内部类不能访问外部类的成员，但你一上来就顶牛，这不好，要先顺着人家，让人家满意，然后再说特殊情况，让人家吃惊。
28、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?
  可以继承其他类或实现其他接口。不仅是可以，而是必须!
29、super.getClass()方法调用
  下面程序的输出结果是多少？
  import java.util.Date;
  public  class Test extends Date{
  public static void main(String[] args) {
    new Test().test();
  }

  public void test(){
    System.out.println(super.getClass().getName());
  }
  }

  很奇怪，结果是Test
  这属于脑筋急转弯的题目，在一个qq群有个网友正好问过这个问题，我觉得挺有趣，就研究了一下，没想到今天还被你面到了，哈哈。
  在test方法中，直接调用getClass().getName()方法，返回的是Test类名
  由于getClass()在Object类中定义成了final，子类不能覆盖该方法，所以，在
  test方法中调用getClass().getName()方法，其实就是在调用从父类继承的getClass()方法，等效于调用super.getClass().getName()方法，所以，super.getClass().getName()方法返回的也应该是Test。
  如果想得到父类的名称，应该用如下代码：
  getClass().getSuperClass().getName();
30、String是最基本的数据类型吗?
  基本数据类型包括byte、int、char、long、float、double、boolean和short。
  java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类
31、String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有？
  没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s原先指向一个String对象，内容是 "Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。
  通过上面的说明，我们很容易导出另一个结论，如果经常对字�


包含的任务有哪些？|
|人工智能|您认为人工智能的应用前景如何？|
|深度学习|请简述一下深度学习的基本原理是什么？|
|机器翻译|请说明机器翻译模型的发展历程和主要方法？|
|文本分类|如何设计一个文本分类模型，可以应对多种类型的文本？|
|命名实体识别|请列举命名实体识别在各个领域的应用场景？|
|知识图谱|请解释一下知识图谱的概念和构建方法？|
|问答系统|请分析一下常见的问答系统的优缺点及其应用场景？|
|语音识别|请介绍一下语音识别技术的现状和未来发展方向？|
|数据挖掘|请阐述一下数据挖掘在商业领域的应用案例和价值？|
| 开始一个新的项目 | 建议如何开始一个新的项目？ |
| 日常时间管理 | 你有什么实用的时间管理建议来帮助提高日常生产力？ |
| 产品定价 | 如何决定一种产品的价格？ |
| Twitter 推文 | 你有什么有用的建议可以帮助我写出引人入胜的推文吗？ |
| 网站优化 | 有什么可行的途径可以帮助我进行网站内容优化？ |
| 新兴技术趋势 | 当前有哪些技术发展趋势可能会影响到我的业务？ |
| 商品市场营销 | 如何制定成功的商品市场营销策略？ |
| 工作面试 | 面试时我应该注意什么？你有什么好的技巧可以分享吗？ |
| 社交媒体广告 | 社交媒体广告有哪些有效的策略可以帮助我增加转化率？ |
| 企业文化改进 | 如何在公司中引导和实现积极的企业文化改变？ |
| 文学分析 | 分析《红楼梦》的主题和人物形象 |
| 金融预测 | 预测未来三个月股市走势 |
| 情感识别 | 判断一篇文章的情感倾向是积极还是消极 |
| 听众调查 | 调查听众对广播节目的满意度，得到反馈并改进 |
| 产品推荐 | 推荐适合年轻女性的护肤品牌及其产品 |
| 编辑修改 | 对一篇新闻稿进行编辑修改，提高其可读性和准确性 |
| 艺术鉴赏 | 对莫奈的《睡莲》进行艺术鉴赏，分�


reactError(message);

    const channel = args.channel || cache.channels.get(message.channelID);
    if (!channel) return;

    const messageToUse = cache.messages.get(args.messageID) ||
      (await getMessage(channel.id, args.messageID).catch(() => undefined));
    if (!messageToUse) return botCache.helpers.reactError(message);

    const reactionRole = await db.reactionroles.findOne((value) =>
      value.messageID === args.messageID ||
      (message.guildID === value.guildID && value.name === args.name)
    );
    if (reactionRole) return botCache.helpers.reactError(message);

    db.reactionroles.create(message.id, {
      name: args.name,
      reactions: [
        {
          reaction: args.emoji,
          roleIDs: args.roles.map((r) => r.id),
        },
      ],
      messageID: messageToUse.id,
      channelID: messageToUse.channelID,
      guildID: message.guildID,
      authorID: message.author.id,
    });

    addReaction(messageToUse.channelID, messageToUse.id, args.emoji);
    botCache.helpers.reactSuccess(message);
  },
});

interface CommandArgs {
  name: string;
  channel?: Channel;
  messageID: string;
  emoji: string;
  roles: Role[];
}
export function split<T>(text: string, delimiter: string, options: string): string[] {
    let tokens = text.split(delimiter);
    if (options === "RemoveEmptyEntries") {
        tokens = tokens.filter(t => t);
    }

    return tokens;
}
import type {AlphaBlendMode} from "./AlphaBlendMode";
import type {AnimationHandlerParam} from "./AnimationHandlerParams";
import {CellValue} from "./AnimeParams";
import type {Attachment} from "./Attachment";
import {AttrId} from "./AttrId";
import type {FinalizedCell} from "./FinalizedCell";
import type * as vfx from "./vfx";

// 動的ボーン
// Boneが静的で様々なシステムから参照されるのに対し、
// Postureは実行時に定まるボーンの情報を扱う
// 主なものはAnimationの計算結果
//
export class Posture {
	private static _costbl: number[] = [];

	attrs: any[] = [];

	m: g.Matrix;

	alphaBlendMode: AlphaBlendMode = undefined;

	// 以下、アニメーション結果から直接決まらないが、実行時にボーンに与えたい情報
	attachments: Attachment[];
	finalizedCell: FinalizedCell;
	index: number; // Array.prototype.sortを安定にするための追加情報
	effects: vfx.Effect[];

	_trigger: g.Trigger<AnimationHandlerParam>;

	constructor() {
		this.m = new g.PlainMatrix();
		this.attrs[AttrId.cv] = new CellValue();
		this.attachments = [];
		this.effects = [];

		if (Posture._costbl.length === 0) {
			// [0, 90] degree の範囲をテーブル化
			for (let i = 0; i <= 0x4000; i++) {
				const rad = (Math.PI / 2) * (i / 0x4000);
				Posture._costbl.push(Math.cos(rad));
			}
		}
	}

	reset(): void {
		const attrs = this.attrs;
		attrs[AttrId.tx]    = attrs[AttrId.ty]   = 0;
		attrs[AttrId.rz]    = 0;
		attrs[AttrId.sx]    = attrs[AttrId.sy]   = 1;
		attrs[AttrId.lsx]   = attrs[AttrId.lsy]  = 1;
		attrs[AttrId.alpha] = 1;
		attr


IRModule(self, module: IRModule):
        call_graph = CallGraph(module, allow_missing=True)
        unused_func_names: Set[str] = set()
        for node in call_graph.nodes:
            func: Function = node.func
            if func.kind in ['public', 'cpu_kernel', 'cuda_kernel', 'hip_kernel']:
                continue
            if len(node.callers) == 0:
                unused_func_names.add(func.name)
        for func_name in unused_func_names:
            del module.functions[func_name]
            if func_name in module.global_vars:
                del module.global_vars[func_name]

        return module

def prune_unused_functions(ir_module: IRModule):
    rewriter = PruneUnusedFunctionRewriter()
    return rewriter.visit(ir_module)

class InlineFunctionPass(Pass):
    def process_module(self, ir_module: IRModule) -> IRModule:
        call_graph = CallGraph(ir_module, allow_missing=True)
        updated_ir_module = ir_module.copy().reset_funcs()
        for node in call_graph.reversed_order:
            assert isinstance(node, CallGraphNode)
            func = inline_callees(node.func, updated_ir_module)
            updated_ir_module.functions[func.name] = func

        updated_ir_module = prune_unused_functions(updated_ir_module)

        # add global variables that are not functions
        updated_ir_module.global_vars.update(
            {name: var for name, var in ir_module.global_vars.items() if name not in ir_module.functions}
        )

        return updated_ir_module

def inline_function_pass():
    return InlineFunctionPass()


8 | flagIsIntegral | flagIsUnsigned,
	}, {
		defined:  Int64,
		expected: 9 | flagIsIntegral,
	}, {
		defined:  Uint64,
		expected: 10 | flagIsIntegral | flagIsUnsigned,
	}, {
		defined:  Float32,
		expected: 11 | flagIsFloat,
	}, {
		defined:  Float64,
		expected: 12 | flagIsFloat,
	}, {
		defined:  Timestamp,
		expected: 13 | flagIsQuoted,
	}, {
		defined:  Date,
		expected: 14 | flagIsQuoted,
	}, {
		defined:  Time,
		expected: 15 | flagIsQuoted,
	}, {
		defined:  Datetime,
		expected: 16 | flagIsQuoted,
	}, {
		defined:  Year,
		expected: 17 | flagIsIntegral | flagIsUnsigned,
	}, {
		defined:  Decimal,
		expected: 18,
	}, {
		defined:  Text,
		expected: 19 | flagIsQuoted | flagIsText,
	}, {
		defined:  Blob,
		expected: 20 | flagIsQuoted | flagIsBinary,
	}, {
		defined:  VarChar,
		expected: 21 | flagIsQuoted | flagIsText,
	}, {
		defined:  VarBinary,
		expected: 22 | flagIsQuoted | flagIsBinary,
	}, {
		defined:  Char,
		expected: 23 | flagIsQuoted | flagIsText,
	}, {
		defined:  Binary,
		expected: 24 | flagIsQuoted | flagIsBinary,
	}, {
		defined:  Bit,
		expected: 25 | flagIsQuoted,
	}, {
		defined:  Enum,
		expected: 26 | flagIsQuoted,
	}, {
		defined:  Set,
		expected: 27 | flagIsQuoted,
	}, {
		defined:  Tuple,
		expected: 28,
	}, {
		defined:  Geometry,
		expected: 29 | flagIsQuoted,
	}, {
		defined:  TypeJSON,
		expected: 30 | flagIsQuoted,
	}}
	for _, tcase := range testcases {
		if int(tcase.defined) != tcase.expected {
			t.Errorf("Type %s: %d, want: %d", tcase.defined, int(tcase.defined), tcase.expected)
		}
	}
}

func TestIsFunctions(t *testing.T) {
	if IsIntegral(Null) {
		t.Error("Null: IsIntegral, must be false")
	}
	if !IsIntegral(Int64) {
		t.Error("Int64: !IsIntegral, must be true")
	}
	if IsSigned(Uint64) {
		t.Error("Uint64: IsSigned, must be false")
	}
	if !IsSigned(Int64) {
		t.Error("Int64: !IsSigned, must be true")
	}
	if IsUnsigned(Int64) {
		t.Error("Int64: IsUnsigned, must be false")
	}
	if !IsUnsigned(Uint64) {
		t.Error("Uint64: !IsUnsigned, must be true")
	}
	if IsFloat(Int64) {
		t.Error("Int64: IsFloat, must be false")
	}
	if !IsFloat(Float64) {
		t.Error("Uint64: !IsFloat, must be true")
	}
	if IsQuoted(Int64) {
		t.Error("Int64: IsQuoted, must be false")
	}
	if !IsQuoted(Binary) {
		t.Error("Binary: !IsQuoted, must be true")
	}
	if IsText(Int64) {
		t.Error("Int64: IsText, must be false")
	}
	if !IsText(Char) {
		t.Error("Char: !IsText, must be true")
	}
	if IsBinary(Int64) {
		t.Error("Int64: IsBinary, must be false")
	}
	if !IsBinary(Binary) {
		t.Error("Char: !IsBinary, must be true")


dd sp, #4
	pop {r4, r5, r6, r7}
	pop {r3}
	bx r3
	.align 2, 0
_02219F50: .word ov13_0223F834

	thumb_func_start ov13_02219F54
ov13_02219F54: ; 0x02219F54
	push {r4, r5, r6, r7, lr}
	sub sp, #4
	add r6, r0, #0
	add r5, r1, #0
	add r7, r2, #0
	bl OS_DisableInterrupts
	add r4, r0, #0
	ldr r0, _0221A028 ; =0x02241A84
	str r5, [r0]
	add r2, r5, #0
	add r2, #0x53
	mov r0, #3
	bic r2, r0
	ldr r0, _0221A02C ; =0x02241A68
	str r2, [r0]
	add r1, r2, #0
	add r1, #0x2f
	mov r3, #0x1f
	bic r1, r3
	ldr r3, _0221A030 ; =0x02241A60
	str r1, [r3]
	ldr r3, _0221A034 ; =0x0000231F
	add r1, r1, r3
	mov r3, #0x1f
	bic r1, r3
	ldr r3, _0221A038 ; =0x02241A80
	str r1, [r3]
	add r1, #0xdf
	mov r3, #0x1f
	bic r1, r3
	str r1, [r2, #4]
	ldr r1, [r0]
	add r3, r5, r7
	ldr r2, [r1, #4]
	sub r2, r3, r2
	str r2, [r1, #8]
	mov r2, #0
	ldr r1, [r0]
	str r2, [r1, #0xc]
	ldr r1, [r0]
	mov r0, #3
	str r0, [r1]
	ldr r0, _0221A03C ; =0x02241A7C
	str r6, [r0]
	ldr r0, _0221A040 ; =0x02241A78
	ldr r0, [r0]
	cmp r0, #0
	bne _02219FDA
	ldr r0, _0221A030 ; =0x02241A60
	ldr r0, [r0]
	ldr r1, _0221A044 ; =0x00002300
	bl WCM_Init
	cmp r0, #0
	beq _02219FD4
	add r0, r4, #0
	bl OS_RestoreInterrupts
	mov r0, #0
	add sp, #4
	pop {r4, r5, r6, r7}
	pop {r3}
	bx r3
_02219FD4:
	mov r1, #1
	ldr r0, _0221A040 ; =0x02241A78
	str r1, [r0]
_02219FDA:
	ldr r0, _0221A040 ; =0x02241A78
	ldr r0, [r0]
	cmp r0, #1
	bne _0221A016
	ldr r0, _0221A02C ; =0x02241A68
	ldr r0, [r0]
	ldr r1, _0221A048 ; =ov13_0221A3CC
	bl WCM_StartupAsync
	cmp r0, #3
	beq _0221A000


：阻止延时执行的debugger
  - 📝 Eval 拦截：阻止通过eval执行的debugger

## 使用方法 📝

1. 🔧 安装油猴插件（Tampermonkey）
   - 支持Chrome、Firefox、Edge等主流浏览器
   - 从浏览器应用商店安装最新版本

2. 📥 安装此脚本
   - 点击脚本链接自动安装
   - 或手动复制代码到油猴中
   - 确保脚本已启用

3. ✅ 脚本会自动在页面加载开始时运行
   - 无需手动干预
   - 自动拦截所有debugger
   - 控制台显示工作状态

## 控制台输出说明 📊

- 🚀 启动提示：显示脚本版本和启动状态
- ⚡ Constructor拦截：显示构造函数debugger拦截情况
- ⏰ SetInterval拦截：显示定时器debugger拦截情况
- ⏱ SetTimeout拦截：显示延时器debugger拦截情况
- 📝 Eval拦截：显示eval执行debugger拦截情况

## 版本历史 📅

- v2.1.1: 图标更新 🎨
  - ✨ 添加脚本图标
  - 🖼 优化视觉识别度

- v2.1.0: 功能优化版本 🔄
  - ✨ 优化控制台输出，提供更清晰的状态提示
  - 🎨 添加友好的emoji提示，提升使用体验
  - 🔧 防止重复提示信息，避免控制台污染
  - 🛡 增强hook机制的稳定性

- v1.0.0: 初始发布版本 🎉
  - ✨ 实现基础的debugger移除功能
  - 🛡 添加防检测机制
  - 🔧 优化错误处理
  - 📝 基础文档支持

## 注意事项 ⚠

- 脚本会自动在页面加载开始时运行
- 首次拦截各类型debugger时会显示提示信息
- 同类型的debugger拦截只提示一次
- 不会影响页面正常的开发者工具使用

## 许可证 📄

MIT License

## 贡献指南 🤝

欢迎提交问题和改进建议！
- 提交Issue报告问题
- 提交PR贡献代码
- 帮助改进文档

## 作者 👩💻

Sherry Contributing to Sherpa
======================

Thanks for reporting an issue, fixing a bug, or adding a new feature to
Sherpa. The following guidelines are not meant to be too onerous; please open
an issue if you find this to be wrong! Thanks are due to the [AstroPy
project](https://www.astropy.org/), from which we based this document.

Reporting Issues
----------------

When [opening an issue](https://github.com/sherpa/sherpa/issues) to report a
problem, please try and provide a minimal code example that reproduces the
issue, and also include details of the operating system, and the versions of
the code you are using - in particular for Sherpa, NumPy, and Python. The
Sherpa version can be found using

    $ python -c 'import sherpa; print(sherpa.__version__)'
    4.12.1

When using a development version of Sherpa, the value will include the
Git commit. An example of this is ``4.12.1+327.ge5183cd4``.

Contributing code
-----------------

Contributions to Sherpa are generally done via a [pull
request](https://github.com/sherpa/sherpa/pulls) from your GitHub fork of the
[Sherpa repository](https://github.com/sherpa/sherpa), although you will see
core developers using the Sherpa repository for development. At present we do
not have a document describing our suggested development workflow, so we
suggest you follow the [AstroPy
workflow](https://docs.astropy.org/en/latest/development/workflow/development_workflow.html)
for now. We also do not have a written up set of coding guidelines, so we also
suggest using the [AstroPy
guidelines](https://docs.astropy


= [
    'HAS_READER',
    'SILENT_PRINT',
    'VERSION'
  ];

  /**
   * Adds a list of user-agent properties and their values to the output table.
   * @param {Element} parent The table body to append new rows to
   * @param {string} title The header for this table section
   * @param {Object} ns The Closure namespace to read properties from
   * @param {Array.<string>} A list of properties to read from that namespace
   */
  function addSection(parent, title, ns, properties) {
    goog.dom.appendChild(
        parent,
        goog.dom.createDom(goog.dom.TagName.TR,
                           null,
                           goog.dom.createDom(goog.dom.TagName.TH,
                                              {'colspan': 2, 'class': 'section'},
                                              title)));

    goog.array.forEach(
        properties,
        function(p) {
          addValue(parent, p.toLowerCase(), ns[p]);
        })
  }

  /**
   * Adds a name/value row to the table.
   * @param {Element} parent The table body to append the row to
   * @param {string} name The name of the property
   * @param {string|boolean} value The value to display
   */
  function addValue(parent, name, value) {
    var row = goog.dom.createElement('tr');
    goog.dom.appendChild(parent, row);

    var nameCell = goog.dom.createDom(goog.dom.TagName.TH, null, name);
    goog.dom.appendChild(row, nameCell);

    var valueCell = goog.dom.createElement('td');
    goog.dom.appendChild(row, valueCell);

    if (typeof value === 'boolean') {
      value = value ? 'yes' : 'no';
      goog.dom.setTextContent(valueCell, value);
      goog.dom.classlist.set(valueCell, value);
    } else {
      goog.dom.setTextContent(valueCell, value);
      if (!value) {
        goog.dom.classlist.set(valueCell, 'no');
      }
    }
  }

  var browser = goog.dom.getElement('browserFields');
  addSection(browser, 'Hardware Platform', goog.userAgent, platformFields);
  addSection(browser, 'Renderer', goog.userAgent, rendererFields);
  addSection(browser, 'Product', goog.userAgent.product, productFields);

  var features = goog.dom.getElement('featureFields');
  addSection(features, 'Adobe Reader Detection', goog.userAgent.adobeReader,
      adobeReaderFields);
  addSection(features, 'iPhoto Detection', goog.userAgent.iphoto, iphotoFields);
  addSection(features, 'Microsoft JScript', goog.userAgent.jscript,
      jscriptFields);

  </script>

</body>
</html>
<!DOCTYPE html>
<html>
<style type="text/css">
  .spinner-painter {
    animation: spinner-rotation 1.2s linear infinite;
    background: paint(spinner-painter);
    display: inline-block;
    height: 64px;
    width: 64px;
  }
  @keyframes spinner-rotation {
    0% {
      --spinner-angle-degrees: 0;
    }
    100% {
      --spinner-angle-degrees: 360;
    }
  }

  .ring-painter {
    animation:
      comet-head 1.2s cubic-bezier(0.5, 0, 0.5, 1) -0.45s infinite,
      comet-tail 1.2s cubic-bezier(0.5, 0, 0.5, 1) infinite;
    background: paint(ring-painter);
    display: inline-block;
    height: 64px;
    width: 64px;
  }
  @keyframes comet-head


: 20})});
        toolContext.onMouseMove({endPosition: newPoint({longitude: 13, latitude: 28})});
        toolContext.onMouseMove({endPosition: newPoint({longitude: 28, latitude: 32})});
        toolContext.onLeftClick({position: newPoint({longitude: 30, latitude: 40})});
        toolContext.onMouseMove({endPosition: newPoint({longitude: 31, latitude: 41})});
        toolContext.onMouseMove({endPosition: newPoint({longitude: 39, latitude: 35})});

        expect(toolContext.entities).to.exist;
        expect(toolContext.entities.length).to.equal(1);
        const entity = toolContext.entities[0];
        expect(entity.polygon).to.exist;
        expect(entity.polygon.hierarchy).to.exist;
        expect(entity.polygon.hierarchy.length).to.equal(4);
        expect(entity).to.deep.equal(
            {
                polygon: {
                    hierarchy: [
                        newPoint({longitude: 10, latitude: 20, height: 0}),
                        newPoint({longitude: 30, latitude: 20, height: 0}),
                        newPoint({longitude: 30, latitude: 40, height: 0}),
                        newPoint({longitude: 10, latitude: 40, height: 0}),
                    ],
                    material: polygonColor
                }
            }
        );

        expect(toolContext.toolEntities).to.exist;
        expect(toolContext.toolEntities).to.deep.equal([]);
    });

});

//unkown type
let userInput: unknown;
let userName: string;

userInput = 5;
userInput = 'Max';
if(typeof userInput === 'string'){
    userName = userInput;
}
//userName = userInput //unvalid

//nerver type
function generateError(message:string,code:number): never{
    throw { message: message, errorCode: code}
}import { RefreshingAuthProvider } from "@twurple/auth"
import { ChatClient } from "@twurple/chat"
import { promises as fs } from "fs"
import dotenv from "dotenv-flow"

dotenv.config({
  default_node_env: "development",
})

const gachaIntervalMs = 180 * 1000
const stopTime = 2 * 60 * 60 * 1000
let running = true

const clientId = process.env.CLIENT_ID as string
const clientSecret = process.env.CLIENT_SECRET as string
const channel = process.env.CHANNEL as string

async function main() {
  setTimeout(() => {
    console.log("Stopped")
    running = false
  }, stopTime)

  const tokenData = JSON.parse(await fs.readFile("./tokens.json", "utf-8"))
  const auth = new RefreshingAuthProvider(
    {
      clientId,
      clientSecret,
      onRefresh: async (newTokenData) =>
        await fs.writeFile(
          "./tokens.json",
          JSON.stringify(newTokenData, null, 2),
          "utf-8"
        ),
    },
    tokenData
  )

  const chatClient = new ChatClient(auth, { channels: [channel] })

  let amount: number | string = 1

  chatClient.onConnect(async () => {
    console.log("CONNECTED", { channel })

    setInterval(async () => {
      if (!running) {
        return
      }

      const message = `!gacha ${amount}`
      await chatClient.say(channel, message).then(
        () => {
          console.log("Sent", { message })
        },
        (reason) => {
          console.error("Not sent", { reason })
        }
      )

      // Swap amount to prevent duplicated message
      if (amount == 1) {
        amount = "(github.com/narze/autogacha)"
      } else {
        amount = 1
      }
    }, gachaIntervalMs)
  })

  await chatClient.connect()
}

main()
import { LanguageCode


" width="15" height="15" preserveAspectRatio="xMidYMid meet" viewBox="0 0 15 15"><path fill="currentColor" fill-rule="evenodd" d="M7.5 0a.5.5 0 01.5.5v1.307A5.624 5.624 0 0113.007 7H14.5a.5.5 0 010 1h-1.511A5.625 5.625 0 018 12.989V14.5a.5.5 0 01-1 0v-1.493A5.624 5.624 0 011.807 8H.5a.5.5 0 010-1h1.289A5.624 5.624 0 017 1.789V.5a.5.5 0 01.5-.5ZM8 12.032V9.5a.5.5 0 00-1 0v2.554A4.675 4.675 0 012.763 8H5.5a.5.5 0 000-1H2.742A4.674 4.674 0 017 2.742V5.5a.5.5 0 001 0V2.763A4.675 4.675 0 0112.054 7H9.5a.5.5 0 000 1h2.532A4.675 4.675 0 018 12.032Z" clip-rule="evenodd"/></svg>';
  static const String crumpled_paper =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="15" height="15" preserveAspectRatio="xMidYMid meet" viewBox="0 0 15 15"><path fill="currentColor" fill-rule="evenodd" d="M4.61.063a.45.45 0 00-.528.27l-.928 2.32-2.321.93a.45.45 0 00-.193.687l1.371 1.829-.948 3.792a.45.45 0 00.264.524L4.2 11.613l1.425 2.137a.45.45 0 00.498.183l3.5-1a.41.41 0 00.018-.006l3-1a.45.45 0 00.297-.33l1-4.5a.45.45 0 00-.169-.457l-1.82-1.365V3a.45.45 0 00-.249-.402l-3-1.5a.45.45 0 00-.092-.035l-4-1Zm6.822 5.949 1.343 1.007-2.563 2.135a.45.45 0 00-.139.204l-.82 2.457-1.515-.947a.45.45 0 10-.477.764l1.142.713-2.21.632L4.873 11a.45.45 0 00-.2-.165L2.03 9.734l.821-3.284H5a.45.45 0 100-.9H2.725L1.712 4.2l1.802-.721 2.844.948a.45.45 0 00.493-.146l1.773-2.216 2.426 1.213v1.917l-2.217.887a.45.45 0 00-.26.276l-.5 1.5a.45.45 0 10.854.284L9.36 6.84l2.071-.828ZM7.711 1.766 6.345 3.474l-2.25-.75.677-1.692 2.939.734Zm2.5 10.023 1.905-.635.659-2.964-1.889 1.574-.675 2.025Z" clip-rule="evenodd"/></svg>';
  static const String cube =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="15" height="15" preserveAspectRatio="xMidYMid meet" viewBox="0 0 15 15"><path fill="currentColor" fill-rule="evenodd" d="M7.289.797a.5.5 0 01.422 0l6 2.8A.5.5 0 0114


<dfn data-dfn-for="html-global" id="attr-itemref" data-dfn-type="element-attr">itemref</dfn>属性を指定されてもよい。

itemref属性は、指定される場合、同じツリー内の要素のIDからなる、別のトークンと同一でない順不同の一意な空白区切りトークンの集合である値を持たなければならない。

itemref属性は、itemscope属性に指定されない要素で指定してはならない。

itemref属性は、microdataデータモデルの一部ではない。この属性は、注釈付けするデータが便利なツリー構造に従わないページに注釈を追加することで著者を支援するための単なる構文構造に過ぎない。この属性は、たとえば、セル内のプロパティを維持しながら、各列が個別のアイテムを定義するために、テーブルにおけるデータをマークアップすることを著者に可能にする。

この例は、鉄道模型メーカーの製品を記述するために使用される単純な語彙を示す。語彙は、ちょうど5つのプロパティ名を持つ：

product-code
メーカーのカタログに製品を記載する整数。
name
製品の簡単な説明。
scale
製品の規模を示す、"HO"、"1"または"Z"（潜在的に先頭または末尾の空白をもつ）のいずれか。
digital
存在する場合、特定の型のデジタルデコーダーを持つことを示す、"Digital"、"Delta"または"Systems"（潜在的に先頭または末尾の空白をもつ）のいずれか。
track-type
トラック固有の製品の場合、製品が意図されるトラックの型を示す、 "K"、"M"、"C"（潜在的に先頭または末尾の空白をもつ


44" alt=""  id="basicCodeBlock0" border="0">

Home > Commands > Sound > GetSoundInstanceLoopCount

GetSoundInstanceLoopCount

Description

If the sound was played with looping turned on this command returns the number of loops completed so far. If the instance is using a fixed number of loops then it will never actually reach that loop count value as it will be immediately deleted upon reaching the end of its last loop. The instance ID is the value returned from PlaySound when you initiated the playing of the sound.

Definition

integer GetSoundInstanceLoopCount( iID )

int agk::GetSoundInstanceLoopCount( uint32_t iID )

Parameters

iID - The ID of the instance to check

App Game Kit  © The Game Creators Ltd. All Rights Reserved.                Report an issue

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

<title>GetSoundInstanceVolume - AGK Help</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

<link href="../../main.css" rel="styleSheet" type="text/css" />


ordArray *wd = NULL;
    ECPoint *r = NULL;
    int ret = RET_OK;

    CHECK_PARAM(ctx != NULL);
    CHECK_PARAM(d != NULL);
    CHECK_PARAM(qx != NULL);
    CHECK_PARAM(qy != NULL);

    CHECK_NOT_NULL(wd = wa_alloc_from_ba(d));
    if (int_is_zero(wd) || int_cmp(wd, ctx->params->gfq->p) >= 0) {
        SET_ERROR(RET_INVALID_PRIVATE_KEY);
    }
    wa_change_len(wd, ctx->params->len);

    CHECK_NOT_NULL(r = ec_point_alloc(ctx->params->ecp->len));
    if (ctx->params->precomp_p == NULL) {
        int sign_win_opt_level = (default_opt_level >> 8) & 0x0f;
        if (sign_win_opt_level == 0) {
            sign_win_opt_level = ECDSA_DEFAULT_WIN_WIDTH;
        }
        DO(ecdsa_set_sign_precomp(ctx, 0, sign_win_opt_level));
    }

    DO(ecp_dual_mul_opt(ctx->params->ecp, ctx->params->precomp_p, wd, NULL, NULL, r));

    blen = (int_bit_len(ctx->params->ecp->gfp->p) + 7) / 8;
    CHECK_NOT_NULL(*qx = wa_to_ba(r->x));
    CHECK_NOT_NULL(*qy = wa_to_ba(r->y));
    DO(ba_change_len(*qx, blen));
    DO(ba_change_len(*qy, blen));

cleanup:

    ec_point_free(r);
    wa_free_private(wd);

    return ret;
}

int ecdsa_compress_pubkey(EcdsaCtx *ctx, const ByteArray *qx, const ByteArray *qy, ByteArray **q, int *last_qy_bit)
{
    ECPoint *ec_point = NULL;
    int ret = RET_OK;

    CHECK_PARAM(ctx != NULL);
    CHECK_PARAM(qx != NULL);
    CHECK_PARAM(qy != NULL);
    CHECK_PARAM(q != NULL);
    CHECK_PARAM(last_qy_bit != NULL);

    DO(public_key_to_ec_point(ctx->params, qx, qy, &ec_point));

    CHECK_NOT_NULL(*q = ba_alloc_from_uint8(qx->buf, qx->len));
    *last_qy_bit = int_get_bit(ec_point->y, 0);

cleanup:

    ec_point_free(ec_point);

    return ret;
}

int ecdsa_decompress_pubkey(EcdsaCtx *ctx, const ByteArray *q, int last_qy_bit, ByteArray **qx, ByteArray **qy)
{
    WordArray *x = NULL;
    WordArray *y = NULL;
    GfpCtx *gfp;
    size_t blen;
    int ret = RET_OK;

    CHECK_PARAM(ctx != NULL);
    CHECK_PARAM(qx != NULL);
    CHECK_PARAM(qy != NULL);
    CHECK_PARAM(q != NULL);

    if (last_qy_bit != 0 && last_qy_bit != 1) {
        SET_ERROR(RET_INVALID_PUBLIC_KEY);
    }

    CHECK_NOT_NULL(x = wa_alloc_from_ba(q));
    wa_change_len(x, ctx->params->len);

    CHECK_NOT_NULL(y = wa_alloc(ctx->params->len));

    gfp = ctx->params->ecp->gfp;
    if (int_cmp(x, gfp->p) >= 0 || int_is_zero(x)) {
        SET_ERROR(RET_INVALID_PUBLIC_KEY);
    }

    /* Восстановление точки эллиптической кривой. */
    wa_free(y);
    y = NULL;

    CHECK_NOT_NULL(y = wa_alloc(ctx->params->len));
    gfp_mod_sqr(gfp, x, y);
    gfp_mod_add(gfp, y, ctx->params->ecp->a, y);
    gfp_mod_mul(gfp, x, y, y);
    gfp_mod_add(gfp, y, ctx->params->ecp->b, y);
    if (!gfp_mod_sqrt(gfp, y, y)) {
        SET_ERROR(RET_INVALID_PUBLIC_KEY);
    }

    /* Если младший бит y не равен last_qy_bit y = p - y. */
    if (int_get_bit(y, 0) != last_qy_bit) {
        gfp_mod_sub(gfp, gfp->p, y, y);
    }

    blen = (int_bit_len(gfp->p) + 7) / 8;
    *qx = wa_to_ba(x);
    *qy = wa_to_ba(y);
    DO(ba_change_len(*qx, blen));
    DO(ba_change_len(*qy, blen));

    ret = RET_OK;

cleanup:

    wa_free(x);
    wa_free(y);

    return ret;
}

int ecdsa_set_opt_level(EcdsaCtx *ctx, OptLevelId opt_level)
{
    int ret = RET_OK;
    int sign_comb_opt_level;
    int sign_win_opt_level;
    int verify_comb_opt_level;
    int verify_win_opt_level;

    CHECK_PARAM(ctx != NULL);

    if (ctx->params == NULL) {
        SET_ERROR(RET_CONTEXT_NOT_READY);
    }

    sign_comb_opt_level = (opt_level >> 12) & 0x0f;
    sign_win_opt_level = (opt_level >> 8) & 0x0f;
    verify_comb_opt_level = (opt_level >> 4) & 0x0f;
    verify_win_opt_level = opt_level & 0x0f;

    CHECK_PARAM(sign_comb_opt_level == 0 || sign_win_opt_level == 0);
    CHECK_PARAM(sign_win_opt_level == 0 || (sign_win_opt_level & 1) == 1);
    CHECK_PARAM(verify_comb_opt_level == 0 || verify_win_opt_level == 0);
    CHECK_PARAM(verify_win_opt_level == 0 || (verify_win_opt_level & 1) == 1);

    DO(ecdsa_set_sign_precomp(ctx, sign_comb_opt_level, sign_win_opt_level));
    DO(ecdsa_set_verify_precomp(ctx, verify_comb_opt_level, verify_win_opt_level));

cleanup:

    return ret;
}

int ecdsa_init_sign(EcdsaCtx *ctx, const ByteArray *d, PrngCtx *prng)
{
    ByteArray *seed = NULL;
    int ret = RET_OK;

    CHECK_PARAM(ctx != NULL);
    CHECK_PARAM(d != NULL);
    CHECK_PARAM(prng != NULL);

    if (ctx->params == NULL) {
        SET_ERROR(RET_CONTEXT_NOT_READY);
    }

    wa_free_private(ctx->priv_key);


E);

  Dmsg0(100, "Begin DespoolAttributesFromFile\n");

  if (jcr->IsJobCanceled() || !jcr->dir_impl->res.pool->catalog_files
      || !jcr->db) {
    goto bail_out; /* user disabled cataloging */
  }

  spool_fd = open(file, O_RDONLY | O_BINARY);
  if (spool_fd == -1) {
    Dmsg0(100, "cancel DespoolAttributesFromFile\n");
    /* send an error message */
    goto bail_out;
  }

#if defined(HAVE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
  posix_fadvise(spool_fd, 0, 0, POSIX_FADV_WILLNEED);
#endif

  while ((nbytes = read(spool_fd, (char*)&pktsiz, sizeof(int32_t)))
         == sizeof(int32_t)) {
    message_length = ntohl(pktsiz);

    if (message_length > 0) {
      // check for message_length + \0
      if ((message_length + 1) > (int32_t)SizeofPoolMemory(msg)) {
        msg = ReallocPoolMemory(msg, message_length + 1);
      }
      nbytes = read(spool_fd, msg, message_length);
      if (nbytes != (size_t)message_length) {
        BErrNo be;
        Dmsg2(400, "nbytes=%" PRIuz " message_length=%" PRId32 "\n", nbytes,
              message_length);
        Qmsg1(jcr, M_FATAL, 0, T_("read attr spool error. ERR=%s\n"),
              be.bstrerror());
        goto bail_out;
      }
      msg[nbytes] = '\0';
    }

    if (!jcr->IsJobCanceled()) {
      UpdateAttribute(jcr, msg, message_length);
      if (jcr->IsJobCanceled()) { goto bail_out; }
    }
  }

  retval = true;

bail_out:
  if (spool_fd != -1) { close(spool_fd); }

  if (jcr->IsJobCanceled()) { CancelStorageDaemonJob(jcr); }

  FreePoolMemory(msg);
  Dmsg1(100, "End DespoolAttributesFromFile retval=%i\n", retval);
  return retval;
}
} /* namespace directordaemon */
// Copyright (c) 2020 fortiss GmbH
//
// Authors: Julian Bernhard, Klemens Esterle, Patrick Hart and
// Tobias Kessler
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.

#ifndef BARK_MODELS_BEHAVIOR_STATIC_TRAJECTORY_BEHAVIOR_STATIC_TRAJECTORY_HPP_
#define BARK_MODELS_BEHAVIOR_STATIC_TRAJECTORY_BEHAVIOR_STATIC_TRAJECTORY_HPP_

#include <memory>
#include <utility>
#include <vector>

#include "bark/models/behavior/behavior_model.hpp"
#include "bark/models/dynamic/dynamic_model.hpp"

namespace bark {
namespace models {
namespace behavior {

using dynamic::DynamicModelPtr;
using dynamic::Input;
using dynamic::State;
using dynamic::Trajectory;
using world::ObservedWorld;
using world::objects::AgentId;
using StateRowVector = Eigen::Matrix<State::Scalar, 1, Eigen::Dynamic>;

// model for replaying static trajectories
// can e.g. be used for dataset replay
class BehaviorStaticTrajectory : public BehaviorModel {
 public:
  explicit BehaviorStaticTrajectory(const commons::ParamsPtr& params);
  BehaviorStaticTrajectory(const commons::ParamsPtr& params,
                           const Trajectory& static_trajectory);
  Trajectory Plan(double min_planning_time,
                  const world::ObservedWorld& observed_world) override;
  std::shared_ptr<BehaviorModel>


rate_power,
          use_locking=self._use_locking)

  def get_config(self):
    config = super(Ftrl, self).get_config()
    config.update({
        'learning_rate':
            self._serialize_hyperparameter('learning_rate'),
        'decay':
            self._serialize_hyperparameter('decay'),
        'initial_accumulator_value':
            self._initial_accumulator_value,
        'learning_rate_power':
            self._serialize_hyperparameter('learning_rate_power'),
        'l1_regularization_strength':
            self._serializer_hyperparameter('l1_regularization_strength'),
        'l2_regularization_strength':
            self._serializer_hyperparameter('l2_regularization_strength'),
        'l2_shrinkage_regularization_strength':
            self._l2_shrinkage_regularization_strength,
    })
    return config


.yukihookapi.hook.xposed.parasitic.context.wrapper

import android.content.Context
import android.content.res.Configuration
import android.content.res.Resources
import android.view.ContextThemeWrapper
import com.highcapable.yukihookapi.hook.factory.injectModuleAppResources
import com.highcapable.yukihookapi.hook.xposed.bridge.YukiXposedModule
import com.highcapable.yukihookapi.hook.xposed.parasitic.reference.ModuleClassLoader

/**
 * 代理 [ContextThemeWrapper]
 *
 * 通过包装 - 你可以轻松在 (Xposed) 宿主环境使用来自模块的主题资源
 * @param baseContext 原始 [Context]
 * @param theme 使用的主题
 * @param configuration 使用的 [Configuration]
 */
class ModuleContextThemeWrapper private constructor(baseContext: Context, theme: Int, configuration: Configuration?) :
    ContextThemeWrapper(baseContext, theme) {

    internal companion object {

        /**
         * 从 [Context] 创建 [ModuleContextThemeWrapper]
         * @param baseContext 对接的 [Context]
         * @param theme 需要使用的主题
         * @param configuration 使用的 [Configuration]
         * @return [ModuleContextThemeWrapper]
         * @throws IllegalStateException 如果重复装载
         */
        internal fun wrapper(baseContext: Context, theme: Int, configuration: Configuration?) =
            if (baseContext !is ModuleContextThemeWrapper)
                ModuleContextThemeWrapper(baseContext, theme, configuration)
            else error("ModuleContextThemeWrapper already loaded")
    }

    /** 创建用于替换的 [Resources] */
    private var baseResources: Resources? = null

    init {
        configuration?.also {
            baseResources = baseContext.createConfigurationContext(it)?.resources
            baseResources?.updateConfiguration(it, baseContext.resources.displayMetrics)
        }
        if (YukiXposedModule.isXposedEnvironment) resources?.injectModuleAppResources()
    }

    /**
     * 设置当前 [ModuleContextThemeWrapper] 的 [Configuration]
     *
     * 设置后会自动调用 [Resources.updateConfiguration]
     * @param initiate [Configuration] 方法体
     * @return [ModuleContextThemeWrapper]
     */
    fun applyConfiguration(initiate: Configuration.() -> Unit): ModuleContextThemeWrapper {
        resources?.configuration?.apply(initiate)
        resources?.updateConfiguration(resources?.configuration, resources?.displayMetrics)
        return this
    }

    override fun getClassLoader(): ClassLoader = ModuleClassLoader.instance()

    override fun getResources(): Resources? = baseResources ?: super.getResources()
}/*
 * YukiHookAPI - An efficient Hook API and Xposed Module solution built in Kotlin.
 * Copyright (C) 2019 HighCapable
 * https://github.com/HighCapable/YukiHookAPI
 *
 * Apache License Version 2.0
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *


icense for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

#include <sysdep.h>
#include <init-arch.h>

	.text
ENTRY (_ZGVdN4v_exp)
        .type   _ZGVdN4v_exp, @gnu_indirect_function
	LOAD_RTLD_GLOBAL_RO_RDX
        leaq    _ZGVdN4v_exp_avx2(%rip), %rax
	HAS_ARCH_FEATURE (AVX2_Usable)
        jz      2f
        ret
2:      leaq    _ZGVdN4v_exp_sse_wrapper(%rip), %rax
        ret
END (_ZGVdN4v_exp)
libmvec_hidden_def (_ZGVdN4v_exp)

#define _ZGVdN4v_exp _ZGVdN4v_exp_sse_wrapper
#include "../svml_d_exp4_core.S"


e(outfile, y_valPatches)
        with open(str(args.simple_percent) + "%ytestWindowSize" + str(windowSize) + "PCA" + str(args.pca_components) + ".npy", 'bw') as outfile:
            np.save(outfile, y_testPatches)
    else:
        with open(str(args.simple_percent) + "%XtrainWindowSize" + str(windowSize) + ".npy", 'bw') as outfile:
            np.save(outfile, X_trainPatches)
        with open(str(args.simple_percent) + "%XvalWindowSize" + str(windowSize) + ".npy", 'bw') as outfile:
            np.save(outfile, X_valPatches)
        with open(str(args.simple_percent) + "%XtestWindowSize" + str(windowSize) + ".npy", 'bw') as outfile:
            np.save(outfile, X_testPatches)
        with open(str(args.simple_percent) + "%ytrainWindowSize" + str(windowSize) + ".npy", 'bw') as outfile:
            np.save(outfile, y_trainPatches)
        with open(str(args.simple_percent) + "%yvalWindowSize" + str(windowSize) + ".npy", 'bw') as outfile:
            np.save(outfile, y_valPatches)
        with open(str(args.simple_percent) + "%ytestWindowSize" + str(windowSize) + ".npy", 'bw') as outfile:
            np.save(outfile, y_testPatches)

X_train,X_val,y_train,y_val = splitTrainValSet(X_train,y_train,testRatio=0.5)

print("train集各类别的数量：")
print(countEachClassInTrain(y_train,nb_classes))
print("val集各类别的数量：")
print(countEachClassInTrain(y_val,nb_classes))
print("test集各类别的数量：")
print(countEachClassInTrain(y_test,nb_classes))

savePreprocessedData(X_train, X_val, X_test, y_train, y_val, y_test, windowSize=args.windows)


ame="topic" class="topic" data-topic-id="29f3a343-7e64-40c8-ae2f-80a27fc50a3b"><g id="sbsvgG1918" data-name="topic-shape-group"><path id="sbsvgPath1919" data-name="topic-shape-shallow-fill" d="M -56.076080322265625 -23.5L 56.076080322265625 -23.5L 56.076080322265625 22L -56.076080322265625 22z" fill="white" opacity="0"></path><path id="sbsvgPath1920" data-name="topic-shape-fill" opacity="0" d="M -56.076080322265625 -23.5L 56.076080322265625 -23.5L 56.076080322265625 22L -56.076080322265625 22z"></path><path id="sbsvgPath1921" data-name="topic-shape" fill="none" stroke="#262626" stroke-width="3" stroke-linecap="" stroke-dasharray="" d="M  -56.076080322265625 22L 56.076080322265625 22"></path><g id="sbsvgG1922" data-name="topic-content" transform="translate(-35.076080322265625 -13.5)"><g id="sbsvgG1923" data-name="inner-element-group"><g id="sbsvgG1926" data-name="topic-title-text-group" fill="#333333" text-decoration="none" text-anchor="middle" font-size="18" font-family="\'Roboto\',\'NeverMind\',\'Microsoft YaHei\',\'PingFang SC\',\'Microsoft JhengHei\',sans-serif" font-weight="500" font-style="normal"><text id="sbsvgText1925" font-family="\'Roboto\',\'NeverMind\',\'Microsoft YaHei\',\'PingFang SC\',\'Microsoft JhengHei\',sans-serif" fill="#333333" text-decoration="none" text-anchor="middle" font-size="18" font-weight="500" font-style="normal" transform="translate(35.076080322265625 0)" style="user-select: none; cursor: default;"><tspan id="sbsvgTspan1990" font-family="\'Roboto\',\'NeverMind\',\'Microsoft YaHei\',\'PingFang SC\',\'Microsoft JhengHei\',sans-serif" font-size="18" font-weight="500" font-style="normal" text-decoration="none" dy="18" x="0" fill="#333333" text-anchor="middle" style="white-space: pre;"> </tspan></text></g><g id="sbsvgG1927" data="markers-group" class="MARKERS"></g></g></g></g></g></g><g id="sbsvgG1935" data-name="branch" class="branch" transform="translate(-216.004150390625 -22)"><g id="sbsvgG1936" data-name="topic" class="topic" data-topic-id="722ee265-7781-495b-aa3b-e3620b084ecd"><g id="sbsvgG1937" data-name="topic-shape-group"><path id="sbsvgPath1938" data-name="topic-shape-shallow-fill" d="M -71.07608032226562 -23.5L 71.07608032226562 -23.5L 71.07608032226562 22L -71.07608032226562 22z" fill="white" opacity="0"></path><path id="sbsvgPath1939" data-name="topic-shape-fill" opacity="0" d="M -71.07608032226562 -23.5L 71.07608032226562 -23.5L 71.07608032226562 22L -71.07608032226562 22z"></path><path id="sbsvgPath1940" data-name="topic-shape" fill="none" stroke="#262626" stroke-width


e_node.sim_id))
                            if relationship.has_bit(sim_info.sim_id, FamilyRelationshipTuning.DEAD_SPOUSE_RELATIONSHIP_BIT):
                                with ProtocolBufferRollback(family_tree_node.proto_node.dead_spouses) as dead_spouse_family_tree_node:
                                    additional_sims_to_look_at.append(FamilyTreeNode(sim_id=relationship.get_other_sim_id(sim_info_id), proto_node=dead_spouse_family_tree_node, antecedent_depth=0, descendant_depth=0, extended_info_depth=0, include_spouse=False, step_depth=0, source_sim_id=family_tree_node.sim_id))
        automation_output('FamilyTreeInfo; Status:End')
    distributor = Distributor.instance()
    family_tree_op = GenericProtocolBufferOp(DistributorOps_pb2.Operation.SHOW_FAMILY_TREE, family_tree_msg)
    distributor.add_op_with_no_owner(family_tree_op)


ts];");
  }
}
import 'package:sqlparser/sqlparser.dart';
import 'package:test/test.dart';

import '../data.dart';
import 'utils.dart';

void main() {
  late SqlEngine engine;

  setUp(() {
    engine = SqlEngine();
    engine.registerTableFromSql('''
      CREATE TABLE foo (
        a INTEGER NOT NULL,
        b INTEGER NOT NULL
      );
    ''');
  });

  group("using column-name-list and tuple in update", () {
    test('reports error if they have different sizes', () {
      engine
          .analyze("UPDATE foo SET (a, b) = (1);")
          .expectError('(1)', type: AnalysisErrorType.cteColumnCountMismatch);
      engine
          .analyze("UPDATE foo SET (a) = (1,2);")
          .expectError('(1,2)', type: AnalysisErrorType.cteColumnCountMismatch);
    });
    test('reports no error if they have same sizes', () {
      engine.analyze("UPDATE foo SET (a, b) = (1,2);").expectNoError();
    });
  });

  group("using column-name-list and values in update", () {
    test('reports error if they have different sizes', () {
      engine.analyze("UPDATE foo SET (a, b) = (VALUES(1));").expectError(
          "(VALUES(1))",
          type: AnalysisErrorType.cteColumnCountMismatch);
      engine.analyze("UPDATE foo SET (a) = (VALUES(1,2));").expectError(
          "(VALUES(1,2))",
          type: AnalysisErrorType.cteColumnCountMismatch);
    });

    test('reports no error if they have same sizes', () {
      engine.analyze("UPDATE foo SET (a, b) = (VALUES(1,2));").expectNoError();
    });
  });

  group("using column-name-list and subquery in update", () {
    test('reports error if they have different sizes', () {
      engine.analyze("UPDATE foo SET (a, b) = (SELECT 1);").expectError(
          '(SELECT 1)',
          type: AnalysisErrorType.cteColumnCountMismatch);
      engine.analyze("UPDATE foo SET (a) = (SELECT 1,2);").expectError(
          '(SELECT 1,2)',
          type: AnalysisErrorType.cteColumnCountMismatch);
      engine
          .analyze(
              "UPDATE foo SET (a, b) = (SELECT b FROM foo as f WHERE f.a=a);")
          .expectError('(SELECT b FROM foo as f WHERE f.a=a)',
              type: AnalysisErrorType.cteColumnCountMismatch);
    });

    test('reports no error if they have same sizes', () {
      engine.analyze("UPDATE foo SET (a, b) = (SELECT 1,2);").expectNoError();
      engine
          .analyze(
              "UPDATE foo SET (a, b) = (SELECT b, a FROM foo as f WHERE f.a=a);")
          .expectNoError();
    });
  });
}
import 'package:sqlparser/sqlparser.dart';
import 'package:test/test.dart';

void main() {
  void check(String sql, List<String> problems) {
    final engine = SqlEngine();
    final parseResult = engine.parse(sql);
    engine.registerTable(const SchemaFromCreateTable()
        .read(parseResult.rootNode as CreateTableStatement));

    final context = engine.analyzeParsed(parseResult);
    expect(
      context.errors,
      pairwiseCompare<String, AnalysisError>(
        problems,
        (span, err) => err.span?.text == span,
        'with span',
      ),
    );
  }

  test('not reported on a correct table', () {
    check(
      '''
        CREATE TABLE tbl (
          foo INTEGER PRIMARY KEY,
          bar TEXT
        );
      ''',
      [],
    );
  });

  test('multiple column constraints', () {
    check(
      '''
        CREATE TABLE tbl (
          foo INTEGER PRIMARY KEY,
          bar TEXT PRIMARY KEY


/******************************************************************************
 *
 * osisscripref.h -	class OSISScripRef: an OptionFilter to handle
 * 			cross-references in modules marked up in OSIS
 *
 * $Id: osisscripref.h 3786 2020-08-30 11:35:14Z scribe $
 *
 * Copyright 2003-2013 CrossWire Bible Society (http://www.crosswire.org)
 *	CrossWire Bible Society
 *	P. O. Box 2528
 *	Tempe, AZ  85280-2528
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation version 2.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 */

#ifndef OSISSCRIPREF_H
#define OSISSCRIPREF_H

#include <swoptfilter.h>

SWORD_NAMESPACE_START

/** This Filter shows/hides cross-references in a OSIS text
 */
class SWDLLEXPORT OSISScripref : public SWOptionFilter {
public:
	OSISScripref();
	virtual ~OSISScripref();
	virtual char processText(SWBuf &text, const SWKey *key = 0, const SWModule *module = 0);
};

SWORD_NAMESPACE_END
#endif


itionFilter filter = PartitionFilter.All();

			// Query 3 pages of records.
			for (int i = 0; i < 3 && !filter.Done; i++)
			{
				console.Info("Query page: " + i);

				RecordSet rs = client.QueryPartitions(null, stmt, filter);

				try
				{
					int count = 0;

					while (rs.Next())
					{
						count++;
					}

					console.Info("Records returned: " + count);
				}
				finally
				{
					rs.Close();
				}
			}
			client.DropIndex(args.policy, args.ns, setName, indexName);
		}

		private void CreateIndex
		(
			IAerospikeClient client,
			Arguments args,
			string setName,
			string indexName,
			string binName
		)
		{
			console.Info("Create index: ns={0} set={1} index={2} bin={3}",
				args.ns, setName, indexName, binName);

			Policy policy = new Policy();

			try
			{
				IndexTask task = client.CreateIndex(policy, args.ns, setName, indexName, binName, IndexType.NUMERIC);
				task.Wait();
			}
			catch (AerospikeException ae)
			{
				if (ae.Result != ResultCode.INDEX_ALREADY_EXISTS)
				{
					throw;
				}
			}
		}

		private void WriteRecords
		(
			IAerospikeClient client,
			Arguments args,
			string setName,
			string binName,
			int size
		)
		{
			console.Info("Write " + size + " records.");

			for (int i = 1; i <= size; i++)
			{
				Key key = new Key(args.ns, setName, i);
				Bin bin = new Bin(binName, i);
				client.Put(args.writePolicy, key, bin);
			}
		}
	}
}


/**
 * @file fwd.h
 * @brief Tesseract Kinematics Forward Declarations.
 *
 * @author Levi Armstrong
 * @date February 21, 2024
 * @version TODO
 * @bug No known bugs
 *
 * @copyright Copyright (c) 2024, Levi Armstrong
 *
 * @par License
 * Software License Agreement (Apache License)
 * @par
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
 * @par
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef TESSERACT_KINEMATICS_FWD_H
#define TESSERACT_KINEMATICS_FWD_H

namespace tesseract_kinematics
{
class ForwardKinematics;
class InverseKinematics;
class JointGroup;
struct KinGroupIKInput;
class KinematicGroup;
class InvKinFactory;
class FwdKinFactory;
class KinematicsPluginFactory;
class REPInvKinFactory;
class REPInvKin;
class ROPInvKinFactory;
class ROPInvKin;
struct URParameters;
struct ManipulabilityEllipsoid;
struct Manipulability;
}  // namespace tesseract_kinematics

#endif  // TESSERACT_KINEMATICS_FWD_H


se_type: args.sse_type.clone(),
            clang: args.clang,
            direct: args.direct,
            rehit_rate: special_args.rehit_rate,
            angle_flipping: special_args.angle_flipping.clone(),
            stretches_to_bone: special_args.stretches_to_bone,
            can_hit1: special_args.can_hit1,
            can_hit2: special_args.can_hit2,
            can_hit3: special_args.can_hit3,
            can_hit4: special_args.can_hit4,
            can_hit5: special_args.can_hit5,
            can_hit6: special_args.can_hit6,
            can_hit7: special_args.can_hit7,
            can_hit8: special_args.can_hit8,
            can_hit9: special_args.can_hit9,
            can_hit10: special_args.can_hit10,
            can_hit11: special_args.can_hit11,
            can_hit12: special_args.can_hit12,
            can_hit13: special_args.can_hit13,
            enabled: special_args.enabled,
            can_be_shielded: special_args.can_be_shielded,
            can_be_reflected: special_args.can_be_reflected,
            can_be_absorbed: special_args.can_be_absorbed,
            remain_grabbed: special_args.remain_grabbed,
            ignore_invincibility: special_args.ignore_invincibility,
            freeze_frame_disable: special_args.freeze_frame_disable,
            flinchless: special_args.flinchless,
        })
    }

    pub(crate) fn from_grabbox(args: &GrabBoxArguments) -> CollisionBoxValues {
        CollisionBoxValues::Grab(GrabBoxValues {
            hitbox_id: args.hitbox_id,
            size: args.size,
            set_action: args.set_action,
            target: args.target.clone(),
            unk: args.unk.clone(),
        })
    }

    pub(crate) fn stretches_to_bone(&self) -> bool {
        match self {
            CollisionBoxValues::Hit(values) => values.stretches_to_bone,
            CollisionBoxValues::Grab(_) => false,
        }
    }
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct GrabBoxValues {
    pub hitbox_id: i32,
    pub size: f32,
    pub set_action: i32,
    pub target: GrabTarget,
    pub unk: Option<i32>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct HitBoxValues {
    pub hitbox_id: u8,
    pub set_id: u8,
    pub damage: f32,
    pub trajectory: i32,
    pub wdsk: i16,
    pub kbg: i16,
    pub shield_damage: i16,
    pub bkb: i16,
    pub size: f32,
    pub tripping_rate: f32,
    pub hitlag_mult: f32,
    pub sdi_mult: f32,
    pub effect: HitBoxEffect,
    pub sound_level: u8,
    pub sound: HitBoxSound,
    pub ground: bool,
    pub aerial: bool,
    pub sse_type: HitBoxSseType,
    pub clang: bool,
    pub direct: bool,
    pub rehit_rate: i32,
    pub angle_flipping: AngleFlip,
    pub stretches_to_bone: bool,
    pub can_hit1: bool,
    pub can_hit2: bool,


r() {
                mesh_radius =
                    mesh_radius.max(Vec3::from(vertex_positions[*index as usize]).length());
            }
        }
        BoundingSphere {
            mesh_radius,
            transformed_radius: None,
        }
    }
}

#[allow(dead_code)]
pub enum RaycastAlgorithm {
    Geometric,
    MollerTrumbore(Backfaces),
}

impl Default for RaycastAlgorithm {
    fn default() -> Self {
        RaycastAlgorithm::MollerTrumbore(Backfaces::Cull)
    }
}

#[allow(dead_code)]
pub enum Backfaces {
    Cull,
    Include,
}

/// Takes a ray and triangle and computes the intersection and normal
pub fn ray_triangle_intersection(
    ray: &Ray3d,
    triangle: &Triangle,
    algorithm: RaycastAlgorithm,
) -> Option<Ray3d> {
    match algorithm {
        RaycastAlgorithm::Geometric => raycast_geometric(ray, triangle),
        RaycastAlgorithm::MollerTrumbore(backface_culling) => {
            raycast_moller_trumbore(ray, triangle, backface_culling)
        }
    }
}

/// Implementation of the Möller-Trumbore ray-triangle intersection test
pub fn raycast_moller_trumbore(
    ray: &Ray3d,
    triangle: &Triangle,
    backface_culling: Backfaces,
) -> Option<Ray3d> {
    // Source: https://www.scratchapixel.com/lessons/3d-basic-rendering/ray-tracing-rendering-a-triangle/moller-trumbore-ray-triangle-intersection
    let epsilon: f32 = 0.000001;
    let vector_v0_to_v1: Vec3 = triangle.v1 - triangle.v0;
    let vector_v0_to_v2: Vec3 = triangle.v2 - triangle.v0;
    let p_vec: Vec3 = ray.direction().cross(vector_v0_to_v2);
    let determinant: f32 = vector_v0_to_v1.dot(p_vec);

    match backface_culling {
        Backfaces::Cull => {
            // if the determinant is negative the triangle is backfacing
            // if the determinant is close to 0, the ray misses the triangle
            // This test checks both cases
            if determinant < epsilon {
                return None;
            }
        }
        Backfaces::Include => {
            // ray and triangle are parallel if det is close to 0
            if determinant.abs() < epsilon {
                return None;
            }
        }
    }

    let determinant_inverse = 1.0 / determinant;

    let t_vec: Vec3 = *ray.origin() - triangle.v0;
    let u = t_vec.dot(p_vec) * determinant_inverse;
    if u < 0.0 || u > 1.0 {
        return None;
    }

    let q_vec = t_vec.cross(vector_v0_to_v1);
    let v = ray.direction().dot(q_vec) * determinant_inverse;
    if v < 0.0 || u + v > 1.0 {
        return None;
    }

    // The distance between ray origin and intersection is t.
    let t: f32 = vector_v0_to_v2.dot(q_vec) * determinant_inverse;

    // Move along the ray direction from the origin, to find the intersection
    let point_intersection = *ray.origin() + *ray.direction() * t;
    let triangle_normal = vector_v0_to_v1.cross(vector_v0_to_v2);

    Some(Ray3d::new(point_intersection, triangle_normal))
}

/// Geometric method of computing a ray-triangle intersection
pub fn raycast_geometric(ray: &Ray3d, triangle: &Triangle) -> Option<Ray3d> {
    // Source: https://www.scratchapixel.com/lessons/3d-basic-rendering/ray-tracing-rendering-a-triangle/ray-triangle-intersection-geometric-solution
    let epsilon = 0.000001;

    // compute


zdır, bence.

cinarnamik@hotmail.com

Kaynak: [taraf.com.tr](http://www.taraf.com.tr:80/namik-cinar/makale-yakici-konular.htm), [web.archive.org (arşiv bağlantısı)](http://web.archive.org/web/20100611011450/http://www.taraf.com.tr:80/namik-cinar/makale-yakici-konular.htm)
# İslâmiyet bağdaş kurduğu için mi geri kaldı

*Namık Çınar 16.08.2013*

Bazı toplumlar var ki, yaşama alanlarında ya kolaylık buldukları için, ya da tam tersine, coğrafyaları kendilerine kesinlikle yüz vermediği için kapitalistleşemediler.

Sanırım Ortadoğu, yani İslâm âlemi bu ikincilere giriyor.

Tabii kapitalistleşemedikleri için de modernleşemediler.

Bugünün geri kalmış yurtları dünyanın kapitalistleşme süreçlerinde yer almadıklarından, o sıralarda hane halklarının ihtiyacı kadarlık bir tarımsal üretim yapmakla yetiniyorlar; arkadan gelip eklenen genç nüfus fazlası da, baştaki, hattâ komşu ülkelerdeki despotların periyodik fetih ve talanlarına asker yazılıyorlardı.

Hâlâ yaşayan ama bugün artık kadın sömürüsü olduğuna kanaat getirdiğimiz kadim bir Anadolu geleneği olarak kadınların tarlaya çalışmaya giderken erkeklerin köy kahvesinde pineklemesi vakıası, topraktan umuru kalmamış erkeğin maişetini ve nasibini talandan çıkarmak için acaba sefer mevsimini beklemesi yüzünden miydi dersiniz?

Nitekim kapitalistleşemeyen bu coğrafya insanlarının, sapır sapır ölmekten yaşlanmaya da fırsatları olmazdı.

O yüzden İslâmiyet’te çok kadınla evlenme nedenlerini de, bozkır ve çöl yaşamının zorluklarındaki doğum ve ölümlerin telâfi gayretlerinde aramak gerekir. Zira çok sayıda kadın rahminin gebe kalmasında toplumsal fayda vardı.

Bir taraftan da yokluk ve yoksulluk gırtlağa kadardır.

O gırtlağı besleyecek olan mutfak kültürünün temel girdisi de tahıldır.

Yani ekmek!

Diğer her şey, sadece ekmeğin yavan yenmemesine yarayan katıklardır.

Çorbalar, içine ekmek doğransın; tencere yemekleri, suyuna ekmek bandırılsın; kahvaltılıklar, ekmek dilimine sürülsün diye vardırlar.

Azla yetinen ve tam doymayan bu top


锐情': [['ruì'], ['qíng']],
    '锐意': [['ruì'], ['yì']],
    '锐意进取': [['ruì'], ['yì'], ['jìn'], ['qǔ']],
    '锐挫望绝': [['ruì'], ['cuò'], ['wàng'], ['jué']],
    '锐挫气索': [['ruì'], ['cuò'], ['qì'], ['suǒ']],
    '锐敏': [['ruì'], ['mǐn']],
    '锐旅': [['ruì'], ['lǚ']],
    '锐景': [['ruì'], ['jǐng']],
    '锐智': [['ruì'], ['zhì']],
    '锐果': [['ruì'], ['guǒ']],
    '锐标': [['ruì'], ['biāo']],
    '锐步': [['ruì'], ['bù']],
    '锐武': [['ruì'], ['wǔ']],
    '锐气': [['ruì'], ['qì']],
    '锐泽': [['ruì'], ['zé']],
    '锐眦': [['ruì'], ['zì']],
    '锐眼': [['ruì'], ['yǎn']],
    '锐立': [['ruì'], ['lì']],
    '锐端': [['ruì'], ['duān']],
    '锐笔': [['ruì'], ['bǐ']],
    '锐精': [['ruì'], ['jīng']],
    '锐翰': [['ruì'], ['hàn']],
    '锐藻': [['ruì'], ['zǎo']],
    '锐虑': [['ruì'], ['lǜ']],
    '锐角': [['ruì'], ['jiǎo']],
    '锐评': [['ruì'], ['píng']],
    '锐身': [['ruì'], ['shēn']],
    '锐达': [['ruì'], ['dá']],
    '锐进': [['ruì'], ['jìn']],
    '锐逸': [['ruì'], ['yì']],
    '锐锋': [['ruì'], ['fēng']],
    '锐锒': [['ruì'], ['láng']],
    '锐阵': [['ruì'], ['zhèn']],
    '锐顶': [['ruì'], ['dǐng']],
    '锐骑': [['ruì'], ['qí']],
    '锑华': [['tī'], ['huá']],
    '锒铛': [['láng'], ['dāng']],
    '锒铛入狱': [['láng'], ['dāng'], ['rù'], ['yù']],
    '锒镗': [['láng'], ['táng']],
    '锓木': [['qǐn'], ['mù']],
    '锓本': [['qǐn'], ['běn']],
    '锓板': [['qǐn'], ['bǎn']],
    '锓枣': [['qǐn'], ['zǎo']],
    '锓梓': [['qǐn'], ['zǐ']],
    '锓版': [['qǐn'], ['bǎn']],
    '锓画': [['qǐn'], ['huà']],
    '锔子': [['jū'], ['zi']],
    '锔碗儿的': [['jū'], ['wǎn'], ['ér'], ['de']],
    '锔碗匠': [['jū'], ['wǎn'], ['jiàng']],
    '锕系元素': [['ā'], ['xì'], ['yuán'], ['sù']],
    '锖色': [['qiāng'], ['sè']],
    '错举': [['cuò'], ['jǔ']],
    '错义突变': [['cuò'], ['yì'], ['tū'], ['biàn']],
    '错乱': [['cuò'], ['luàn']],
    '错事': [['cuò'], ['shì']],
    '错互': [['cuò'], ['hù']],
    '错仪画制': [['cuò'], ['yí'], ['huà'], ['zhì']],
    '错位': [['cuò'], ['wèi']],
    '错兵': [['cuò'], ['bīng']],
    '错出': [['cuò'], ['chū']],
    '错刀': [['cuò'], ['dāo']],
    '错分': [['cuò'], ['fēn']],
    '错刑': [['cuò'], ['xíng']],
    '错列': [['cuò'], ['liè']],
    '错别字': [['cuò'], ['bié'], ['zì']],
    '错到底': [['cuò'], ['dào'], ['dǐ']],
    '错动': [['cuò'], ['dòng']],
    '错发': [['cuò'], ['fā']],
    '错口': [['cuò'], ['kǒu']],
    '错合': [['cuò'], ['hé']],
    '错啎': [['cuò'], ['wǔ']],
    '错喉': [['cuò'], ['hóu']],
    '错壤': [['cuò'], ['rǎng']],
    '错处': [['cuò'], ['chǔ']],
    '错失': [['cuò'], ['shī']],
    '错头': [['cuò'], ['tóu']],
    '错字': [['cuò'], ['zì']],
    '错守': [['cuò'], ['shǒu']],
    '错安头': [['cuò'], ['ān'], ['tóu']],
    '错宝': [['cuò'], ['bǎo']],
    '错层': [['cuò'], ['céng']],
    '错居': [['cuò'], ['jū']],
    '错峙': [['cuò'], ['zhì']],
    '错峰': [['cuò'], ['fēng']],
    '错崔': [['cuò'], ['cuī']],
    '错崿': [['cuò'], ['è']],
    '错带': [['cuò'], ['dài']],
    '错开': [['cuò'], ['kāi']],
    '错彩': [['cuò'], ['cǎi']],
    '错彩镂金': [['cuò'], ['cǎi'], ['lòu'], ['jīn']],
    '错待': [['cuò'], ['dài']],
    '错忙': [['cuò'], ['máng']],
    '错忤': [['cuò'], ['wǔ']],
    '错念': [['cuò'], ['niàn']],
    '错怪': [['cuò'], ['guài']],
    '错悮': [['cuò'], ['wù']],
    '错意': [['cuò'], ['yì']],
    '错愕': [['cuò'], ['è']],
    '错戾': [['cuò'], ['lì']],
    '错手': [['cuò'], ['shǒu']],
    '错扳': [['cuò'], ['bān']],
    '错折': [['cuò'], ['shé']],
    '错择': [['cuò'], ['zé']],
    '错指': [['cuò'], ['zhǐ']],
    '错揉': [['cuò'], ['róu']],
    '错支剌': [['cuò'], ['zhī'], ['là']],
    '错文': [['cuò'], ['wén']],
    '错断': [['cuò'], ['duàn']],
    '错时': [['cuò'], ['shí']],
}

from pypinyin import load_phrases_dict

def load():
    load_phrases_dict(phrases_dict)


LK("l2c0", -1, SH_CLK, HWBLK_L2C, CLK_ENABLE_ON_INIT),
	SH_HWBLK_CLK("fpu0", -1, I_CLK, HWBLK_FPU, CLK_ENABLE_ON_INIT),
	SH_HWBLK_CLK("intc0", -1, P_CLK, HWBLK_INTC, CLK_ENABLE_ON_INIT),
	SH_HWBLK_CLK("dmac0", -1, B_CLK, HWBLK_DMAC0, 0),
	SH_HWBLK_CLK("sh0", -1, SH_CLK, HWBLK_SHYWAY, CLK_ENABLE_ON_INIT),
	SH_HWBLK_CLK("hudi0", -1, P_CLK, HWBLK_HUDI, 0),
	SH_HWBLK_CLK("ubc0", -1, I_CLK, HWBLK_UBC, 0),
	SH_HWBLK_CLK("tmu0", -1, P_CLK, HWBLK_TMU0, 0),
	SH_HWBLK_CLK("cmt0", -1, R_CLK, HWBLK_CMT, 0),
	SH_HWBLK_CLK("rwdt0", -1, R_CLK, HWBLK_RWDT, 0),
	SH_HWBLK_CLK("dmac1", -1, B_CLK, HWBLK_DMAC1, 0),
	SH_HWBLK_CLK("tmu1", -1, P_CLK, HWBLK_TMU1, 0),
	SH_HWBLK_CLK("scif0", -1, P_CLK, HWBLK_SCIF0, 0),
	SH_HWBLK_CLK("scif1", -1, P_CLK, HWBLK_SCIF1, 0),
	SH_HWBLK_CLK("scif2", -1, P_CLK, HWBLK_SCIF2, 0),
	SH_HWBLK_CLK("scif3", -1, B_CLK, HWBLK_SCIF3, 0),
	SH_HWBLK_CLK("scif4", -1, B_CLK, HWBLK_SCIF4, 0),
	SH_HWBLK_CLK("scif5", -1, B_CLK, HWBLK_SCIF5, 0),
	SH_HWBLK_CLK("msiof0", -1, B_CLK, HWBLK_MSIOF0, 0),
	SH_HWBLK_CLK("msiof1", -1, B_CLK, HWBLK_MSIOF1, 0),

	SH_HWBLK_CLK("keysc0", -1, R_CLK, HWBLK_KEYSC, 0),
	SH_HWBLK_CLK("rtc0", -1, R_CLK, HWBLK_RTC, 0),
	SH_HWBLK_CLK("i2c0", -1, P_CLK, HWBLK_IIC0, 0),
	SH_HWBLK_CLK("i2c1", -1, P_CLK, HWBLK_IIC1, 0),

	SH_HWBLK_CLK("mmc0", -1, B_CLK, HWBLK_MMC, 0),
	SH_HWBLK_CLK("eth0", -1, B_CLK, HWBLK_ETHER, 0),
	SH_HWBLK_CLK("atapi0", -1, B_CLK, HWBLK_ATAPI, 0),
	SH_HWBLK_CLK("tpu0", -1, B_CLK, HWBLK_TPU, 0),
	SH_HWBLK_CLK("irda0", -1, P_CLK, HWBLK_IRDA, 0),
	SH_HWBLK_CLK("tsif0", -1, B_CLK, HWBLK_TSIF, 0),
	SH_HWBLK_CLK("usb1", -1, B_CLK, HWBLK_USB1, 0),
	SH_HWBLK_CLK("usb0", -1, B_CLK, HWBLK_USB0, 0),
	SH_HWBLK_CLK("2dg0", -1, B_CLK, HWBLK_2DG, 0),
	SH_HWBLK_CLK("sdhi0", -1, B_CLK, HWBLK_SDHI0, 0),
	SH_HWBLK_CLK("sdhi1", -1, B_CLK, HWBLK_SDHI1, 0),
	SH_HWBLK_CLK("veu1", -1, B_CLK, HWBLK_VEU1, 0),
	SH_HWBLK_CLK("ceu1", -1, B_CLK, HWBLK_CEU1, 0),
	SH_HWBLK_CLK("beu1", -1, B_CLK, HWBLK_BEU1, 0),
	SH_HWBLK_CLK("2ddmac0", -1, SH_CLK, HWBLK_2DDMAC, 0),
	SH_HWBLK_CLK("spu0", -1, B_CLK, HWBLK_SPU, 0),
	SH_HWBLK_CLK("jpu0", -1, B_CLK, HWBLK_JPU, 0),
	SH_HWBLK_CLK("vou0", -1, B_CLK, HWBLK_VOU, 0),
	SH_HWBLK_CLK("beu0", -1, B_CLK, HWBLK_BEU0, 0),
	SH_HWBLK_CLK("ceu0", -1, B_CLK, HWBLK_CEU0, 0),
	SH_HWBLK_CLK("veu0", -1, B_CLK, HWBLK_VEU0, 0),
	SH_HWBLK_CLK("vpu0", -1, B_CLK, HWBLK_VPU, 0),
	SH_HWBLK_CLK("lcdc0", -1, B_CLK, HWBLK_LCDC, 0),
};

int __init arch_clk_init(void)
{
	int k, ret = 0;

	/* autodetect extal or fll configuration */
	if (__raw_readl(PLLCR) & 0x1000)
		pll_clk.parent = &fll_clk;
	else
		pll_clk.parent = &extal_clk;

	for (k = 0; !ret && (k < ARRAY_SIZE(main_clks)); k++)
		ret = clk_register(main_clks[k]);

	if (!ret)
		ret = sh_clk_div4_register(div4_clks, DIV4_NR, &div4_table);

	if (!ret)
		ret = sh_clk_div6_register(div6_clks, ARRAY_SIZE(div6_clks));

	if (!ret)
		ret = sh_hwblk_clk_register(mstp_clks, ARRAY_SIZE(mstp_clks));

	return ret;
}