></g><g data-mml-node="mo" transform="translate(11768.8,0)"><use data-c="29" xlink:href="#MJX-126-TEX-N-29"></use></g><g data-mml-node="msub" transform="translate(12157.8,0)"><g data-mml-node="mi"><use data-c="210E" xlink:href="#MJX-126-TEX-I-210E"></use></g><g data-mml-node="mi" transform="translate(609,-150) scale(0.707)"><use data-c="1D457" xlink:href="#MJX-126-TEX-I-1D457"></use></g></g></g></g></svg><mjx-assistive-mml unselectable="on" display="block"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mi mathvariant="normal">Δ</mi><msub><mi>v</mi><mrow data-mjx-texclass="ORD"><mi>j</mi><mi>k</mi></mrow></msub><mo>=</mo><mi>η</mi><mo stretchy="false">(</mo><msub><mi>y</mi><mi>k</mi></msub><mo>−</mo><mrow data-mjx-texclass="ORD"><mover><msub><mi>y</mi><mi>k</mi></msub><mo stretchy="false">^</mo></mover></mrow><mo stretchy="false">)</mo><mrow data-mjx-texclass="ORD"><mover><msub><mi>y</mi><mi>k</mi></msub><mo stretchy="false">^</mo></mover></mrow><mo stretchy="false">(</mo><mn>1</mn><mo>−</mo><mrow data-mjx-texclass="ORD"><mover><msub><mi>y</mi><mi>k</mi></msub><mo stretchy="false">^</mo></mover></mrow><mo stretchy="false">)</mo><msub><mi>h</mi><mi>j</mi></msub></math></mjx-assistive-mml></mjx-container>

其中<mjx-container class="MathJax" jax="SVG" style="position: relative;"><svg xmlns="http://www.w3.org/2000/svg" width="2.15ex" height="2.236ex" role="img" focusable="false" viewBox="0 -694 950.3 988.2" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" style="vertical-align: -0.666ex;"><defs><path id="MJX-80-TEX-I-210E" d="M137 683Q138 683 209 688T282 694Q294 694 294 685Q294 674 258 534Q220 386 220 383Q220 381 227 388Q288 442 357 442Q411 442 444 415T478 336Q478 285 440 178T402 50Q403 36 407 31T422 26Q450 26 474 56T513 138Q516 149 519 151T535 153Q555 153 555 145Q555 144 551 130Q535 71 500 33Q466 -10 419 -10H414Q367 -10 346 17T325 74Q325 90 361 192T398 345Q398 404 354 404H349Q266 404 205 306L198 293L164 158Q132 28 127 16Q114 -11 83 -11Q69 -11 59 -2T48 16Q48 30 121 320L195 616Q195 629 188 632T149 637H128Q122 643 122 645T124 664Q129 683 137 683Z"></path><path id="MJX-80-TEX-I-1D457" d="M297 596Q297 627 318 644T361 661Q378 661 389 651T403 623Q403 595 384 576T340 557Q322 557 310 567T297 596ZM288 376Q288 405 262 405Q240 405 220 393T185 362T161 325T144 293L137 279Q135 278 121 278H107Q101 284 101 286T105 299Q126 348 164


checked_enum,method,None)\n    simple_method=getattr(simple_enum,method,None)\n    if hasattr(checked_method,'__func__'):\n     checked_method=checked_method.__func__\n     simple_method=simple_method.__func__\n    if checked_method !=simple_method:\n     failed.append(\"%r:  %-30s %s\"%(\n     method,\n     \"checked -> %r\"%(checked_method,),\n     \"simple -> %r\"%(simple_method,),\n     ))\n   else:\n   \n   \n    pass\n if failed:\n  raise TypeError('enum mismatch:\\n   %s'%'\\n   '.join(failed))\n  \ndef _old_convert_(etype,name,module,filter,source=None,*,boundary=None):\n ''\n\n \n \n \n \n \n \n module_globals=sys.modules[module].__dict__\n if source:\n  source=source.__dict__\n else:\n  source=module_globals\n  \n  \n  \n members=[\n (name,value)\n for name,value in source.items()\n if filter(name)]\n try:\n \n  members.sort(key=lambda t:(t[1],t[0]))\n except TypeError:\n \n  members.sort(key=lambda t:t[0])\n cls=etype(name,members,module=module,boundary=boundary or KEEP)\n return cls\n \n_stdlib_enums=IntEnum,StrEnum,IntFlag\n",["builtins","functools","operator","sys","types","warnings"]],errno:[".py","''\n\n\n\n\n\n\n\n\n\n\n\n\n\nE2BIG=7\n\nEACCES=13\n\nEADDRINUSE=10048\n\nEADDRNOTAVAIL=10049\n\nEAFNOSUPPORT=10047\n\nEAGAIN=11\n\nEALREADY=10037\n\nEBADF=9\n\nEBADMSG=104\n\nEBUSY=16\n\nECANCELED=105\n\nECHILD=10\n\nECONNABORTED=10053\n\nECONNREFUSED=10061\n\nECONNRESET=10054\n\nEDEADLK=36\n\nEDEADLOCK=36\n\nEDESTADDRREQ=10039\n\nEDOM=33\n\nEDQUOT=10069\n\nEEXIST=17\n\nEFAULT=14\n\nEFBIG=27\n\nEHOSTDOWN=10064\n\nEHOSTUNREACH=10065\n\nEIDRM=111\n\nEILSEQ=42\n\nEINPROGRESS=10036\n\nEINTR=4\n\nEINVAL=22\n\nEIO=5\n\nEISCONN=10056\n\nEISDIR=21\n\nELOOP=10062\n\nEMFILE=24\n\nEMLINK=31\n\nEMSGSIZE=10040\n\nENAMETOOLONG=38\n\nENETDOWN=10050\n\nENETRESET=10052\n\nENETUNREACH=10051\n\nENFILE=23\n\nENOBUFS=10055\n\nENODATA=120\n\nENODEV=19\n\nENOENT=2\n\nENOEXEC=8\n\nENOLCK=39\n\nENOLINK=121\n\nENOMEM=12\n\nENOMSG=122\n\nENOPROTOOPT=10042\n\nENOSPC=28\n\nENOSR=124\n\nENOSTR=125\n\nENOSYS=40\n\nENOTCONN=10057\n\nENOTDIR=20\n\nENOTEMPTY=41\n\nENOTRECOVERABLE=127\n\nENOTSOCK=10038\n\nENOTSUP=129\n\nENOTTY=25\n\nENXIO=6\n\nEOPNOTSUPP=10045\n\nEOVERFLOW=132\n\nEOWNERDEAD=133\n\nEPERM=1\n\nEPFNOSUPPORT=10046\n\nEPIPE=32\n\nEPROTO=134\n\nEPROTONOSUPPORT=10043\n\nEPROTOTYPE=10041\n\nERANGE=34\n\nEREMOTE=10071\n\nEROFS=30\n\nESHUTDOWN=10058\n\nESOCKTNOSUPPORT=10044\n\nESPIPE=29\n


   'test_kernel@kd'
// CHECK:          .vgpr_count:     14
// CHECK:          .vgpr_spill_count: 1
// CHECK:          .wavefront_size: 64
// CHECK:      amdhsa.version:
// CHECK-NEXT:   - 1
// CHECK-NEXT:   - 0
.amdgpu_metadata
  amdhsa.version:
    - 1
    - 0
  amdhsa.printf:
    - '1:1:4:%d\n'
    - '2:1:8:%g\n'
  amdhsa.kernels:
    - .name:            test_kernel
      .symbol:      test_kernel@kd
      .kernarg_segment_size:      24
      .group_segment_fixed_size:   24
      .private_segment_fixed_size: 16
      .kernarg_segment_align:     16
      .wavefront_size:           64
      .max_flat_workgroup_size:    256
      .sgpr_count:               40
      .vgpr_count:               14
      .sgpr_spill_count:         1
      .vgpr_spill_count:         1
.end_amdgpu_metadata


r.message);
                });
    };

    const body = (
        <Form isHorizontal>
            {cert["cert-storage"].v === "NSSDB" && <>
                <FormGroup label={_("Database path")} hasNoPaddingTop>
                    { cert["cert-database"].v }
                </FormGroup>
                <FormGroup label={_("Nickname")} hasNoPaddingTop>
                    { cert["cert-nickname"].v }
                </FormGroup>
            </>}

            {cert["cert-storage"].v === "FILE" && <>
                <FormGroup label={_("Certificate file")} hasNoPaddingTop>
                    { cert["cert-file"].v }
                </FormGroup>
                <FormGroup label={_("Key file")} hasNoPaddingTop>
                    { cert["key-file"].v }
                </FormGroup>
            </>}

            <CAsRow ca={ca} setCa={setCa} cas={Object.values(cas)} />

            <SubjectNameRow subjectName={subjectName} setSubjectName={setSubjectName} />
            <DNSNameRow dnsName={dnsName} setDnsName={setDnsName} />
            <PrincipalNameRow principalName={principalName} setPricipalName={setPricipalName} />
        </Form>
    );

    return (
        <Modal id="resubmit-certificate-dialog"
               position="top" variant="medium"
               onClose={onClose}
               isOpen
               title={_("Resubmit Certificate")}
               footer={<>
                   {errorName && <ModalError dialogError={errorName} dialogErrorDetail={errorMessage} />}
                   <Button variant="primary" onClick={onResubmit}>
                       {_("Resubmit")}
                   </Button>
                   <Button variant="link" className="btn-cancel" onClick={onClose}>
                       {_("Cancel")}
                   </Button>
               </>}>
            {body}
        </Modal>
    );
};

function makeNickName(hostname, ca) {
    // drop the unsightly 'Z' suffix and microseconds
    const timestamp = new Date().toISOString()
            .replace(/(\.\d+)?Z$/, '');
    return hostname + '_' + ca + '_' + timestamp;
}

export const RequestCertificateModal = ({ onClose, hostname, cas, addAlert, mode }) => {
    const [_userChangedNickname, setUserChangedNickname] = useState(false);
    const [ca, _setCa] = useState(cas[Object.keys(cas)[0]] ? cas[Object.keys(cas)[0]].nickname.v : undefined);
    const [storage, setStorage] = useState(mode === "request" ? "nssdb" : "file");
    const [nickname, _setNickname] = useState(makeNickName(hostname, ca));
    const [certFile, setCertFile] = useState("");
    const [keyFile, setKeyFile] = useState("");
    const [subjectName, setSubjectName] = useState("");
    const [dnsName, _setDnsName] = useState("");
    const [principalName, setPricipalName] = useState("");
    const [signingParameters, setSigningParameters] = useState("");
    const [errorName, setErrorName] = useState();
    const [errorMessage, setErrorMessage] = useState();

    const setCa = value => {
        if (!_userChangedNickname)
            _setNickname(makeNickName(hostname, value));

        _setCa(value);
    };

    const setNickname = value => {
        setUserChangedNickname(true);
        _setNickname(value);
    };

    const setDnsName = value => {
        value = value.replace(/\s/g, ',');
        while (value.includes(",,"))
            value = value.replace(",,", ',');
        _setDnsName(value);
    };

    const onRequest = () => {
        const casKeys = Object.keys(cas);
        let caPath;


 '../assets/images/pro3/28.jpg', '../assets/images/pro3/28.jpg', '../assets/images/pro3/28.jpg',
     '../assets/images/pro3/28.jpg', '../assets/images/pro3/28.jpg', '../assets/images/pro3/28.jpg', '../assets/images/pro3/28.jpg',
      '../assets/images/pro3/28.jpg', '../assets/images/pro3/28.jpg'];

    colors: string[] = ['Black', 'White', 'Red', 'Blue', 'Silver', 'Green', 'Yellow'];
    prices: string[] = ['1000', '2000', '3000', '212', '32323', '43434', '433434'];

    constructor(private http: HttpClient) { }

    getCarsSmall() {
        return this.http.get<any>('assets/cars-small.json')
        .toPromise()
        .then(res => <Car[]>res.data)
        .then(data => { return data; });
    }

    getCarsMedium() {
        return this.http.get<any>('assets/cars-medium.json')
        .toPromise()
        .then(res => <Car[]>res.data)
        .then(data => { return data; });
    }

    generateCar(): Car {
        return {
            product_name: this.generateProduct_name(),
            action: this.actions,
            year: this.generateYear(),
            price: this.generatePrice(),
            img: this.imgs

        }
    }

    generateProduct_name() {
        let text = "";
        let possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

        for (var i = 0; i < 5; i++) {
            text += possible.charAt(Math.floor(Math.random() * possible.length));
        }

        return text;
    }

    generateaction() {
        return this.actions[Math.floor(Math.random() * Math.floor(10))];
    }
    generatePrice() {
        return this.prices[Math.floor(Math.random() * Math.floor(10))];
    }

    generateColor() {
        return this.colors[Math.floor(Math.random() * Math.floor(7))];
    }

    generateYear() {
        return 2000 + Math.floor(Math.random() * Math.floor(19));
    }

}/**
 * 1つ分の会話内容
 */
export class TalkData{
    /**
     * ID
     */
    id: number = 0;

    /**
     * キャラ名
     */
    name: string = "";

    /**
     * 喋る内容
     */
    message: string = "";

    /**
     * 表示する画像のURL
     */
    url: string = "assets/images/producer_p_head/P-suite.png";

    /**
     * 表示する画像のURLその2
     */
    url2: string = "assets/images/kotori/1100234b19f.png";

    /**
     * ファボ数
     */
    favs: string = "1234";

    /**
     * タイムスタンプ
     */
    date: string = "01-02 03:04"

    /**
     * 選択されているか？
     */
    selected: boolean = false;

    get selected2(): string{
        return this.selected ? "true" : "false";
    }
}
import { GameLoadData } from "../models/game-load-data";
import { ConvertToInt } from "./convert-to-int";

//
// c0  --> 1st code verifier (Has to be 'E')
// c1  --> Score (total8thHex) 15 x 1
// c2  --> Satellite State
// c3  --> Score (total5thHex) 15 x 4,096
// c4  --> Difficulty Level
// c5  --> Scor


source.settingVersion
                            ) throw ErrorCodeException(
                                errorCode = ProcessMessageCode.ERROR_VERSION_IS_NOT_UPDATED
                            )
                            draftVersion.model.getTriggerContainer().buildNo?.let {
                                val releaseBuildNo = releaseResource.model.getTriggerContainer().buildNo
                                // [关闭变为开启]或[修改buildNo数值]，都属于更新行为，需要提示更新
                                if (releaseBuildNo == null || releaseBuildNo.buildNo != it.buildNo) {
                                    updateBuildNo = true
                                }
                            }
                            draftVersion.version
                        } else {
                            // 兼容逻辑：没有已有草稿保存正式版本时，直接增加正式版本，基准为上一个发布版本
                            // 创建新版本记录
                            realBaseVersion = realBaseVersion ?: releaseResource.version
                            latestVersion.version + 1
                        }
                        logger.info(
                            "PROCESS|$userId|releasePipeline|$projectId|$pipelineId|" +
                                "version=$version|versionName=$versionName"
                        )
                        watcher.start("updatePipelineResource")
                        pipelineInfoDao.update(
                            dslContext = transactionContext,
                            projectId = projectId,
                            pipelineId = pipelineId,
                            userId = if (updateLastModifyUser == false) null else userId,
                            version = version,
                            pipelineName = null,
                            pipelineDesc = null,
                            manualStartup = canManualStartup,
                            canElementSkip = canElementSkip,
                            taskCount = taskCount,
                            latestVersion = model.latestVersion,
                            // 进行过至少一次发布版本后，取消仅有草稿/分支的状态
                            latestVersionStatus = VersionStatus.RELEASED,
                            locked = pipelineDisable
                        )
                        pipelineResourceDao.updateReleaseVersion(
                            dslContext = transactionContext,
                            projectId = projectId,
                            pipelineId = pipelineId,
                            version = version,
                            model = model,
                            yamlStr = yaml?.yamlStr,
                            yamlVersion = yaml?.versionTag,
                            versionName = versionName,
                            versionNum = versionNum,
                            pipelineVersion = pipelineVersion,
                            triggerVersion = triggerVersion,
                            settingVersion = settingVersion
                        )
                        watcher.start("updatePipelineModelTask")
                        pipelineModelTaskDao.deletePipelineTasks(
                            dslContext = transactionContext,
                            projectId = projectId,
                            pipelineId = pipelineId
                        )
                        pipelineModelTaskDao.batchSave(transactionContext, modelTasks)
                        // 保存流水线单体回调记录
                        savePipelineCallback(
                            dslContext = transactionContext,
                            projectId = projectId,
                            pipelineId = pipelineId,
                            userId = userId,
                            events = model.events
                        )
                        watcher.start("updateSubPipelineRef")
                        // 批量保存,禁用态的插件需要被删除
                        subPipelineTaskService.batchAdd(
                            dslContext = transactionContext,
                            projectId = projectId,
                            pipelineId = pipelineId,
                            model = model,
                            channel = channelCode.name,
                            modelTasks = modelTasks.toList()
                        )
                    }
                }

                watcher.start("updatePipelineResourceVersion")
                pipelineResourceVersionDao.create(
                    dslContext = transactionContext,


hibernate.validator.constraints.Length;
import javax.validation.constraints.NotNull;
import com.fasterxml.jackson.annotation.JsonBackReference;

import com.jeespring.common.persistence.TreeEntity;

/**
 * 树Entity
 * @author JeeSpring
 * @version 2018-12-13
 */
public class TestTree extends TreeEntity<TestTree> {

	private static final long serialVersionUID = 1L;
	private String name;		// 名称
	private Integer sort;		// 排序
	private TestTree parent;		// 父级编号
	private String parentIds;		// 所有父级编号

	public TestTree() {
		super();
	}

	public TestTree(String id){
		super(id);
	}

	@Length(min=1, max=100, message="名称长度必须介于 1 和 100 之间")
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@NotNull(message="排序不能为空")
	public Integer getSort() {
		return sort;
	}

	public void setSort(Integer sort) {
		this.sort = sort;
	}

	@JsonBackReference
	@NotNull(message="父级编号不能为空")
	public TestTree getParent() {
		return parent;
	}

	public void setParent(TestTree parent) {
		this.parent = parent;
	}

	@Length(min=1, max=2000, message="所有父级编号长度必须介于 1 和 2000 之间")
	public String getParentIds() {
		return parentIds;
	}

	public void setParentIds(String parentIds) {
		this.parentIds = parentIds;
	}

	public String getParentId() {
		return parent != null && parent.getId() != null ? parent.getId() : "0";
	}
}/**
 * * Copyright © 2015-2020 JeeSpringCloud All rights reserved..
 */
package com.company.project.modules.ylttrip.service;

import java.util.List;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;

import com.jeespring.common.persistence.Page;
import com.jeespring.common.service.AbstractBaseService;
import com.company.project.modules.ylttrip.entity.TfTicket;
import com.company.project.modules.ylttrip.dao.TfTicketDao;
import com.company.project.modules.ylttrip.service.ITfTicketService;
import com.alibaba.fastjson.JSON;
import com.jeespring.common.redis.RedisUtils;
import com.jeespring.common.security.MD5Tools;
//import com.alibaba.dubbo.config.annotation.Service;
import com.jeespring.common.config.Global;

/**
 * 订单Service
 * @author JeeSpring
 * @version 2018-12-13
 */
 //启用dubbo服务器时，要去掉下面注解
 //com.alibaba.dubbo.config.annotation.Service(interfaceClass = ISysServerService.class,version = "1.0.0", timeout = 60000)
@org.springframework.stereotype.Service
@Transactional(readOnly = t


ublic CreateProductCommandHandler(IApplicationDbContext context)
            {
                _context = context;
            }
            public async Task<int> Handle(CreateProductCommand command, CancellationToken cancellationToken)
            {
                var product = new Product();
                product.Barcode = command.Barcode;
                product.Name = command.Name;
                product.Rate = command.Rate;
                product.Description = command.Description;
                _context.Products.Add(product);
                await _context.SaveChangesAsync();
                return product.Id;
            }
        }
    }
}


 62%);
$c: 'R27 @insvale', hsl(166, 60%, 52%);
$c: 'R27 @insvale', hsl(154, 85%, 37%);
$c: 'https://coolors.co',toggle view and resize ui to arrange the colors;
$c: 'Untitled @jaagup.susi', hsl(63, 28%, 72%);
$c: 'Untitled @jaagup.susi', hsl(39, 100%, 83%);
$c: 'Untitled @jaagup.susi', hsl(8, 70%, 62%);
$c: 'Untitled @jaagup.susi', hsl(350, 30%, 34%);
$c: 'Untitled @jaagup.susi', hsl(353, 22%, 23%);
$c: 'https://coolors.co',toggle view and resize ui to arrange the colors;
$c: 'Beach Weekend @ajiwata', hsl(5, 100%, 81%);
$c: 'Beach Weekend @ajiwata', hsl(46, 74%, 92%);
$c: 'Beach Weekend @ajiwata', hsl(168, 69%, 84%);
$c: 'Beach Weekend @ajiwata', hsl(188, 45%, 78%);
$c: 'Beach Weekend @ajiwata', hsl(222, 10%, 41%);
$c: 'https://coolors.co',toggle view and resize ui to arrange the colors;
$c: 'Untitled @shapeshift', hsl(173, 70%, 35%);
$c: 'Untitled @shapeshift', hsl(233, 22%, 23%);
$c: 'Untitled @shapeshift', hsl(59, 100%, 75%);
$c: 'Untitled @shapeshift', hsl(18, 100%, 72%);
$c: 'Untitled @shapeshift', hsl(355, 78%, 60%);
$c: 'https://coolors.co',toggle view and resize ui to arrange the colors;
$c: 'Marieke by djenkal', hsl(186, 100%, 55%);
$c: 'Marieke by djenkal', hsl(130, 76%, 68%);
$c: 'Marieke by djenkal', hsl(67, 100%, 55%);
$c: 'Marieke by djenkal', hsl(42, 84%, 49%);
$c: 'Marieke by djenkal', hsl(17, 100%, 54%);
$c: 'https://coolors.co',toggle view and resize ui to arrange the colors;
$c: 'Untitled @krispykrista', hsl(29, 79%, 72%);
$c: 'Untitled @krispykrista', hsl(4, 99%, 66%);
$c: 'Untitled @krispykrista', hsl(52, 31%, 77%);
$c: 'Untitled @krispykrista', hsl(132, 56%, 86%);
$c: 'Untitled @krispykrista', hsl(76, 57%, 91%);
$c: 'https://coolors.co',toggle view and resize ui to arrange the colors;
$c: 'Feminina @carolinekvall', hsl(144, 73%, 90%);
$c: 'Feminina @carolinekvall', hsl(278, 82%, 87%);
$c: 'Feminina @carolinekvall', hsl(332, 84%, 77%);
$c: 'Feminina @carolinekvall', hsl(54, 63%, 81%);
$c: 'Feminina @carolinekvall', hsl(200, 87%, 82%);
$c: 'https://coolors.co',toggle view and resize ui to arrange the colors;
$c: 'Untitled @kelly', hsl(60, 53%, 97%);
$c: 'Untitled @kelly', hsl(90, 4%, 90%);
$c: 'Untitled @kelly', hsl(96, 5%, 81%);
$c: 'Untitled @kelly', hsl(0, 2%, 64%);
$c: 'Untitled @kelly', hsl(352, 6%, 49


dashoffset: -97px;
  transition-delay: 20ms;
}
.active.plate7 .line4 {
  stroke-dasharray: 2 97;
  stroke-dashoffset: -97px;
  transition-delay: 20ms;
}
.active.plate7 .line5 {
  stroke-dasharray: 2 92;
  stroke-dashoffset: -90px;
  transition-delay: 40ms;
}
.active.plate7 .line6 {
  stroke-dasharray: 2 102;
  stroke-dashoffset: -100px;
  transition-delay: 40ms;
}
.active.plate7 .x {
  transition: transform 400ms 50ms;
}
/* Όγδοο πιάτο */
.plate8 .line {
  transition: stroke-dasharray 400ms 100ms, stroke-dashoffset 400ms 100ms, transform 400ms 100ms;
}
.plate8 .line1 {
  stroke-dasharray: 21 201;
}
.plate8 .line2 {
  stroke-dasharray: 21 201;
  transition-delay: 20ms;
}
.plate8 .line3 {
  stroke-dasharray: 21 201;
  transition-delay: 40ms;
}
.plate8 .line4 {
  stroke-dasharray: 21 201;
  transition-delay: 60ms;
}
.plate8 .line5 {
  stroke-dasharray: 21 201;
  transition-delay: 80ms;
}
.plate8 .line6 {
  stroke-dasharray: 21 201;
  transition-delay: 100ms;
}
.plate8 .x {
  transition: transform 400ms 50ms;
}

.active.plate8 .line {
  transition: stroke-dasharray 400ms, stroke-dashoffset 400ms, transform 400ms;
}
.active.plate8 .line1 {
  stroke-dasharray: 5 201;
  stroke-dashoffset: -158px;
}
.active.plate8 .line2 {
  stroke-dasharray: 5 201;
  stroke-dashoffset: -158px;
  transition-delay: 20ms;
}
.active.plate8 .line3 {
  stroke-dasharray: 5 201;
  stroke-dashoffset: -158px;
  transition-delay: 40ms;
}
.active.plate8 .line4 {
  stroke-dasharray: 5 201;
  stroke-dashoffset: -158px;
  transition-delay: 60ms;
}
.active.plate8 .line5 {
  stroke-dasharray: 5 201;
  stroke-dashoffset: -158px;
  transition-delay: 80ms;
}
.active.plate8 .line6 {
  stroke-dasharray: 5 201;
  stroke-dashoffset: -158px;
  transition-delay: 100ms;
}
.active.plate8 .x {
  transition: transform 400ms 50ms;
}@import url("https://fonts.googleapis.com/css2?family=Poppins:wght@100;200;300;400;500;600;700;800;900&display=swap");

* {
  margin: 0;
  padding: 0;
  box-sizing: border-box;
  font-family: "Poppins", sans-serif;
}

body {
  background: black;
  display: flex;
  align-items: center;
  justify-content: center;
  height: 100vh;
}

.container,
.circle,
.rating-names,
.stars {
  display: flex;
  align-items: center;
  justify-content: center;
}

.container {
  background-color: white;
  width: 550px;
  height: 400px;
  padding: 20px;
  flex-direction: column;
  gap: 20px;
  border-radius: 10px;
}

.container h1 {
  margin-top: -20px;
  text-transform: uppercase;
  word-spacing: 5px;
  font-size: 40px;
}

.circle {


import tkinter as tk
from tkinter import simpledialog
import random

def generate_teams(num_teams, players_per_team):
    total_players = num_teams * players_per_team
    players = [f"Player {i+1}" for i in range(total_players)]
    random.shuffle(players)

    teams = {f"Team {i+1}": players[i*players_per_team:(i+1)*players_per_team]
             for i in range(num_teams)}
    return teams

def display_teams(teams):
    text.delete('1.0', tk.END)
    for team, members in teams.items():
        text.insert(tk.END, f"{team}: {', '.join(members)}\n")

def on_submit():
    num_teams = int(team_entry.get())
    players_per_team = int(player_entry.get())
    teams = generate_teams(num_teams, players_per_team)
    display_teams(teams)

root = tk.Tk()
root.title("Game Mod - Team Generator")

tk.Label(root, text="Number of Teams:").pack()
team_entry = tk.Entry(root)
team_entry.pack()

tk.Label(root, text="Players per Team:").pack()
player_entry = tk.Entry(root)
player_entry.pack()

submit_button = tk.Button(root, text="Generate Teams", command=on_submit)
submit_button.pack()

text = tk.Text(root)
text.pack()

root.mainloop()


[] shouldBurn = new bool[burnEffects.Length];
            switch (burnEffects.Length)
            {
                case 5:
                    shouldBurn[0] = healthPerc < 0.8f;

                    shouldBurn[1] = healthPerc < 0.5f;

                    shouldBurn[2] = healthPerc < 0.25f;
                    shouldBurn[3] = healthPerc < 0.25f;

                    shouldBurn[4] = healthPerc < 0.1f;
                    break;
                case 4:
                case 3:
                    shouldBurn[0] = healthPerc < 0.75f;
                    shouldBurn[1] = healthPerc < 0.5f;
                    for (int i = 2; i < burnEffects.Length; i++)
                    {
                        shouldBurn[i] = healthPerc < 0.25f;
                    }
                    break;
                case 2:
                    shouldBurn[0] = healthPerc < 0.66f;
                    shouldBurn[1] = healthPerc < 0.33f;
                    break;
                case 1:
                    shouldBurn[0] = healthPerc < 0.5f;
                    break;
                case 0:
                    return;
            }

            for (int i = 0; i < burnEffects.Length; i++)
            {
                if (shouldBurn[i] != burnEffects[i].isPlaying)
                {
                    if (shouldBurn[i])
                    {
                        burnEffects[i].Play(true);
                    }
                    else
                    {
                        burnEffects[i].Stop(true, ParticleSystemStopBehavior.StopEmitting);
                    }
                }
            }
        }
    }

    public override void Die()
    {
        base.Die();

        state = BuildingStates.Dead; //still makes sense to set it, because somebody might be interacting with this script before it is destroyed

        SetSelected(false);

        TriggerBurnEffects();

        faction.data.buildings.Remove(this);

        navMeshObstacle.enabled = false;

        //Remove unneeded Components
        StartCoroutine(HideSeenThings(visionFadeTime));
        StartCoroutine(VisionFade(visionFadeTime, true));
        StartCoroutine(DecayIntoGround());
    }
}


import unittest
from unittest.mock import patch

from pyecharts import options as opts
from pyecharts.charts import GMap
from pyecharts.globals import ChartType

FAKE_API_KEY = "fake_application_key"
GMAP_API_PREFIX = "https://maps.googleapis.com/maps/api/js"

TEST_LOCATION = ["London"]
TEST_VALUE = [1]

class TestGMapChart(unittest.TestCase):

    @patch("pyecharts.render.engine.write_utf8_html_file")
    def test_gmap(self, fake_writer):
        gmap = (
            GMap()
            .add_schema(gmap_ak=FAKE_API_KEY, center=[-0.118092, 51.509865])
            .add_coordinate("London", -0.118092, 51.509865)
            .add(
                "gmap",
                [list(z) for z in zip(TEST_LOCATION, TEST_VALUE)],
                label_opts=opts.LabelOpts(formatter="{b}"),
            )
        )
        gmap.render()
        content = fake_writer.call_args[0][1]
        self.assertIn(f'src="{GMAP_API_PREFIX}?key={FAKE_API_KEY}', content)
        self.assertIn('"coordinateSystem": "gmap"', content, "non gmap found")

    @patch("pyecharts.render.engine.write_utf8_html_file")
    def test_gmap_map_control_panel(self, fake_writer):
        gmap = (
            GMap()
            .add_schema(gmap_ak=FAKE_API_KEY, center=[-0.118092, 51.509865])
            .add_coordinate("London", -0.118092, 51.509865)
            .add(
                "amap",
                [list(z) for z in zip(TEST_LOCATION, TEST_VALUE)],
                label_opts=opts.LabelOpts(formatter="{b}"),
            )
            .add_control_panel(is_add_traffic_layer=True)
        )
        gmap.render()
        content = fake_writer.call_args[0][1]
        self.assertIn("new google.maps.TrafficLayer", content)

    @patch("pyecharts.render.engine.write_utf8_html_file")
    def test_gmap_polyline_and_large(self, fake_writer):
        gmap = (
            GMap()
            .add_schema(gmap_ak=FAKE_API_KEY, center=[-0.118092, 51.509865])
            .add_coordinate("London", -0.118092, 51.509865)
            .add(
                "amap",
                [list(z) for z in zip(TEST_LOCATION, TEST_VALUE)],
                is_polyline=True,
                is_large=True,
                type_=ChartType.LINES,
                label_opts=opts.LabelOpts(formatter="{b}"),
            )
        )
        gmap.render()
        content = fake_writer.call_args[0][1]
        self.assertIn('"polyline": true', content, "polyline parameter is error")
        self.assertIn('"large": true', content, "large parameter is error")

    def test_gmap_heatmap(self):
        gmap = (
            GMap()
            .add_schema(gmap_ak=FAKE_API_KEY, center=[-0.118092, 51.509865])
            .add_coordinate("London", -0.118092, 51.509865)
            .add(
                "amap",
                [list(z) for z in zip(TEST_LOCATION, TEST_VALUE)],
                label_opts=opts.LabelOpts(formatter="{b}"),
            )
        )
        data = gmap.options.get("series")[0]["data"]
        for item in data:
            self.assertIn("name", item)
            self.assertIn("value", item)


덤불 골짜기에 있는 님보야에게 돌아가십시오."}},
[2933] = {"독병", {"이 병 안에는 사악한 녹색 독이 들어 있습니다.","이 마을에 깔려 있는 독병의 수를 감안하면 마른나무껍질부족이 상당히 중요하게 여기는 것 같습니다. 근처의 타렌 밀농장에 있는 연금술사가 견본을 원할지도 모릅니다."}, {"타렌 밀농장에 있는 연금술사에게 독병을 가져가야 합니다."}},
[2934] = {"온전한 독주머니", {"당신이 가져온 것보다 신선한 독의 견본이 필요하오. 이 독은 분명 동부 내륙지에 서식하는 거미에서 추출했을 거요. 녀석들을 잡아서 온전한 독주머니를 찾아 내게 가져와 주시오. 트롤들의 도시인 샤드라알로에 가면 거미를 많이 볼 수 있을 거요.","늑장 부리지 마시오. 독주머니는 반드시 신선한 상태로 가져와야 하니까."}, {"타렌 밀농장에 있는 연금술사 라이던에게 온전한 독주머니를 가져가야 합니다."}},
[2935] = {"가드린 장로와 상의", {"혈거미에게서 얻은 독은 당신이 애초에 가져왔던 것만큼 독성이 강하지 않았소. 아마 처음 것은 다른 거미에게서 얻은 것 같소.","그 독의 신선한 견본이 있었으면 좋겠소. 그 독이 어디서 난 것인지 알려면 마른나무껍질부족을 잘 아는 트롤과 상의를 해야 할 거요. 센진 마을의 가드린 장로라면 그 부족에 대해 많은 걸 알려 줄 거요. 듀로타로 가서 가드린과 얘기해 보시오. 운이 좋으면 마른나무껍질부족이 어디


           StopSound(platerInternal.LatestHandleForAudioPlayed, 500)
        end

        local channel = validChannels[Plater.db.cast_audiocues_channel] or defaultAudioChannel
        local bWillPlay, soundHandle = PlaySoundFile(audioCue, channel)

        if (bWillPlay) then
            platerInternal.LatestHandleForAudioPlayed = soundHandle
            platerInternal.LatestTimeForAudioPlayedByID[spellId] = GetTime()
        end
    end
end

--priority for user audio >> play defined in the cast colors tab >> player defined in the script
function Plater.PlayAudioForScript(canUseScriptAudio, audioFilePath, envTable) --exposed
    --user set an audio to play into the Cast Colors tab in the options panel
    local spellId = envTable._SpellID

    --audio set in the cast colors tab, if there are an audio set there for this spell, play it
    local audioByUser = platerInternal.Audio.GetAudioCueForSpell(envTable._SpellID)
    if (audioByUser) then
        platerInternal.Audio.PlaySoundForCastStart(spellId)
        return
    end

    --audio set in the script
    if (canUseScriptAudio and audioFilePath and type(audioFilePath) == "string") then
        platerInternal.Audio.PlaySoundForCastStart(spellId, audioFilePath)
    end
end


any dots or spaces at the end of the extension with the same number of underscores\\n\\textension = extension.replace(/[\\\\. ]+$/, function (u) { return u.replace(/[\\\\. ]/g, \\\"_\\\")});\\n\\t// Truncate the extension if it is too long\\n\\tif(extension.length > 32) {\\n\\t\\textension = extension.substr(0,32);\\n\\t}\\n\\t// If the filepath already ends in the extension then remove it\\n\\tif(filepath.substring(filepath.length - extension.length) === extension) {\\n\\t\\tfilepath = filepath.substring(0,filepath.length - extension.length);\\n\\t}\\n\\t// Truncate the filename if it is too long\\n\\tif(filepath.length > 200) {\\n\\t\\tfilepath = filepath.substr(0,200);\\n\\t}\\n\\t// If the resulting filename is blank (eg because the title is just punctuation)\\n\\tif(!filepath || /^_+$/g.test(filepath)) {\\n\\t\\t// ...then just use the character codes of the title\\n\\t\\tfilepath = \\\"\\\";\\n\\t\\t$tw.utils.each(title.split(\\\"\\\"),function(char) {\\n\\t\\t\\tif(filepath) {\\n\\t\\t\\t\\tfilepath += \\\"-\\\";\\n\\t\\t\\t}\\n\\t\\t\\tfilepath += char.charCodeAt(0).toString();\\n\\t\\t});\\n\\t}\\n\\t// Add a uniquifier if the file already exists (default)\\n\\tvar fullPath = path.resolve(directory, filepath + extension);\\n\\tif (!overwrite) {\\n\\t\\tvar oldPath = (options.fileInfo) ? options.fileInfo.filepath : undefined,\\n\\t\\tcount = 0;\\n\\t\\tdo {\\n\\t\\t\\tfullPath = path.resolve(directory,filepath + (count ? \\\"_\\\" + count : \\\"\\\") + extension);\\n\\t\\t\\tif(oldPath && oldPath == fullPath) break;\\n\\t\\t\\tcount++;\\n\\t\\t} while(fs.existsSync(fullPath));\\n\\t}\\n\\t// If the last write failed with an error, or if path does not start with:\\n\\t//\\tthe resolved options.directory, the resolved wikiPath directory, the wikiTiddlersPath directory, \\n\\t//\\tor the 'originalpath' directory, then $tw.utils.encodeURIComponentExtended() and resolve to options.directory.\\n\\tvar writePath = $tw.hooks.invokeHook(\\\"th-make-tiddler-path\\\",fullPath,fullPath),\\n\\t\\tencode = (options.fileInfo || {writeError: false}).writeError == true;\\n\\tif(!encode) {\\n\\t\\tencode = !(writePath.indexOf($tw.boot.wikiTiddlersPath) == 0 ||\\n\\t\\t\\twritePath.indexOf(path.resolve(directory)) == 0 ||\\n\\t\\t\\twritePath.indexOf(path.resolve($tw.boot.wikiPath)) == 0 ||\\n\\t\\t\\twritePath.indexOf(path.resolve($tw.boot.wikiTiddlersPath,originalpath)) == 0 );\\n\\t\\t}\\n\\tif(encode) {\\n\\t\\twritePath = path.resolve(directory,$tw.utils.encodeURIComponentExtended(fullPath));\\n\\t}\\n\\t// Return the full path to the file\\n\\treturn writePath;\\n};\\n\\n/*\\nSave a tiddler to a file described by the fileInfo:\\n\\tfilepath: the absolute path to the file containing the tiddler\\n\\ttype: the type of the tiddler file (NOT the type of the tiddler)\\n\\thasMetaFile: true if the file also has a companion .meta file\\n*/\\nexports.saveTidd


=adapter_names)

        key_list = [key for key, _ in self.named_modules()]
        desc = "Unloading " + ("and merging " if merge else "") + "model"

        for key in tqdm(key_list, disable=not progressbar, desc=desc):
            try:
                parent, target, target_name = _get_submodules(self, key)
            except AttributeError:
                continue

            if hasattr(target, "base_layer"):
                if merge:
                    merge_recursively(target)
                self._replace_module(parent, target_name, target.get_base_layer(), target)
            elif isinstance(target, ModulesToSaveWrapper):
                # save any additional trainable modules part of `modules_to_save`
                new_module = target.modules_to_save[target.active_adapter]
                if hasattr(new_module, "base_layer"):
                    # check if the module is itself a tuner layer
                    if merge:
                        new_module.merge(safe_merge=safe_merge, adapter_names=adapter_names)
                    new_module = new_module.get_base_layer()
                setattr(parent, target_name, new_module)

#################################################################################
#                            HunYuanDiT Configs                                 #
#################################################################################

HUNYUAN_DIT_CONFIG = {
    'DiT-g/2': {'depth': 40, 'hidden_size': 1408, 'patch_size': 2, 'num_heads': 16, 'mlp_ratio': 4.3637},
    'DiT-XL/2': {'depth': 28, 'hidden_size': 1152, 'patch_size': 2, 'num_heads': 16},
}

def DiT_g_2(args, **kwargs):
    return HunYuanDiT(args, depth=40, hidden_size=1408, patch_size=2, num_heads=16, mlp_ratio=4.3637, **kwargs)

def DiT_XL_2(args, **kwargs):
    return HunYuanDiT(args, depth=28, hidden_size=1152, patch_size=2, num_heads=16, **kwargs)

HUNYUAN_DIT_MODELS = {
    'DiT-g/2': DiT_g_2,
    'DiT-XL/2': DiT_XL_2,
}


trySend(true)
            .onFailure {
                launch {
                    onFill.send(true)
                }
            }
    }

    override fun onFillInterestedFailed(cause: Throwable?) {
        onFill.close(cause)
    }

    override fun onClose(cause: Throwable?) {
        inputJob.cancel()
        outputJob.cancel()
        super.onClose(cause)
    }

    fun isClosed() = outputJob.isCancelled || outputJob.isCompleted

    suspend fun flushAndClose(cause: Throwable? = null) {
        inputJob.channel.cancel(cause)
        outputChannel.close(cause)
        inputJob.join()
        outputJob.join()
    }
}
/*
* Copyright 2014-2021 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
*/

package io.ktor.util.network

import io.ktor.util.*
import io.ktor.utils.io.*
import kotlinx.atomicfu.*

/**
 * Represents remote endpoint with [hostname] and [port].
 *
 * The address will be resolved after construction.
 *
 *
 * [Report a problem](https://ktor.io/feedback/?fqname=io.ktor.util.network.NetworkAddress)
 *
 * @throws UnresolvedAddressException if the [hostname] cannot be resolved.
 */
public actual abstract class NetworkAddress(
    public val hostname: String,
    public val port: Int,
    explicitAddress: Any? = null
) {
    private val _explicitAddress: AtomicRef<Any?> = atomic(explicitAddress)

    @InternalAPI
    public var explicitAddress: Any? by _explicitAddress

    /**
     * Resolve current socket address.
     *
     * [Report a problem](https://ktor.io/feedback/?fqname=io.ktor.util.network.NetworkAddress.toString)
     */

    override fun toString(): String = "NetworkAddress[$hostname:$port]"
}

public actual fun NetworkAddress(hostname: String, port: Int): NetworkAddress =
    object : NetworkAddress(hostname, port, null) {}

@Suppress("FunctionName")
public fun ResolvedNetworkAddress(hostname: String, port: Int, explicitAddress: Any?): NetworkAddress =
    object : NetworkAddress(hostname, port, explicitAddress) {}

@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
public actual val NetworkAddress.hostname: String
    get() = hostname

@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
public actual val NetworkAddress.address: String
    get() = hostname

@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
public actual val NetworkAddress.port: Int
    get() = port

public actual class UnresolvedAddressException : IllegalArgumentException()
/*
 * Copyright 2025 ACINQ SAS
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package fr.acinq.phoenix.android.settings.reset

import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.viewModelScope
import androidx.lifecycle.viewmodel.CreationExtras
import com.google.firebase.messaging.FirebaseMessaging
import fr.acinq.phoenix.android.BusinessManager
import fr.acinq.phoenix.android.PhoenixApplication
import fr.acinq.phoenix.android.WalletId
import fr.acinq.phoenix.android.security.DecryptSeedResult
import fr.acinq.phoenix.android.


/impls.rs.html#219-269\">source§
fn as_ref(&self) -> &[T; 500]

Converts this type into a shared reference of the (usually inferred) input type.

","AsRef<[T; 500]>","crypto_common::Block","crypto_common::ParBlocks","crypto_common::Output","crypto_common::Key","crypto_common::Iv"],["
source§
impl<T> AsRef<[T; 16]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, <a class=\"struct\" href=\"typenum/bit/struct.B0.html\


. A few occurrences will cause
    /// the peer to get kicked.
    /// NOTE: ~5 occurrences will get the peer banned
    LowToleranceError,
    /// An error occurred with this peer but it is not necessarily malicious.
    /// We have high tolerance for this actions: several occurrences are needed for a peer to get
    /// kicked.
    /// NOTE: ~10 occurrences will get the peer banned
    MidToleranceError,
    /// An error occurred with this peer but it is not necessarily malicious.
    /// We have high tolerance for this actions: several occurrences are needed for a peer to get
    /// kicked.
    /// NOTE: ~50 occurrences will get the peer banned
    HighToleranceError,
}

/// Service reporting a `PeerAction` for a peer.
#[derive(Debug)]
pub enum ReportSource {
    Gossipsub,
    RPC,
    Processor,
    SyncService,
    PeerManager,
}

impl From<ReportSource> for &'static str {
    fn from(report_source: ReportSource) -> &'static str {
        match report_source {
            ReportSource::Gossipsub => "gossipsub",
            ReportSource::RPC => "rpc_error",
            ReportSource::Processor => "processor",
            ReportSource::SyncService => "sync",
            ReportSource::PeerManager => "peer_manager",
        }
    }
}

impl std::fmt::Display for PeerAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            PeerAction::Fatal => write!(f, "Fatal"),
            PeerAction::LowToleranceError => write!(f, "Low Tolerance Error"),
            PeerAction::MidToleranceError => write!(f, "Mid Tolerance Error"),
            PeerAction::HighToleranceError => write!(f, "High Tolerance Error"),
        }
    }
}

/// The expected state of the peer given the peer's score.
#[derive(Debug, PartialEq, Clone, Copy)]
pub(crate) enum ScoreState {
    /// We are content with the peers performance. We permit connections and messages.
    Healthy,
    /// The peer should be disconnected. We allow re-connections if the peer is persistent.
    Disconnected,
    /// The peer is banned. We disallow new connections until it's score has decayed into a
    /// tolerable threshold.
    Banned,
}

impl std::fmt::Display for ScoreState {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ScoreState::Healthy => write!(f, "Healthy"),
            ScoreState::Banned => write!(f, "Banned"),
            ScoreState::Disconnected => write!(f, "Disconnected"),
        }
    }
}

/// A peer's score (perceived potential usefulness).
///
/// This simplistic version consists of a global score per peer which decays to 0 over time. The
/// decay rate applies equally to positive and negative scores.
#[derive(PartialEq, Clone, Debug, Serialize)]
pub struct RealScore {
    /// The global score.
    // NOTE: In the future we may separate this into sub-scores involving the RPC, Gossipsub and
    // lighthouse.
    lighthouse_score: f64,
    gossipsub_score: f64,
    /// We ignore the negative gossipsub scores of some peers to allow decaying without
    /// disconnecting.
    ignore_negative_gossipsub_score: bool,
    score: f64,
    /// The time the score was last updated to perform time-based adjustments such as score-decay.
    #[serde(skip)]
    last_updated: Instant,
}

impl Default for RealScore {
    fn default() -> Self {
        RealScore {
            lighthouse_score: DEFAULT_SCORE,
            gossipsub_score: DEFAULT_SCORE,
            score: DE


BaseD0Ev
_ZN10StreamBaseD0Ev:
.LFB4:
	pushq	%rbp
	.seh_pushreg	%rbp
	movq	%rsp, %rbp
	.seh_setframe	%rbp, 0
	subq	$32, %rsp
	.seh_stackalloc	32
	.seh_endprologue
	movq	%rcx, 16(%rbp)
	movq	16(%rbp), %rcx
	call	_ZN10StreamBaseD1Ev
	movq	16(%rbp), %rcx
	call	_ZdlPv
	nop
	addq	$32, %rsp
	popq	%rbp
	ret
	.seh_endproc
	.section	.text$_ZN6StreamD2Ev,"x"
	.linkonce discard
	.align 2
	.globl	_ZN6StreamD2Ev
	.def	_ZN6StreamD2Ev;	.scl	2;	.type	32;	.endef
	.seh_proc	_ZN6StreamD2Ev
_ZN6StreamD2Ev:
.LFB6:
	pushq	%rbp
	.seh_pushreg	%rbp
	movq	%rsp, %rbp
	.seh_setframe	%rbp, 0
	subq	$32, %rsp
	.seh_stackalloc	32
	.seh_endprologue
	movq	%rcx, 16(%rbp)
	movq	%rdx, 24(%rbp)
	movq	24(%rbp), %rax
	movq	(%rax), %rdx
	movq	16(%rbp), %rax
	movq	%rdx, (%rax)
	movq	16(%rbp), %rax
	movq	(%rax), %rax
	subq	$24, %rax
	movq	(%rax), %rax
	addq	16(%rbp), %rax
	movq	24(%rbp), %rdx
	addq	$8, %rdx
	movq	(%rdx), %rdx
	movq	%rdx, (%rax)
	movq	16(%rbp), %rcx
	call	_ZN10StreamBaseD2Ev
	movl	$0, %eax
	andl	$2, %eax
	testl	%eax, %eax
	je	.L11
	movq	16(%rbp), %rax
	addq	$8, %rax
	movq	%rax, %rcx
	call	_ZN5VBaseD2Ev
.L11:
	movl	$0, %eax
	andl	$1, %eax
	testb	%al, %al
	je	.L10
	movq	16(%rbp), %rcx
	call	_ZdlPv
.L10:
	nop
	addq	$32, %rsp
	popq	%rbp
	ret
	.seh_endproc
	.section	.text$_ZN6StreamD1Ev,"x"
	.linkonce discard
	.align 2
	.globl	_ZN6StreamD1Ev
	.def	_ZN6StreamD1Ev;	.scl	2;	.type	32;	.endef
	.seh_proc	_ZN6StreamD1Ev
_ZN6StreamD1Ev:
.LFB7:
	pushq	%rbp
	.seh_pushreg	%rbp
	movq	%rsp, %rbp
	.seh_setframe	%rbp, 0
	subq	$32, %rsp
	.seh_stackalloc	32
	.seh_endprologue
	movq	%rcx, 16(%rbp)
	leaq	24+_ZTV6Stream(%rip), %rdx
	movq	16(%rbp), %rax
	movq	%rdx, (%rax)
	movl	$8, %eax


   "\x45\x41\x41\x56\x30\x40\x41\x42\x56\x30\x40\x40\x5A\x00\x3F\x3F"   //EAAV0@ABV0@@Z.??
/* 77C5CF30 */   "\x34\x62\x61\x64\x5F\x74\x79\x70\x65\x69\x64\x40\x40\x51\x41\x45"   //4bad_typeid@@QAE
/* 77C5CF50 */   "\x41\x41\x56\x30\x40\x41\x42\x56\x30\x40\x40\x5A\x00\x3F\x3F\x34"   //AAV0@ABV0@@Z.??4
/* 77C5CF70 */   "\x65\x78\x63\x65\x70\x74\x69\x6F\x6E\x40\x40\x51\x41\x45\x41\x41"   //exception@@QAEAA
/* 77C5CF90 */   "\x56\x30\x40\x41\x42\x56\x30\x40\x40\x5A\x00\x3F\x3F\x38\x74\x79"   //V0@ABV0@@Z.??8ty
/* 77C5CFB0 */   "\x70\x65\x5F\x69\x6E\x66\x6F\x40\x40\x51\x42\x45\x48\x41\x42\x56"   //pe_info@@QBEHABV
/* 77C5CFD0 */   "\x30\x40\x40\x5A\x00\x3F\x3F\x39\x74\x79\x70\x65\x5F\x69\x6E\x66"   //0@@Z.??9type_inf
/* 77C5CFF0 */   "\x6F\x40\x40\x51\x42\x45\x48\x41\x42\x56\x30\x40\x40\x5A\x00\x3F"   //o@@QBEHABV0@@Z.?
/* 77C5D010 */   "\x3F\x5F\x37\x5F\x5F\x6E\x6F\x6E\x5F\x72\x74\x74\x69\x5F\x6F\x62"   //?_7__non_rtti_ob
/* 77C5D030 */   "\x6A\x65\x63\x74\x40\x40\x36\x42\x40\x00\x3F\x3F\x5F\x37\x62\x61"   //ject@@6B@.??_7ba
/* 77C5D050 */   "\x64\x5F\x63\x61\x73\x74\x40\x40\x36\x42\x40\x00\x3F\x3F\x5F\x37"   //d_cast@@6B@.??_7
/* 77C5D070 */   "\x62\x61\x64\x5F\x74\x79\x70\x65\x69\x64\x40\x40\x36\x42\x40\x00"   //bad_typeid@@6B@.
/* 77C5D090 */   "\x3F\x3F\x5F\x37\x65\x78\x63\x65\x70\x74\x69\x6F\x6E\x40\x40\x36"   //??_7exception@@6
/* 77C5D0B0 */   "\x42\x40\x00\x3F\x3F\x5F\x45\x5F\x5F\x6E\x6F\x6E\


failed");
        }
        if self.last_step.is_some() {
            if input.unimportant_key_pressed(Key::Space, "Press space to pause sim") {
                self.last_step = None;
                self.benchmark = None;
                self.sim_speed = String::from("paused");
            }
        } else {
            if input.unimportant_key_pressed(Key::Space, "Press space to run sim") {
                self.last_step = Some(Instant::now());
                self.benchmark = Some(self.sim.start_benchmark());
            } else if input.unimportant_key_pressed(Key::M, "press M to run one step") {
                self.sim.step(geom_map, map, control_map);
            }
        }

        if input.use_event_directly().update_args().is_some() {
            if let Some(tick) = self.last_step {
                // TODO https://gafferongames.com/post/fix_your_timestep/
                let dt = tick.elapsed();
                let dt_s = dt.as_secs() as f64 + f64::from(dt.subsec_nanos()) * 1e-9;
                if dt_s >= common::TIMESTEP.value_unsafe / self.desired_speed {
                    self.sim.step(geom_map, map, control_map);
                    self.last_step = Some(Instant::now());
                }

                if self.benchmark
                    .as_ref()
                    .unwrap()
                    .has_real_time_passed(Duration::from_secs(1))
                {
                    self.sim_speed = format!(
                        "{0:.2}x",
                        self.sim.measure_speed(self.benchmark.as_mut().unwrap())
                    );
                }
            }
        }
        self.last_step.is_some()
    }

    pub fn get_osd_lines(&self) -> Vec<String> {
        vec![
            self.sim.summary(),
            format!(
                "Speed: {0} / desired {1:.2}x",
                self.sim_speed, self.desired_speed
            ),
        ]
    }
}
use super::error::{ErrorKind, Result};
use super::header;
use super::util::tcpconnection;
use super::{ServicePair, ServiceResult};
use byteorder::WriteBytesExt;
use serde_rosmsg::{from_reader, to_writer};
use std;
use std::collections::HashMap;
use std::net::TcpListener;
use std::sync::Arc;
use std::thread;

pub struct Service {
    pub api: String,
    pub msg_type: String,
    pub service: String,
    _raii: tcpconnection::Raii,
}

impl Service {
    pub fn new<T, F>(
        hostname: &str,
        port: u16,
        service: &str,
        node_name: &str,
        handler: F,
    ) -> Result<Service>
    where
        T: ServicePair,
        F: Fn(T::Request) -> ServiceResult<T::Response> + Send + Sync + 'static,
    {
        let listener = TcpListener::bind((hostname, port))?;
        let socket_address = listener.local_addr()?;
        let api = format!("rosrpc://{}:{}", hostname, socket_address.port());
        let (raii, listener) = tcpconnection::iterate(listener, format!("service '{}'", service));
        Ok(Service::wrap_stream::<T, _, _, _>(
            service,
            node_name,
            handler,
            raii,
            listener,
            &api,
        ))
    }

    fn wrap_stream<T, U, V, F>(
        service: &str,
        node_name: &str,
        handler: F,
        raii: tcpconnection::Raii,
        listener: V,
        api: &


enURL")]
	public class MMOpenURL : MonoBehaviour
	{
		/// the URL to open when calling OpenURL()
		public string DestinationURL;

		/// <summary>
		/// Opens the URL specified in the DestinationURL field
		/// </summary>
		public virtual void OpenURL()
		{
			Application.OpenURL(DestinationURL);
		}
	}
}


})
wrench:register_node("technic:coal_alloy_furnace_active", {
	lists = {"fuel", "src", "dst"},
	metas = {infotext = STRING,
		fuel_totaltime = FLOAT,
		fuel_time = FLOAT,
		src_totaltime = FLOAT,
		src_time = FLOAT},
})
wrench:register_node("technic:alloy_furnace", {
	lists = {"src", "dst"},
	metas = {infotext = STRING,
		formspec = STRING,
		LV_EU_demand = INT,
		LV_EU_input = INT,
		tube_time = INT,
		src_time = INT},
})
wrench:register_node("technic:alloy_furnace_active", {
	lists = {"src", "dst"},
	metas = {infotext = STRING,
		formspec = STRING,
		LV_EU_demand = INT,
		LV_EU_input = INT,
		tube_time = INT,
		src_time = INT},
})
wrench:register_node("technic:mv_alloy_furnace", {
	lists = {"src", "dst", "upgrade1", "upgrade2"},
	metas = {infotext = STRING,
		formspec = STRING,
		MV_EU_demand = INT,
		MV_EU_input = INT,
		tube_time = INT,
		src_time = INT},
})
wrench:register_node("technic:mv_alloy_furnace_active", {
	lists = {"src", "dst", "upgrade1", "upgrade2"},
	metas = {infotext = STRING,
		formspec = STRING,
		MV_EU_demand = INT,
		MV_EU_input = INT,
		tube_time = INT,
		src_time = INT},
})
wrench:register_node("technic:tool_workshop", {
	lists = {"src", "upgrade1", "upgrade2"},
	metas = {infotext = STRING,
		formspec = STRING,
		MV_EU_demand = INT,
		MV_EU_input = INT,
		tube_time = INT},
})
wrench:register_node("technic:grinder", {
	lists = {"src", "dst"},
	metas = {infotext = STRING,
		formspec = STRING,
		LV_EU_demand = INT,
		LV_EU_input = INT,
		src_time = INT},
})
wrench:register_node("technic:grinder_active", {
	lists = {"src", "dst"},
	metas = {infotext = STRING,
		formspec = STRING,
		LV_EU_demand = INT,
		LV_EU_input = INT,
		src_time = INT},
})
wrench:register_node("technic:mv_grinder", {
	lists = {"src", "dst", "upgrade1", "upgrade2"},
	metas = {infotext = STRING,
		formspec = STRING,
		MV_EU_demand = INT,
		MV_EU_input = INT,
		tube_time = INT,
		src_time = INT},
})
wrench:register_node("technic:mv_grinder_active", {
	lists = {"src", "dst", "upgrade1", "upgrade2"},
	metas = {infotext = STRING,
		formspec = STRING,
		MV_EU_demand = INT,
		MV_EU_input = INT,
		tube_time = INT,
		src_time = INT},
})
wrench:register_node("technic:extractor", {
	lists = {"src", "dst"},
	metas = {infotext = STRING,
		formspec = STRING,
		LV_EU_demand = INT,
		LV_EU_input = INT,
		src_time = INT},
})
wrench:register_node("technic:extractor_active", {
	lists = {"src", "dst"},
	metas = {infotext


chInstantConverter(it)
    }

    private fun check(data: JsonObject?, claims: List<Claims>, converter: (String) -> Instant) =
        claims.firstOrNull { claim ->
            !data?.jsonObject?.get(claim.getValue())?.jsonPrimitive?.content.isNullOrEmpty()
        }?.let {
            Pair(it, converter(data!!.jsonObject[it.getValue()]!!.jsonPrimitive.content))
        }

    private fun instantConverter(value: String) = Instant.parse(value)

    private fun epochInstantConverter(value: String) = value.toLongOrNull()?.let { Instant.fromEpochSeconds(it) }
        ?: throw IllegalArgumentException("Couldn't parse epoch seconds from: $value")
}
@file:OptIn(ExperimentalJsExport::class, ExperimentalTime::class)

package id.walt.policies

import id.walt.policies.policies.JsonSchemaPolicy
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.JsonObject
import kotlin.js.ExperimentalJsExport
import kotlin.js.JsExport
import kotlin.time.Duration
import kotlin.time.ExperimentalTime
import kotlin.time.Instant

@JsExport
@Serializable
sealed class SerializableRuntimeException(
    override val message: String? = null
) : RuntimeException(message)

@JsExport
@Serializable
@SerialName("JsonSchemaVerificationException")
data class JsonSchemaVerificationException(
    val validationErrors: List<JsonSchemaPolicy.SerializableValidationError>
) : SerializableRuntimeException()

@Serializable
@SerialName("NotBeforePolicyException")
data class NotBeforePolicyException(
    val date: Instant,
    @SerialName("date_seconds") val dateSeconds: Long,

    @SerialName("available_in") val availableIn: Duration,
    @SerialName("available_in_seconds") val availableInSeconds: Long,
    val key: String,
    @SerialName("policy_available") val policyAvailable: Boolean = true,
) : SerializableRuntimeException()

@Serializable
@SerialName("ExpirationDatePolicyException")
data class ExpirationDatePolicyException(
    val date: Instant,
    @SerialName("date_seconds") val dateSeconds: Long,

    @SerialName("expired_in") val expiredSince: Duration,
    @SerialName("expired_in_seconds") val expiredSinceSeconds: Long,
    val key: String,
    @SerialName("policy_available") val policyAvailable: Boolean = true,
) : SerializableRuntimeException()

@JsExport
@Serializable
@SerialName("WebhookPolicyException")
data class WebhookPolicyException(
    val response: JsonObject,
) : SerializableRuntimeException()

@JsExport
@Serializable
@SerialName("PresentationDefinitionException")
class PresentationDefinitionException(
//    val missingCredentialTypes: List<String>,
    val presentationDefinitionMatch: Boolean
) : SerializableRuntimeException()

@JsExport
@Serializable
@SerialName("PresentationDefinitionRelationalConstraintException")
class PresentationDefinitionRelationalConstraintException(
    val constraint: RelationalConstraintType,
    val constraintFailureDescription: String
) : SerializableRuntimeException() {

    @Suppress("EnumEntryName")
    enum class RelationalConstraintType {
        subject_is_issuer,
        is_holder,
        same_subject
    }

}

@JsExport
@Serializable
@SerialName("MinimumCredentialsException")
class MinimumCredentialsException(
    val total: Int,
    val missing: Int,
)


",
    "Very Strong",
];

export const bodyTypeModifiers = new Map([
    ["Very Weak", 0],
    ["Weak", -1],
    ["Average", -2],
    ["Strong", -3],
    ["Very Strong", -4],
    ["Superhuman", -5],
]);

export type StatAbbr =
    | "INT"
    | "REF"
    | "TECH"
    | "COOL"
    | "ATT"
    | "LUCK"
    | "MA"
    | "BODY"
    | "EMP";

export function getStatByAbbr(stats: CharacterStats, abbr: StatAbbr): number {
    const retStat = stats.get(abbr);
    if (retStat !== undefined) {
        return retStat;
    } else {
        throw Error(
            `Stats ${JSON.stringify(stats)} does not contain abbr ${abbr}`
        );
    }
}

export type CharacterStats = Map<StatAbbr, number>;

export const statNames: { name: string; abbr: StatAbbr }[] = [
    { name: "Intelligence", abbr: "INT" },
    { name: "Reflexes", abbr: "REF" },
    { name: "Technology", abbr: "TECH" },
    { name: "Cool", abbr: "COOL" },
    { name: "Attractiveness", abbr: "ATT" },
    { name: "Luck", abbr: "LUCK" },
    { name: "Movement Allowence", abbr: "MA" },
    { name: "Body", abbr: "BODY" },
    { name: "Empathy", abbr: "EMP" },
];

export const getFullStatName = new Map(
    statNames.map((val) => [val.abbr, val.name])
);
export const getStatAbbr = new Map(
    statNames.map((val) => [val.name, val.abbr])
);

export function rollD10s(num: number) {
    const rolls = [];
    for (let i = 0; i < num; i++) {
        rolls.push(rollD10());
    }
}

export function rollD10() {
    return Math.floor(Math.random() * Math.floor(10)) + 1;
}
export function rollD8() {
    return Math.floor(Math.random() * Math.floor(8)) + 1;
}
export function rollD6() {
    return Math.floor(Math.random() * Math.floor(6)) + 1;
}
export function rollD5() {
    return Math.floor(Math.random() * Math.floor(5)) + 1;
}
export function rollD3() {
    return Math.floor(Math.random() * Math.floor(3)) + 1;
}

export function genCleanStats(): Map<StatAbbr, number> {
    return new Map([
        ["INT", 0],
        ["REF", 0],
        ["TECH", 0],
        ["COOL", 0],
        ["ATT", 0],
        ["LUCK", 0],
        ["MA", 0],
        ["BODY", 0],
        ["EMP", 0],
    ]);
}

export const roles: Role[] = [
    "Cop",
    "Rocker",
    "Solo",
    "Media",
    "Nomad",
    "Netrunner",
    "Techie",
    "MedTechie",
    "Corp",
    "Fixer",
];
export type Role =
    | "Cop"
    | "Rocker"
    | "Solo"
    | "Media"
    | "Nomad"
    | "Netrunner"
    | "Techie"
    | "MedTechie"
    | "Corp"
    | "Fixer";

export const clothes: { [key: number]: Clothes } = {
    1: "Biker leathers",
    2: "Blue jeans",
    3: "Corporate suits",
    4: "Jumpsuits",
    5: "Miniskirts",
    6: "High Fashion",
    7: "Cammos",
    8: "Normal clot


    }

}/*
 * Copyright © 2024 Explyt Ltd
 *
 * All rights reserved.
 *
 * This code and software are the property of Explyt Ltd and are protected by copyright and other intellectual property laws.
 *
 * You may use this code under the terms of the Explyt Source License Version 1.0 ("License"), if you accept its terms and conditions.
 *
 * By installing, downloading, accessing, using, or distributing this code, you agree to the terms and conditions of the License.
 * If you do not agree to such terms and conditions, you must cease using this code and immediately delete all copies of it.
 *
 * You may obtain a copy of the License at: https://github.com/explyt/spring-plugin/blob/main/EXPLYT-SOURCE-LICENSE.md
 *
 * Unauthorized use of this code constitutes a violation of intellectual property rights and may result in legal action.
 */

package com.explyt.spring.core.completion.properties.java

import com.explyt.spring.test.TestLibrary
import com.intellij.codeInsight.completion.CompletionType

class SpringConfigurationMetadataReferenceContributorTest : AbstractSpringPropertiesCompletionContributorTestCase() {

    override val libraries: Array<TestLibrary> =
        arrayOf(TestLibrary.springBoot_3_1_1, TestLibrary.springContext_6_0_7)

    fun testPropertyType() {
        myFixture.configureByText(
            "additional-spring-configuration-metadata.json",
            """
{
  "properties": [
    {
      "name": "main.value",
      "type": "java.<caret>"
    }
  ]
}
""".trimIndent()
        )
        doTest(
            "io",
            "lang",
            "math",
            "net",
            "nio",
            "security",
            "text",
            "time",
            "util"
        )
    }

    fun testPropertySourceType() {
        myFixture.configureByText(
            "additional-spring-configuration-metadata.json",
            """
{
  "properties": [
    {
      "name": "main.max-sessions-per-connection",
      "type": "java.lang.Integer",
      "description": "Maximum number connections.",
      "sourceType": "org.springframework.core.Nes<caret>",
  ]
}
""".trimIndent()
        )
        doTest(
            "NestedCheckedException",
            "NestedExceptionUtils",
            "NestedRuntimeException",
            "CoroutinesUtils"
        )
    }

    fun testGroupType() {
        myFixture.configureByText(
            "additional-spring-configuration-metadata.json",
            """
{
  "groups": [
    {
        "name": "server",
        "type": "org.s<caret>"
    }
  ]
}
""".trimIndent()
        )
        doTest("springframework", "jetbrains")
    }

    fun testGroupSourceType() {
        myFixture.configureByText(
            "additional-spring-configuration-metadata.json",
            """
{
  "groups": [
    {
      "name": "main.max-sessions-per-connection",
      "type": "java.lang.Integer",
      "sourceType": "org.springframework.core.Nes<caret>",
  ]
}
""".trimIndent()
        )
        doTest(
            "NestedCheckedException",
            "NestedExceptionUtils",
            "NestedRuntimeException",
            "CoroutinesUtils"
        )
    }

    fun testHintsNameFromClass() {
        myFixture.copyFileToProject("MainFooProperties.java")
        myFixture.configureByText(
            "additional-spring-configuration-metadata.json",
            """
{
  "hints": [
    {
      "name": "main.local.<caret>"
    }
}
""".trimIndent()
        )
        doTest(
            "main.local.event-listener",
            "main.local.code-mime-type",
            "main.local.code-charset",
            "main.local.code-


c.Schema{
									SchemaProps: spec.SchemaProps{
										Default: "",
										Type:    []string{"string"},
										Format:  "",
									},
								},
							},
						},
					},
				},
				Required: []string{"conversionReviewVersions"},
			},
		},
		Dependencies: []string{
			"k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.WebhookClientConfig"},
	}
}

func schema_apimachinery_pkg_api_resource_Quantity(ref common.ReferenceCallback) common.OpenAPIDefinition {
	return common.EmbedOpenAPIDefinitionIntoV2Extension(common.OpenAPIDefinition{
		Schema: spec.Schema{
			SchemaProps: spec.SchemaProps{
				Description: "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` <quantity>        ::= <signedNumber><suffix>\n\n\t(Note that <suffix> may be empty, from the \"\" case in <decimalSI>.)\n\n<digit>           ::= 0 | 1 | ... | 9 <digits>          ::= <digit> | <digit><digits> <number>          ::= <digits> | <digits>.<digits> | <digits>. | .<digits> <sign>            ::= \"+\" | \"-\" <signedNumber>    ::= <number> | <sign><number> <suffix>          ::= <binarySI> | <decimalExponent> | <decimalSI> <binarySI>        ::= Ki | Mi | Gi | Ti | Pi | Ei\n\n\t(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)\n\n<decimalSI>       ::= m | \"\" | k | M | G | T | P | E\n\n\t(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)\n\n<decimalExponent> ::= \"e\" <signedNumber> | \"E\" <signedNumber> ```\n\nNo matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities.\n\nWhen a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized.\n\nBefore serializing, Quantity will be put in \"canonical form\". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that:\n\n- No precision is lost - No fractional digits will be emitted - The exponent (or suffix) is as large as possible.\n\nThe sign will be omitted unless the number is negative.\n\nExamples:\n\n- 1.5 will be serialized as \"1500m\" - 1.5Gi will be serialized as \"1536Mi\"\n\nNote that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise.\n\nNon-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.)\n\nThis format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation.",
				OneOf:       common.GenerateOpenAPIV3OneOfSchema(resource.Quantity{}.OpenAPIV3OneOfTypes()),
				Format:      resource.Quantity{}.OpenAPISchemaFormat(),
			},
		},
	}, common.OpenAPIDefinition{
		Schema: spec.Schema{
			SchemaProps: spec.SchemaProps{
				Description: "Quantity is a fixed-point representation of a number. It provides convenient marshaling/unmarshaling in JSON and YAML, in addition to String() and AsInt64() accessors.\n\nThe serialization format is:\n\n``` <


::Rect(-200, -100, 800, 600),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTest, FixedPositionInScrollableViewCullRect) {
  SetBodyInnerHTML(R"HTML(

  )HTML");

  EXPECT_EQ(gfx::Rect(-200, -100, 800, 600),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTest, LayerOffscreenNearCullRect) {
  GetDocument().GetSettings()->SetPreferCompositingToLCDTextEnabled(true);
  SetBodyInnerHTML(R"HTML(

  )HTML");

  EXPECT_EQ(gfx::Rect(0, 0, 4200, 4300),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTest, LayerOffscreenFarCullRect) {
  GetDocument().GetSettings()->SetPreferCompositingToLCDTextEnabled(true);
  SetBodyInnerHTML(R"HTML(

  )HTML");

  // The layer is too far away from the viewport.
  EXPECT_EQ(gfx::Rect(),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTest, ScrollingLayerCullRect) {
  GetDocument().GetSettings()->SetPreferCompositingToLCDTextEnabled(true);
  SetBodyInnerHTML(R"HTML(

  )HTML");

  // In screen space, the scroller is (8, 8, 195, 193) (because of overflow clip
  // of 'target', scrollbar and root margin).
  // Applying the viewport clip of the root has no effect because
  // the clip is already small. Mapping it down into the graphics layer
  // space yields (0, 0, 195, 193). This is then expanded by 4000px and clipped
  // by the contents rect.
  EXPECT_EQ(gfx::Rect(0, 0, 195, 4193),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTest, NonCompositedScrollingLayerCullRect) {
  GetDocument().GetSettings()->SetPreferCompositingToLCDTextEnabled(false);
  SetBodyInnerHTML(R"HTML(

  )HTML");

  // See ScrollingLayerCullRect for the calculation.
  EXPECT_EQ(gfx::Rect(0, 0, 195, 193),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTest, ClippedBigLayer) {
  SetBodyInnerHTML(R


_month(2020, 7), 31);
        assert_eq!(num_days_of_month(2020, 8), 31);
        assert_eq!(num_days_of_month(2020, 9), 30);
        assert_eq!(num_days_of_month(2020, 10), 31);
        assert_eq!(num_days_of_month(2020, 11), 30);
        assert_eq!(num_days_of_month(2020, 12), 31);
    }
}
<gh_stars>1-10
use std::fs;
extern crate minidom;

use minidom::Element;

use crate::iteratives;
use crate::residuals;
use crate::solver::SolverParameters;
use crate::solver::{
    QuasiNewtonMethod, ResolutionMethod, UpdateQuasiNewtonMethod,
};

#[cfg(test)]
mod tests {
    use super::*;
    extern crate minidom;
    use crate::solver_advanced::iteratives;
    use crate::solver_advanced::solver::ResolutionMethod;
    use minidom::Element;

    #[test]
    #[should_panic(expected = "The attribute \"dx_abs\" is missing in the iteratives node")]
    fn parsing_iteratives_with_iteratives_fd() {
        const DATA: &'static str = r#"
            <iteratives max_step_abs="inf" max_step_rel="inf" min_value="-inf" max_value="inf">
                <iterative id="0"/>
                <iterative id="1"/>
                <iterative id="2"/>
            </iteratives>"#;
        let iteratives_node: Element = DATA.parse().unwrap();
        let _iteratives = parse_iteratives_fd_node(&iteratives_node);
    }

    #[test]
    fn parsing_iteratives_fd_with_iteratives() {
        const DATA: &'static str = r#"
            <iteratives max_step_abs="inf" max_step_rel="inf" min_value="-inf" max_value="inf" dx_abs="5e-8" dx_rel="5e-8" perturbation_method="Max">
                <iterative id="0"/>
                <iterative id="1"/>
                <iterative id="2"/>
            </iteratives>"#;
        let iteratives_node: Element = DATA.parse().unwrap();
        let _iteratives = parse_iteratives_node(&iteratives_node);
    }

    #[test]
    fn parsing_root_1() {
        const DATA: &'static str = r#"
            <nrf>
                <solver problem_size="3" max_iter="60" tolerance="1e-6" damping="true" resolution_method="NR"/>
                <iteratives max_step_abs="inf" max_step_rel="inf" min_value="-inf" max_value="inf">
                    <iterative id="0"/>
                    <iterative id="1"/>
                    <iterative id="2"/>
                </iteratives>
                <residuals stopping_criteria="Abs" update_method="Abs">
                    <residual id="0" stopping_criteria="Adapt" update_method="Abs"/>
                    <residual id="1" stopping_criteria="Rel"   update_method="Abs"/>
                    <residual id="2" stopping_criteria="Adapt" update_method="Rel"/>
                </residuals>
            </nrf>"#;
        let (solver_parameters, iteratives_parsed, stopping_criterias, update_methods) =
            parse_root_node(&DATA);

        assert_eq!(solver_parameters.get_problem_size(), 3);
        assert_eq!(solver_parameters.get_max_iter(), 60);


/*
 * Copyright (c) 2015 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
 *                    Zhou Xiaoyong <zhouxiaoyong@loongson.cn>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "idctdsp_mips.h"
#include "xvididct_mips.h"

#if HAVE_MSA
static av_cold void idctdsp_init_msa(IDCTDSPContext *c, AVCodecContext *avctx,
                                     unsigned high_bit_depth)
{
    if ((avctx->lowres != 1) && (avctx->lowres != 2) && (avctx->lowres != 3) &&
        (avctx->bits_per_raw_sample != 10) &&
        (avctx->bits_per_raw_sample != 12) &&
        (avctx->idct_algo == FF_IDCT_AUTO)) {
                c->idct_put = ff_simple_idct_put_msa;
                c->idct_add = ff_simple_idct_add_msa;
                c->idct = ff_simple_idct_msa;
                c->perm_type = FF_IDCT_PERM_NONE;
    }

    c->put_pixels_clamped = ff_put_pixels_clamped_msa;
    c->put_signed_pixels_clamped = ff_put_signed_pixels_clamped_msa;
    c->add_pixels_clamped = ff_add_pixels_clamped_msa;
}
#endif  // #if HAVE_MSA

#if HAVE_MMI
static av_cold void idctdsp_init_mmi(IDCTDSPContext *c, AVCodecContext *avctx,
        unsigned high_bit_depth)
{
    if ((avctx->lowres != 1) && (avctx->lowres != 2) && (avctx->lowres != 3) &&
        (avctx->bits_per_raw_sample != 10) &&
        (avctx->bits_per_raw_sample != 12) &&
        ((avctx->idct_algo == FF_IDCT_AUTO) || (avctx->idct_algo == FF_IDCT_SIMPLE))) {
                c->idct_put = ff_simple_idct_put_8_mmi;
                c->idct_add = ff_simple_idct_add_8_mmi;
                c->idct = ff_simple_idct_8_mmi;
                c->perm_type = FF_IDCT_PERM_NONE;
    }

    c->put_pixels_clamped = ff_put_pixels_clamped_mmi;
    c->add_pixels_clamped = ff_add_pixels_clamped_mmi;
    c->put_signed_pixels_clamped = ff_put_signed_pixels_clamped_mmi;
}
#endif /* HAVE_MMI */

av_cold void ff_idctdsp_init_mips(IDCTDSPContext *c, AVCodecContext *avctx,
                          unsigned high_bit_depth)
{
#if HAVE_MMI
    idctdsp_init_mmi(c, avctx, high_bit_depth);
#endif /* HAVE_MMI */
#if HAVE_MSA
    idctdsp_init_msa(c, avctx, high_bit_depth);
#endif  // #if HAVE_MSA
}


.set(name, []);
    }

    let [fin, args] = this.states.get(name);
    if (callback) {
      if (fin) {
        callback(args);
      } else {
        this.events.get(name).push(callback);
      }
    }
  }

  public wait(name: string) {
    return new Promise((resolve) => {
      this.on(name, resolve);
    });
  }

  public finish(name: string, ...args: any[]) {
    if (this.states.has(name)) {
      this.states.set(name, [true, args]);
      this.events.set(
        name,
        this.events.get(name).filter((e) => e(args), false)
      );
    }
  }

  public isFinished(name: string): boolean {
    const g = this.states.get(name);
    return !!g && !!g[0];
  }

  public revoke(name: string) {
    if (!this.states.has(name) || this.states.get(name)) {
      this.on(name);
    }
  }

  public reset() {
    this.states.clear();
    this.events.clear();
  }
}
import IBaseAnimation from "../interfaces/IBaseAnimation.js";
import IaniData from "../interfaces/IaniData.js";

export default abstract class Animation implements IBaseAnimation{

   // aniData:IaniData;
   attributeToAnimateName:string;
   fromSecond:number;
   toSecond:number;
   readOnlyElementAttrNames:string[]|[];
    argsForAlgo : {};
    lastExecutionTime:number;
    store:{};
    fps:number;

constructor(aniData:IaniData,argsForAlgo={}){
 //this.aniData = aniData;
 this.attributeToAnimateName = aniData.attributeToAnimateName ;//must
 this.fromSecond = aniData.fromSecond  ; //must for every animation
 this.toSecond = aniData.toSecond ;//must for every animation
 this.readOnlyElementAttrNames = aniData.readOnlyElementAttrNames;
//--------------------------------------------------------------------
 this.argsForAlgo = argsForAlgo;
//--------------------------------------------------------------------

 this.fps =  60 ; // this has to be settled
 this.lastExecutionTime=0;
 this.store = {};
}

public animate(attributeToAnimateData:any,currentSecond:number,readOnlyElementData:{}={}):string|number|boolean{
return true;
}
//===============================================
}import { Dict } from '../definitions'

interface IUrlParams {
  key: string
  value: any
}

/**
 * 导出 流方式
 *
 * const sendData = {
 *    Authorization: this.state.Authorization,
 *  }
 *  exportFile('/api/admin/platform/downloadReceiptProfitTemplate.xls', sendData)
 */
export const exportFile = (url: string, params: Dict, removeTime = 4000) => {
  const urlParams: IUrlParams[] = []
  for (const key of Object.keys(params)) {
    const value = params[key]
    if (value != undefined && value !== '') {
      urlParams.push({
        key,
        value,
      })
    }
  }
  const exportForm = document.createElement('form')
  exportForm.method = 'get'
  exportForm.action = url
  exportForm.style.display = 'none'
  urlParams.forEach((v) => {
    const input = document.createElement('input')
    input.type = 'text'
    input.name = v.key
    input.value = v.value
    exportForm.appendChild(input)
  })

  document.body.appendChild(exportForm)

  exportForm.submit()

  setTimeout(() => {
    document.body.removeChild(exportForm)
  }, removeTime)
}
import KeyValuePair from 'artisan-core/lib/collections/KeyValuePair';
import IDisposable from 'artisan-core/lib/IDisposable';
import ISqlDataReader from './ISqlDataReader';
import ISqlTransaction from './ISqlTransaction';

/**
 * Represents a statement to be executed against a SQL database.
 */
interface ISqlCommand extends


onClose,
    required this.onError,
  });

  @override
  void add(data) {
    if (_closed) {
      throw StateError('Stream is already closed');
    }
    const bufferSize = 16384;
    _buffer ??= malloc.allocate(bufferSize);

    int numWritten = 0;
    while (numWritten < data.length) {
      final len = min(bufferSize, data.length - numWritten);
      _buffer!
          .asTypedList(bufferSize)
          .setRange(0, len, data.sublist(numWritten, numWritten + len));
      _NativeFunctions.instance.streamWrite(handle, _buffer!, len);
      session.didWriteBytes(len);
      numWritten += len;
    }
  }

  void _close({
    bool delete = false,
  }) {
    if (_buffer != null) {
      malloc.free(_buffer!);
      _buffer = null;
    }
    _NativeFunctions.instance.streamClose(handle, delete);
  }

  @override
  Future<void> addError(Object error, [StackTrace? stackTrace]) async {
    if (_closed) {
      return;
    }
    _closed = true;
    await onError(error.toString());
    _close(delete: true);
  }

  @override
  Future<void> close() async {
    if (_closed) {
      return;
    }
    _closed = true;
    _close();
    return onClose();
  }
}

abstract class _ValuePromiseResult {
  static _ValuePromiseResultOk ok(dynamic value) =>
      _ValuePromiseResultOk._(value);

  static _ValuePromiseResultCancelled cancelled() =>
      _ValuePromiseResultCancelled._();

  dynamic serialize();
}

class _ValuePromiseResultCancelled extends _ValuePromiseResult {
  _ValuePromiseResultCancelled._();

  @override
  serialize() => {
        'type': 'cancelled',
      };
}

class _ValuePromiseResultOk extends _ValuePromiseResult {
  _ValuePromiseResultOk._(this.value);

  final dynamic value;

  @override
  serialize() => {
        'type': 'ok',
        'value': value,
      };
}
import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'dart:math';
import 'dart:ui' as ui;

import 'package:desktop_multi_window/desktop_multi_window.dart';
import 'package:flutter/gestures.dart';
import 'package:flutter/services.dart';
import 'package:flutter/widgets.dart';
import 'package:flutter_hbb/main.dart';
import 'package:flutter_hbb/utils/multi_window_manager.dart';
import 'package:get/get.dart';

import '../../models/model.dart';
import '../../models/platform_model.dart';
import '../common.dart';
import '../consts.dart';

/// Mouse button enum.
enum MouseButtons { left, right, wheel, back }

const _kMouseEventDown = 'mousedown';
const _kMouseEventUp = 'mouseup';
const _kMouseEventMove = 'mousemove';

class CanvasCoords {
  double x = 0;
  double y = 0;
  double scale = 1.0;
  double scrollX = 0;
  double scrollY = 0;
  ScrollStyle scrollStyle = ScrollStyle.scrollauto;
  Size size = Size.zero;

  CanvasCoords();

  Map<String, dynamic> toJson() {
    return {
      'x': x,
      'y': y,
      'scale': scale,
      'scrollX': scrollX,
      'scrollY': scrollY,
      'scrollStyle':
          scrollStyle == ScrollStyle.scrollauto ? 'scrollauto' : 'scrollbar',
      'size': {
        'w': size.width,
        'h': size.height,
      }
    }


s[#,x]]],Throw[tmp]]],u];
    False]]]]

(* ::Subsubsection::Closed:: *)
(*Substitution for inverse functions*)

(* SubstForFractionalPower[u,v,n,w,x] returns u with subexpressions equal to v^(m/n) replaced
	by x^m and x replaced by w. *)
SubstForFractionalPower[u_,v_,n_,w_,x_Symbol] :=
  If[AtomQ[u],
    If[u===x,
      w,
    u],
  If[FractionalPowerQ[u] && EqQ[u[[1]],v],
    x^(n*u[[2]]),
  Map[Function[SubstForFractionalPower[#,v,n,w,x]],u]]]

(* SubstForInverseFunction[u,v,w,x] returns u with subexpressions equal to v replaced by x
	and x replaced by w. *)
SubstForInverseFunction[u_,v_,x_Symbol] :=
(*  Module[{a=Coefficient[v[[1]],0],b=Coefficient[v[[1]],1]},
  SubstForInverseFunction[u,v,-a/b+InverseFunction[Head[v]]/b,x]] *)
  SubstForInverseFunction[u,v,
		(-Coefficient[v[[1]],x,0]+InverseFunction[Head[v]][x])/Coefficient[v[[1]],x,1],x]

SubstForInverseFunction[u_,v_,w_,x_Symbol] :=
  If[AtomQ[u],
    If[u===x,
      w,
    u],
  If[Head[u]===Head[v] && EqQ[u[[1]],v[[1]]],
    x,
  Map[Function[SubstForInverseFunction[#,v,w,x]],u]]]

(* ::Section::Closed:: *)
(*Absurd number factors*)

(* ::Text:: *)
(*Definition: A number is absurd if it is a rational number, a positive rational number raised to a fractional power, or a product of absurd numbers.*)

(* AbsurdNumberQ[u] returns True if u is an absurd number, else it returns False. *)
AbsurdNumberQ[u_] :=
  RationalQ[u]

AbsurdNumberQ[u_^v_] :=
  RationalQ[u] && u>0 && FractionQ[v]

AbsurdNumberQ[u_*v_] :=
  AbsurdNumberQ[u] && AbsurdNumberQ[v]

(* AbsurdNumberFactors[u] returns the product of the factors of u that are absurd numbers. *)
AbsurdNumberFactors[u_] :=
  If[AbsurdNumberQ[u],
    u,
  If[ProductQ[u],
    Map[AbsurdNumberFactors,u],
  NumericFactor[u]]]

(* NonabsurdNumberFactors[u] returns the product of the factors of u that are not absurd numbers. *)
NonabsurdNumberFactors[u_] :=
  If[AbsurdNumberQ[u],
    1,
  If[ProductQ[u],
    Map[NonabsurdNumberFactors,u],
  NonnumericFactors[u]]]

(* m must be an absurd number.  FactorAbsurdNumber[m] returns the prime factorization of m *)
(* as list of base-degree pairs where the bases are prime numbers and the degrees are rational. *)
FactorAbsurdNumber[m_] :=
  If[RationalQ[m],
    FactorInteger[m],
  If[PowerQ[m],
    Map[Function[{#[[1]], #[[2]]*m[[2]]}],FactorInteger[m[[1]]]],
  CombineExponents[Sort[Flatten[Map[FactorAbsurdNumber


from sqlalchemy import func, text
from sqlalchemy.dialects.postgresql import JSONB, BIGINT

class AdditionalSQLFunctions:

    @staticmethod
    def jsonb_array_elements(jsonb_array):
        return func.jsonb_array_elements(jsonb_array)

    @staticmethod
    def jsonb_extract_path_text(jsonb, *path):
        return func.jsonb_extract_path_text(jsonb, *path)

    @staticmethod
    def jsonb_dv_ordered_magnitude(dv_ordered_field):
        return func.jsonb_dv_ordered_magnitude(dv_ordered_field)

    @staticmethod
    def jsonb_attribute_path_text(jsonb, *path):
        # SQLAlchemy does not have built-in support for chaining JSONB operations, so we need to build it manually
        jsonb_field = jsonb
        for att in path:
            jsonb_field = func.jsonb_get_attribute(jsonb_field, text(att))
        return func.jsonb_get_element_as_text(jsonb_field, text("0"))

    @staticmethod
    def to_jsonb(value):
        if isinstance(value, str):
            return func.to_jsonb(text(value))
        return func.to_jsonb(value)

    @staticmethod
    def max_dv_ordered(field):
        return func.max_dv_ordered(field).label('max_dv_ordered')

    @staticmethod
    def min_dv_ordered(field):
        return func.min_dv_ordered(field).label('min_dv_ordered')

    @staticmethod
    def count(distinct, field):
        if distinct:
            return func.count_distinct(field).cast(BIGINT)
        return func.count(field).cast(BIGINT) if field is not None else func.count('*').cast(BIGINT)


-32s-32 14.3-32 32v64c0 17.7-14.3 32-32 32H96c-17.7 0-32-14.3-32-32V352z"],folder:[512,512,[128193,128447,61716,"folder-blank"],"f07b","M64 480H448c35.3 0 64-28.7 64-64V160c0-35.3-28.7-64-64-64H288c-10.1 0-19.6-4.7-25.6-12.8L243.2 57.6C231.1 41.5 212.1 32 192 32H64C28.7 32 0 60.7 0 96V416c0 35.3 28.7 64 64 64z"],"file-waveform":[448,512,["file-medical-alt"],"f478","M96 0C60.7 0 32 28.7 32 64V288H144c6.1 0 11.6 3.4 14.3 8.8L176 332.2l49.7-99.4c2.7-5.4 8.3-8.8 14.3-8.8s11.6 3.4 14.3 8.8L281.9 288H352c8.8 0 16 7.2 16 16s-7.2 16-16 16H272c-6.1 0-11.6-3.4-14.3-8.8L240 275.8l-49.7 99.4c-2.7 5.4-8.3 8.8-14.3 8.8s-11.6-3.4-14.3-8.8L134.1 320H32V448c0 35.3 28.7 64 64 64H352c35.3 0 64-28.7 64-64V160H288c-17.7 0-32-14.3-32-32V0H96zM288 0V128H416L288 0z"],radiation:[512,512,[],"f7b9","M216 186.7c-23.9 13.8-40 39.7-40 69.3L32 256C14.3 256-.2 241.6 2 224.1C10.7 154 47.8 92.7 101.3 52c14.1-10.7 33.8-5.3 42.7 10l72 124.7zM256 336c14.6 0 28.2-3.9 40-10.7l72 124.8c8.8 15.3 3.7 35.1-12.6 41.9c-30.6 12.9-64.2 20-99.4 20s-68.9-7.1-99.4-20c-16.3-6.9-21.4-26.6-12.6-41.9l72-124.8c11.8 6.8 25.4 10.7 40 10.7zm224-80l-144 0c0-29.6-16.1-55.5-40-69.3L368 62c8.8-15.3 28.6-20.7 42.7-10c53.6 40.7 90.6 102 99.4 172.1c2.2 17.5-12.4 31.9-30 31.9zM256 208a48 48 0 1 1 0 96 48 48 0 1 1 0-96z"],"chart-simple":[448,512,[],"e473","M160 80c0-26.5 21.5-48 48-48h32c26.5 0 48 21.5 48 48V432c0 26.5-21.5 48-48 48H208c-26.5 0-48-21.5-48-48V80zM0 272c0-26.5 21.5-48 48-48H80c26.5 0 48 21.5 48 48V432c0 26.5-21.5 48-48 48H48c-26.5 0-48-21.5-48-48V272zM368 96h32c26.5 0 48 21.5 48 48V432c0 26.5-21.5 48-48 48H368c-26.5 0-48-21.5-


85" class="Function">isProp-nothing≡x (just _) p _ = ⊥.rec (¬nothing≡just p)

isContr-nothing≡nothing : isContr (nothing {A = A} ≡ nothing)
isContr-nothing≡nothing = inhProp→isContr refl (isProp-x≡nothing _)

discreteMaybe : Discrete A → Discrete (Maybe <a id="5093" href="Cu


// Copyright 2018-present Network Optix, Inc. Licensed under MPL 2.0: www.mozilla.org/MPL/2.0/

#pragma once

#include <QtCore/QObject>

#include <nx/utils/impl_ptr.h>
#include <nx/utils/uuid.h>

#include "detail/resources_structures.h"

class QnWorkbenchContext;

namespace nx::vms::client::desktop::jsapi {

namespace detail { class ResourcesApiBackend; }

/**
 * Contains methods and signals to work with available resources.
 */
class Resources: public QObject
{
    Q_OBJECT
    using base_type = QObject;

public:
    Resources(QObject* parent = nullptr);

    virtual ~Resources() override;

    /**
     * @addtogroup vms-resources Allows user to gather Resource descriptions.
     *
     * Contains methods and signals to work with available resources.
     *
     * Example:
     *
     *     const handleResourceAdded =
     *         function(resource)
     *         {
     *             if (resource.type = 'io_module')
     *                 vms.log.info(`Resource "${resource.name}" is IO module`)
     *
     *             if (vms.resources.hasMediaStream(resource.id))
     *                 vms.log.info(`Resource "${resource.name}" has media stream`)
     *         }
     *
     *     // You can connect to the signal using "connect" function and specifying a callback.
     *     vms.resources.added.connect(handleResourceAdded)
     *
     *     const resources = await vms.resources.resources()
     *     resources.forEach(handleResourceAdded)
     *
     * Resource may have additional parameters.
     *
     * Example:
     *
     *     vms.resources.parameter(resourceId, "hasDualStreaming")
     *
     * Also a custom parameter can be added to Resource:
     *
     *     vms.resources.setParameter(resourceId, "example", "value")
     *
     * @{
     */

    /**
     * Checks if the Resource with the specified id can have a media stream.
     * @ingroup vms-resources
     */
    Q_INVOKABLE bool hasMediaStream(const QString& resourceId) const;

    /**
     * @return List of all available (to the user and by the API constraints) Resources.
     */
    Q_INVOKABLE QList<Resource> resources() const;

    /**
     * @return Description of the Resource with the specified identifier.
     */
    Q_INVOKABLE ResourceResult resource(const QString& resourceId) const;

    /**
     * @return Parameter value.
     * @param resourceId Identifier of the Resource.
     * @param name Name of the parameter.
     */
    Q_INVOKABLE ParameterResult parameter(const QString& resourceId, const QString& name) const;

    /**
     * @return All parameter names.
     * @param resourceId Identifier of the Resource.
     */
    Q_INVOKABLE ParameterResult parameterNames(const QString& resourceId) const;

    /**
     * Sets the parameter value.
     * @param resourceId Identifier of the Resource.
     * @param name Name of the parameter.
     * @param value Value, can be a string, an object or an array.
     */
    Q_INVOKABLE Error setParameter(
        const QString& resourceId,
        const QString& name,
        const QJsonValue& value);

signals:
    /**
     * Called when a new Resource is added.
     * @param resource Description of the Resource.
     */
    void added(const Resource& resource);

    /**
     * Called when a Resource is deleted.
     * @param resourceId Identifier of the Resource.
     */
    void removed(const QString& resourceId);

    /** @} */ // group vms.resources

private:
    nx::utils::ImplPtr<detail::ResourcesApiBackend> d;
};

} // namespace nx::vms::client::desktop::jsapi


d != null) 'disabled': disabled!,
    if (name != null) 'name': name!,
    if (typeDescriptor != null) 'typeDescriptor': typeDescriptor!,
    if (typeUrls != null) 'typeUrls': typeUrls!,
    if (version != null) 'version': version!,
  };
}

/// GenericXdsConfig is used to specify the config status and the dump of any
/// xDS resource identified by their type URL.
///
/// It is the generalized version of the now deprecated ListenersConfigDump,
/// ClustersConfigDump etc \[#next-free-field: 10\]
class GenericXdsConfig {
  /// Per xDS resource status from the view of a xDS client
  /// Possible string values are:
  /// - "UNKNOWN" : Resource status is not available/unknown.
  /// - "REQUESTED" : Client requested this resource but hasn't received any
  /// update from management server. The client will not fail requests, but will
  /// queue them until update arrives or the client times out waiting for the
  /// resource.
  /// - "DOES_NOT_EXIST" : This resource has been requested by the client but
  /// has either not been delivered by the server or was previously delivered by
  /// the server and then subsequently removed from resources provided by the
  /// server. For more information, please refer to the :ref:`"Knowing When a
  /// Requested Resource Does Not Exist" ` section.
  /// - "ACKED" : Client received this resource and replied with ACK.
  /// - "NACKED" : Client received this resource and replied with NACK.
  /// - "RECEIVED_ERROR" : Client received an error from the control plane. The
  /// attached config dump is the most recent accepted one. If no config is
  /// accepted yet, the attached config dump will be empty.
  /// - "TIMEOUT" : Client timed out waiting for the resource from the control
  /// plane.
  core.String? clientStatus;

  /// Per xDS resource config status.
  ///
  /// It is generated by management servers. It will not be present if the CSDS
  /// server is an xDS client.
  /// Possible string values are:
  /// - "UNKNOWN" : Status info is not available/unknown.
  /// - "SYNCED" : Management server has sent the config to client and received
  /// ACK.
  /// - "NOT_SENT" : Config is not sent.
  /// - "STALE" : Management server has sent the config to client but hasn’t
  /// received ACK/NACK.
  /// - "ERROR" : Management server has sent the config to client but received
  /// NACK. The attached config dump will be the latest config (the rejected
  /// one), since it is the persisted version in the management server.
  core.String? configStatus;

  /// Set if the last update failed, cleared after the next successful update.
  ///
  /// The *error_state* field contains the rejected version of this particular
  /// resource along with the reason and timestamp. For successfully updated or
  /// acknowledged resource, this field should be empty.
  /// \[#not-implemented-hide:\]
  UpdateFailureState? errorState;

  /// Is static resource is true if it is specified in the config supplied
  /// through the file at the startup.
  core.bool? isStaticResource;

  /// Timestamp when the xDS resource was last updated
  core.String? lastUpdated;

  /// Name of the xDS resource
  core.String? name;

  /// Type_url represents the fully qualified name of xDS resource type like
  /// envoy.v3.Cluster, envoy.v3.ClusterLoadAssignment etc.
  core.String? typeUrl;

  /// This is the :ref:`version_info ` in the last processed xDS discovery
  /// response.
  ///
  /// If there are only static bootstrap listeners, this field will be ""
  core.String? versionInfo;

  /// The xDS resource config.
  ///
  /// Actual content depends on the type
  ///
  /// The values for Object must be JSON objects. It can consist of `num`,
  /// `String`, `bool` and `null` as well as `Map` and `List` values.
  core


p operation.</param>
    /// <param name="edges">The edges for the map.</param>
    public KernelProcessMap(KernelProcessMapState state, KernelProcessStepInfo operation, Dictionary<string, List<KernelProcessEdge>> edges)
        : base(typeof(KernelProcessMap), state, edges)
    {
        Verify.NotNull(operation, nameof(operation));
        Verify.NotNullOrWhiteSpace(state.Name, $"{nameof(state)}.{nameof(KernelProcessMapState.Name)}");
        Verify.NotNullOrWhiteSpace(state.Id, $"{nameof(state)}.{nameof(KernelProcessMapState.Id)}");

        this.Operation = operation;
    }
}


].join('/'),
    orderBy.orderType
  ].join(' ');
}

import {Component,Output,EventEmitter} from '@angular/core'
import { Observable } from 'rxjs/Rx';

@Component({
  selector: 'searchbar',
  template: `

                   <form class="navbar-form navbar-right" role="search">
                        <div class="form-group">
                            <input id="searchBar" type="text" placeholder="Cég név" style="color: #000000;">
                        </div>
                    </form>
  `
})
export class SearchbarComponent {

  @Output() searchChanged = new EventEmitter<string>();

constructor(){

}

ngOnInit()
{
       var keyups = Observable.fromEvent($("#searchBar"),"keyup")
        .map(e => e.target.value)
        .debounceTime(400)
        .distinctUntilChanged();
        keyups.subscribe(data=>this.searchChanged.emit(data));
}
}
import {
  IObserverCallback,
  IItem,
  IGetItem,
  IInsertItem,
  IQueryInput,
  IInsertInput,
  IUnlisten,
  IInsert,
  IDebeUse
} from './types';
import { DebeDispatcher } from './dispatcher';
import { ensureQuery } from './sanitize';

export class Debe<TBase = IItem, TDispatcher = DebeDispatcher<TBase>> {
  dispatcher: TDispatcher & DebeDispatcher<TBase>;
  initializing: Promise<void>;
  isInitialized = false;
  constructor(dispatcher: TDispatcher & DebeDispatcher<TBase>) {
    this.dispatcher = dispatcher;
    dispatcher.db = this as any;
  }
  async close() {
    await this.dispatcher.close();
  }
  async initialize() {
    if (!this.initializing) {
      this.initializing = this.dispatcher.initialize();
    }
    await this.initializing;
    this.isInitialized = true;
    return this;
  }
  use<T = IItem>(collection: string): IDebeUse<T> {
    const proxy = this;
    return new Proxy<any>(
      {},
      {
        get: function(t: string, methodName: string) {
          return (...args: [any]) => {
            return proxy[methodName](collection, ...args);
          };
        }
      }
    );
  }
  listen<T = IGetItem>(
    collection: string,
    callback: IObserverCallback<(T & IGetItem)[]>
  ): IUnlisten {
    return this.dispatcher.listen('insert', callback, { collection });
  }
  insert<T = IInsertItem>(
    collection: string,
    value: (T & IInsertItem)[],
    options?: IInsertInput
  ): Promise<(T & IGetItem)[]>;
  insert<T = IInsertItem>(
    collection: string,
    value: T & IInsertItem,
    options?: IInsertInput
  ): Promise<T & IGetItem>;
  insert<T = IInsertItem>(
    collection: string,
    value: (T & IInsertItem)[] | (T & IInsertItem),
    optionsInput: IInsertInput = {}
  ): Promise<(T & IGetItem)[] | T & IGetItem> {
    const options: IInsert = {
      refetchResult: false,
      update: true,
      ...optionsInput
    } as any;
    if (Array.isArray(value)) {
      return this.dispatcher.run<T & IGetItem>(
        'insert',
        collection,
        value,
        options
      );
    }
    return this.dispatcher
      .run<(T & IGetItem)[]>('insert', collection, [value], options)
      .then(x => (Array.isArray(x) ? x[0] : x));
  }
  // remove
  remove<T = any>(
    collection: string,
    value: string | string[]
  ): Promise


，比如什么表格文件，什么订单截图，发票，试剂盒说明书等等附件，你都可以直接用拖拽的方式插入到这个卡片中。它们会被自动转存到 `08-Assets` 目录下。

仪器设备的话，不仅要记录名称型号，可能还有使用培训的一些笔记。你可以参考试剂卡片，自行涉及仪器卡片的模板。

### 试剂库存的查询管理

![[Pasted image 20220328200413.png]]

 请直接到`00-MOC` 目录中，打开页面 [[试剂库存管理]] 并预览，便能查看 `06-Cards` 中试剂类卡片的信息。这段 dataview 的 query 代码如下：

 ![[Pasted image 20220328200535.png]]

 当你修改了卡片模板之后，可以在这段 query 中修改对应的键。

 ![[Pasted image 20220328200749.png]]

 如果列表太长，你可以直接在预览模式下按快捷键，Ctrl+F，输入关键词搜索，入上图所示，结果会被框选。

 总而言之，这并不是一个成熟的试剂库存管理方案，但对于个人来说其实足够用了。最重要的是这些资料就以卡片的形式存放于你的库中，你无论是写实验记录还是写论文草稿，都可以快速地引用它。如[[202112201648|Avidin]]

 ![[Pasted image 20220328201143.png]]

 而这个时候你也应该知道，在obsidian中被双链引用的内容，如果不是嵌入引用，按住 Ctrl，用鼠标悬停于引用上方是可以预览的。

 ![[Pasted image 20220328201208.png]]

 **That's pretty good!**

 ```ad-info
 title: 下节预告
 一周之内，看看文献，做做实验，买买试剂，学学仪器，科研工作大体就是这样。很快就到小组会时间了，你该写一下工作总结了，这该如何是好？
 ```

---

page:: 21---
title: 重要综述如何阅读
date: 2022-03-25 10:44:04
excerpt: 所谓的提高效率不过是从实际情况出发有所权衡和取舍。对于重要的文献和综述，再别无他法，只能是老老实实下苦功夫读懂读透。
tags: obsidian读文献
rating: ⭐⭐⭐
status: complete
destination: 03-Projects/黑曜石玩家指南
share: false
---

```ad-info
title: 友情提示
综述类文献的阅读与之前非常相似，在此部分内容