on('error', function(e) {
    console.log('ERROR: ' + e.message);
});

var express = require('express');
var cors = require('cors');
var app = express();

app.use(cors());

app.get('/api/v1/customers', function (req, res, next) {
    // res.json({msg: 'This is CORS-enabled for all origins!'});
    res.send(jsObject);
})

app.listen(8080, ()=> console.log('CORS-enabled web server listening on port 80'));
import { EntityRepository, Repository } from 'typeorm';
import { Product } from './product.entity';
import { CreateProductDto } from './dto/create-product.dto';
import {
  ConflictException,
  InternalServerErrorException,
} from '@nestjs/common';
import { CredentialsDto } from '../auth/dto/credentials.dto';
import { FindProductsQueryDto } from './dto/find-products-query-dto';

@EntityRepository(Product)
export class ProductRepository extends Repository<Product> {
  async findProducts(
    queryDto: FindProductsQueryDto,
  ): Promise<{ products: Product[]; total: number }> {
    const { price, name, description } = queryDto;
    const query = this.createQueryBuilder('product');

    query.select(['product.id', 'product.name', 'product.price', 'product.description']);

    const [products, total] = await query.getManyAndCount();

    return { products, total };
  }

  async createProduct(
    createProductDto: CreateProductDto,
  ): Promise<Product> {
    const { price, name, description } = createProductDto;

    const product = this.create();
    product.price = price;
    product.name = name;
    product.description = description;
    try {
      await product.save();
      return product;
    } catch (error) {
      throw new InternalServerErrorException(
        'Erro ao salvar o usuário no banco de dados',
      );
    }
  }
}
import * as Joi from 'joi'
import { v1 as uuidv1 } from 'uuid'

import { validateSchema } from '@utils/validators'

const ITEM_ITEM_ID = 'itemId'
const ITEM_PURCHASED = 'purchased'
const ITEM_QUANTITY = 'quantity'
const ITEM_UNIT = 'unit'
const LIST_ITEMS = 'items'

export interface ListItemFactoryParams {
  itemId?: string,
  name: string,
  purchased?: boolean,
  quantity?: number,
  unit?: string,
}

interface ListItem {
  itemId: string,
  name: string,
  purchased: boolean,
  quantity: number,
  unit?: string,
}

export interface ShoppingListFactoryParams {
  listId: string,
  items?: ListItem[],
}

interface ShoppingList {
  listId: string,
  items: ListItem[],
}

const listItemSchema = Joi.object().keys({
  [ITEM_ITEM_ID]: Joi.string().required(),
  name: Joi.string().required(),
  [ITEM_PURCHASED]: Joi.boolean().required(),
  [ITEM_QUANTITY]: Joi.number().integer().positive().required(),
  [ITEM_UNIT]: Joi.string(),
})

export const listItemFactory = (params: ListItemFactoryParams): ListItem => {
  const itemData = { name: params.name }
  itemData[ITEM_ITEM_ID] = params.hasOwnProperty(ITEM_ITEM_ID) ? params[ITEM_ITEM_ID] : uuidv1()
  itemData[ITEM_PURCHASED] = params.hasOwnProperty(ITEM_PURCHASED) ? params[ITEM_PURCHASED] : false
  itemData[ITEM_QUANTITY] = params.hasOwnProperty(ITEM_QUANTITY) ? params[


;

  constructor(private config: CharacterConfig, image = "default") {
    this.id = config.id;
    this.view = new Container();

    const sprite = Sprite.from(config.images[image]);
    sprite.alpha = 0;
    sprite.anchor.set(0.5, 1);
    sprite.y = screenHeight;

    this.view.addChild(sprite);
  }

  fadeIn = (duration = 1000) => {
    const sprite = this.view.children[0];
    return fade("in", sprite, duration);
  };

  moveTo = (
    { x = this.view.x, y = this.view.y }: Partial<Point>,
    duration = 1000
  ) =>
    new Promise(resolve => {
      anime({
        targets: this.view,
        x,
        y,
        easing: "linear",
        duration,
        complete: () => resolve()
      });
    });

  changeImage = async (image: string) => {
    const prev = this.view.children[0];
    const next = Sprite.from(this.config.images[image]);
    next.anchor.set(0.5, 1);
    next.y = screenHeight;

    const remove = fade("out", prev, 1000);
    const add = fade("in", next, 1000);

    this.view.addChild(next);

    await Promise.all([remove, add]);
    this.view.removeChild(prev);
    return;
  };
}
import createFactory, {
  FactoryParam,
  NPM_REGISTRY,
  YARN_REGISTRY,
  encodePackageName,
  validRegistry,
  validPackageName,
  validVersion
} from '../index'

describe('createFactory', () => {
  describe('when param is valid', () => {
    function nofn (param?: FactoryParam) {
      const base = createFactory(param)

      const result: {
        [_: string]: string
      } = {}

      for (const [key, value] of Object.entries(base)) {
        result[key] = typeof value === 'function' ? '[Function]' : value
      }

      return result
    }

    describe('when param is undefined', () => {
      it('should work', () => {
        expect(nofn()).toEqual(nofn({}))
      })
    })

    describe('when param.registry is undefined', () => {
      it('should use npm registry', () => {
        expect(nofn({})).toEqual(nofn({
          registry: NPM_REGISTRY
        }))
      })
    })

    describe('when param.registry is specified', () => {
      it('npm', () => {
        expect(createFactory({
          registry: NPM_REGISTRY
        })).toMatchSnapshot()
      })

      it('yarn', () => {
        expect(createFactory({
          registry: YARN_REGISTRY
        })).toMatchSnapshot()
      })
    })

    describe('when param.package is specified', () => {
      it('without param.registry', () => {
        expect(createFactory({
          package: 'package'
        })).toMatchSnapshot()
      })

      it('with param.registry', () => {
        expect(createFactory({
          registry: NPM_REGISTRY,
          package: 'package'
        })).toMatchSnapshot()
      })

      it('scoped', () => {
        expect(createFactory({
          package: '@scope/package'
        })).toMatchSnapshot()
      })
    })

    describe('when param.package and param.version is specified', () => {
      it('without param.registry', () => {
        expect(createFactory({
          package: 'package',
          version: '1.2.3'
        })).toMatchSnapshot()
      })

      it('with param.r


.

   Repeat the same process for `Access` and `SAML` (3 times total).

4. Your optional claims will look like this:

## Generate application secret

 Create client secret

1. On the Port App page, click `Certificates & Secrets`.

2. On the `Client secrets` tab, click the `New client secret` button.

3. Configure the secret:

   3.1 **Description**: Enter a secret description, for example `Port Login Client Secret`.

   3.2 **Expires**: Select when the secret expires.

   Be sure to mark on your calendar the expiration date of the secret. The secret needs to be replaced before its expiration, otherwise login to Port will be disabled.

   3.3 Click `Add`.

4. **Copy the secret immediately**: A secret will be created and its Value will appear as shown in the image below. Document the secret's value immediately because it will never appear again after you leave this page.

## Provide application information to Port

Port needs the following information to complete the integration:

- The `Client Secret` value that you created in the previous step.
- The `Application (Client) ID`, which appears on the Port application overview page:

Port will provide you the `CONNECTION_NAME` needed for the homepage URL of the App.

## Distribute the application to users

 Assign users and groups

After the app setup is complete, you can assign it to your organization's users and groups:

1. Go to `Azure Active Directory`.

2. Go to `Enterprise Applications`.

3. Click on the Port app.

4. Click on `Users and Groups`.

5. Click `Add user/group`.

6. Select users and groups you want to grant access to Port, then click `Assign`.

 Make the application visible

1. Go to `Azure Active Directory` > `Enterprise Applications` > Port app.

2. Click on `Properties`.

3. Set the application properties:
   - Mark `Enabled for users to sign-in?` as `Yes`.
   - Mark `Visible to users?` as `Yes`.

   :::info Assignment required?
   By default the `Assignment required?` flag is set to `No`, meaning any user with the Homepage URL to the Port app can access it, even if the app isn't directly assigned to them. Changing the flag to `Yes` means only users and groups the app is directly assigned to can use and access it.
   :::

   <img src="/img/sso/azure-ad/AzureAppPropertiesValues.png" width


         At(event.sender).plus("\r\n").plus(Image(imageId!!)).plus("\r\n")
                    .plus("Title: $title").plus("\r\n")
                    .plus("ID: $pixivId").plus("\r\n")
                    .plus("AuthorID: $memberId").plus("\r\n")
                    .plus("AuthorName: $memberName").plus("\r\n")
                    .plus("Ratio: $similarity%").plus("\r\n")
                    .plus(getExtUrls(extUrls))
            } else {
                At(event.sender).plus("\r\n").plus("该图片因官方服务器奔溃而无法获取").plus("\r\n")
                    .plus("The image was unavailable due to a crash on the official server").plus("\r\n")
                    .plus("Title: $title").plus("\r\n")
                    .plus("ID: $pixivId").plus("\r\n")
                    .plus("AuthorID: $memberId").plus("\r\n")
                    .plus("AuthorName: $memberName").plus("\r\n")
                    .plus("Ratio: $similarity%").plus("\r\n")
                    .plus(getExtUrls(extUrls))
            }
        } catch (e: java.lang.Exception) {
            logger.error { e.message }
            e.printStackTrace()
            null
            //return At(event.sender).plus(e.message.toString())
        }
    }

    private suspend fun danBooRuSearch(event: GroupMessageEvent, everything: SaucenaoItem): Message? {

        return try {
            val header = everything.results?.get(0)?.header
            val data = everything.results?.get(0)?.data
            val similarity = header?.similarity
            val thumbnail = header?.thumbnail
            val extUrls = data?.extUrls

            val danbooruId = data?.danbooruId
            val memberName = data?.creator
            if (StringUtils.isBlank(danbooruId.toString())) {
                throw RuntimeException("搜索到的插画id为空")
            }
            val toExternalResource = getImage(thumbnail!!, CacheUtil.Type.NONSUPPORT).toByteArray().toExternalResource()
            val imageId = toExternalResource.uploadAsImage(event.group).imageId
            withContext(Dispatchers.IO) {
                toExternalResource.close()
            }
            if (!thumbnail.contains("https://img3.saucenao.com/") || !thumbnail.contains("https://img1.saucenao.com/")) {
                At(event.sender).plus("\r\n")
                    .plus(Image(imageId)).plus("\r\n")
                    .plus("ID: $danbooruId").plus("\r\n")
                    .plus("AuthorName: $memberName").plus("\r\n")
                    .plus("Ratio: $similarity%").plus("\r\n")
                    .plus(getExtUrls(extUrls))

            } else {
                At(event.sender).plus("\r\n")
                    .plus("该图片因官方服务器奔溃而无法获取").plus("\r\n")
                    .plus("The image was unavailable due to a crash on the official server").plus("\r\n")
                    .plus("ID: $danbooruId").plus("\r\n")
                    .plus("AuthorName: $memberName").plus("\r\n")
                    .plus("Ratio: $similarity%").plus("\r\n")
                    .plus(getExtUrls(extUrls))
            }
        } catch (e: java.lang.Exception) {
            logger.error { e.message }
            e.printStackTrace()
            null
        }
    }

    private suspend fun seiGaSearch(event: GroupMessageEvent, everything: SaucenaoItem): Message? {

        return try {
            val header = everything.results?.get(0)?.header
            val data = everything.results?.get(0)?.data
            val similarity = header?.similarity
            val thumbnail = header?.thumbnail
            val extUrls = data?.extUrls

            val


using Rubberduck.UI.Shell.Document;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Windows.Data;
using System.Windows.Media;
//using Rubberduck.Parsing.Annotations.Concrete;
//using Rubberduck.Parsing.Symbols;
//using Rubberduck.Resources.CodeExplorer;

namespace Rubberduck.UI.Converters
{
    public class SupportedDocumentTypeToIconConverter : ImageSourceConverter
    {
        private static readonly IDictionary<SupportedDocumentType, ImageSource> Mapping = new Dictionary<SupportedDocumentType, ImageSource>
        {
            [Supported


/*
    Plugin-SDK (Grand Theft Auto San Andreas) header file
    Authors: GTA Community. See more here
    https://github.com/DK22Pac/plugin-sdk
    Do not delete this comment block. Respect others' work!
*/
#pragma once

#include "PluginBase.h"
#include "CPed.h"
#include "CPedGroup.h"

class PLUGIN_API CPedGroups {
public:
    SUPPORTED_10US static short(&ScriptReferenceIndex)[8]; // static short ScriptReferenceIndex[8]
    SUPPORTED_10US static char(&ms_activeGroups)[8]; // static char ms_activeGroups[8]
    SUPPORTED_10US static bool &ms_bIsPlayerOnAMission;
    SUPPORTED_10US static unsigned int &ms_iNoOfPlayerKills;
    SUPPORTED_10US static CPedGroup(&ms_groups)[8]; // static CPedGroup ms_groups[8]

    //! return the index of the added group , return -1 if failed.
    SUPPORTED_10US static signed int AddGroup();
    SUPPORTED_10US static bool AreInSameGroup(CPed *ped1, CPed *ped2);
    SUPPORTED_10US static void CleanUpForShutDown();
    SUPPORTED_10US static signed int GetGroupId(CPedGroup *pedgrp);
    SUPPORTED_10US static char *GetPedsGroup(CPed *ped);
    SUPPORTED_10US static void Init();
    SUPPORTED_10US static bool IsGroupLeader(CPed *ped);
    SUPPORTED_10US static char IsInPlayersGroup(CPed *a1);
    SUPPORTED_10US static void Process();
    SUPPORTED_10US static void RegisterKillByPlayer();
    SUPPORTED_10US static void RemoveAllFollowersFromGroup(int groupID);
    SUPPORTED_10US static void RemoveGroup(int groupID);
};

#include "meta/meta.CPedGroups.h"


d_->buf4_init(&WMbeJ, PSIF_CC_TMP0, 0, 10, 10, 10, 10, 0, "WMbeJ");
        global_dpd_->buf4_axpy(&Z, &WMbeJ, 1.0);
        global_dpd_->buf4_close(&WMbeJ);
        global_dpd_->buf4_close(&Z);

        global_dpd_->buf4_close(&F);

        global_dpd_->file2_close(&tIA);

        /* E -> Wmbej */
        global_dpd_->file2_init(&tIA, PSIF_CC_OEI, 0, 0, 1, "tIA");

        global_dpd_->buf4_init(&E, PSIF_CC_EINTS, 0, 11, 0, 11, 0, 0, "E <ai|jk>");
        global_dpd_->buf4_init(&WMbEj, PSIF_CC_TMP0, 0, 10, 11, 10, 11, 0, "WMbEj");
        global_dpd_->contract424(&E, &tIA, &WMbEj, 3, 0, 1, -1, 1);
        global_dpd_->buf4_close(&WMbEj);
        global_dpd_->buf4_close(&E);

        global_dpd_->buf4_init(&E, PSIF_CC_EINTS, 0, 0, 10, 0, 10, 0, "E <ij|ka>");
        global_dpd_->buf4_init(&WMbeJ, PSIF_CC_TMP0, 0, 10, 10, 10, 10, 0, "WMbeJ");
        global_dpd_->contract424(&E, &tIA, &WMbeJ, 1, 0, 1, 1, 1);
        global_dpd_->buf4_close(&WMbeJ);
        global_dpd_->buf4_close(&E);

        global_dpd_->file2_close(&tIA);

        /* Sort to (ME,JB) */

        global_dpd_->buf4_init(&WMbEj, PSIF_CC_TMP0, 0, 10, 11, 10, 11, 0, "WMbEj");
        global_dpd_->buf4_sort(&WMbEj, PSIF_CC3_HET1, prsq, 10, 10, "CC3 WMbEj (ME,jb)");
        global_dpd_->buf4_close(&WMbEj);

        global_dpd_->buf4_init(&WMbeJ, PSIF_CC_TMP0, 0, 10, 10, 10, 10, 0, "WMbeJ");
        global_dpd_->buf4_sort(&WMbeJ, PSIF_CC3_HET1, psrq, 10, 10, "CC3 WMbeJ (Me,Jb)");
        global_dpd_->buf4_close(&WMbeJ);

        /* T1^2 -> Wmbej */

        global_dpd_->file2_init(&tIA, PSIF_CC_OEI, 0, 0, 1, "tIA");

        global_dpd_->buf4_init(&Y, PSIF_CC_TMP0, 0, 10, 0, 10, 0, 0, "Y (ME,JN)");
        global_dpd_->buf4_init(&D, PSIF_CC_DINTS, 0, 10, 11, 10, 11, 0, "D <ij|ab> (ia,bj)");
        global_dpd_->contract244(&tIA, &D, &Y, 1, 2, 1, 1, 0);
        global_dpd_->buf4_close(&D);
        global_dpd_->buf4_init(&W, PSIF_CC3_HET1, 0, 10, 10, 10, 10, 0, "CC3 WMbEj (ME,jb)");
        global_dpd_->contract424(&Y, &tIA, &W, 3, 0, 0, -1, 1);
        global_dpd_->buf4_close(&W);
        global_dpd_->buf4_close(&Y);


nst struct ipt_same_info *same = targinfo;
	struct ip_nat_range newrange;
	const struct ip_conntrack_tuple *t;

	IP_NF_ASSERT(hooknum == NF_IP_PRE_ROUTING ||
			hooknum == NF_IP_POST_ROUTING);
	ct = ip_conntrack_get(*pskb, &ctinfo);

	t = &ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple;

	/* Base new source on real src ip and optionally dst ip,
	   giving some hope for consistency across reboots.
	   Here we calculate the index in same->iparray which
	   holds the ipaddress we should use */

	tmpip = ntohl(t->src.ip);

	if (!(same->info & IPT_SAME_NODST))
		tmpip += ntohl(t->dst.ip);

	aindex = tmpip % same->ipnum;

	new_ip = htonl(same->iparray[aindex]);

	DEBUGP("ipt_SAME: src=%u.%u.%u.%u dst=%u.%u.%u.%u, "
			"new src=%u.%u.%u.%u\n",
			NIPQUAD(t->src.ip), NIPQUAD(t->dst.ip),
			NIPQUAD(new_ip));

	/* Transfer from original range. */
	newrange = ((struct ip_nat_range)
		{ same->range[0].flags, new_ip, new_ip,
		  /* FIXME: Use ports from correct range! */
		  same->range[0].min, same->range[0].max });

	/* Hand modified range to generic setup. */
	return ip_nat_setup_info(ct, &newrange, hooknum);
}

static struct ipt_target same_reg = {
	.name		= "SAME",
	.target		= same_target,
	.checkentry	= same_check,
	.destroy	= same_destroy,
	.me		= THIS_MODULE,
};

static int __init init(void)
{
	return ipt_register_target(&same_reg);
}

static void __exit fini(void)
{
	ipt_unregister_target(&same_reg);
}

module_init(init);
module_exit(fini);


ha
/* 801D6290 001D1EF0  38 00 00 80 */	li r0, 0x80
/* 801D6294 001D1EF4  39 03 07 E8 */	addi r8, r3, lbl_804907E8@l
/* 801D6298 001D1EF8  38 A0 00 40 */	li r5, 0x40
/* 801D629C 001D1EFC  80 E8 00 00 */	lwz r7, 0(r8)
/* 801D62A0 001D1F00  38 61 00 0C */	addi r3, r1, 0xc
/* 801D62A4 001D1F04  98 01 00 10 */	stb r0, 0x10(r1)
/* 801D62A8 001D1F08  38 80 00 40 */	li r4, 0x40
/* 801D62AC 001D1F0C  38 C7 00 01 */	addi r6, r7, 1
/* 801D62B0 001D1F10  90 E1 00 18 */	stw r7, 0x18(r1)
/* 801D62B4 001D1F14  38 06 00 01 */	addi r0, r6, 1
/* 801D62B8 001D1F18  90 C8 00 00 */	stw r6, 0(r8)
/* 801D62BC 001D1F1C  90 A1 00 0C */	stw r5, 0xc(r1)
/* 801D62C0 001D1F20  9B E1 00 14 */	stb r31, 0x14(r1)
/* 801D62C4 001D1F24  90 08 00 00 */	stw r0, 0(r8)
/* 801D62C8 001D1F28  90 C1 00 18 */	stw r6, 0x18(r1)
/* 801D62CC 001D1F2C  48 00 33 41 */	bl TRKWriteUARTN
/* 801D62D0 001D1F30  38 60 00 00 */	li r3, 0
/* 801D62D4 001D1F34  48 00 00 0C */	b lbl_801D62E0
lbl_801D62D8:
/* 801D62D8 001D1F38  7F E3 FB 78 */	mr r3, r31
/* 801D62DC 001D1F3C  4B FF EA 01 */	bl TRKMessageSend
lbl_801D62E0:
/* 801D62E0 001D1F40  80 01 00 E4 */	lwz r0, 0xe4(r1)
/* 801D62E4 001D1F44  83 E1 00 DC */	lwz r31, 0xdc(r1)
/* 801D62E8 001D1F48  7C 08 03 A6 */	mtlr r0
/* 801D62EC 001D1F4C  38 21 00 E0 */	addi r1, r1, 0xe0
/* 801D62F0 001D1F50  4E 80 00 20 */	blr

.global TRKDoWriteMemory
TRKDoWriteMemory:
/* 801D62F4 001D1F54  54 2B 06 FE */	clrlwi r11, r1, 0x1b
/* 801D62F8 001D1F58  7C 2C 0B 78 */	mr r12, r1
/* 801D62FC 001D1F5C  21 6B F6 C0 */	subfic r11, r11, -2368
/* 801D6300 001D1F60  7C 21 59 6E */	stwux r1, r1, r11
/* 801D6304 001D1F64  7C 08 02 A6 */	mflr r0
/* 801D6308 001D1F68  90 0C 00 04 */	stw r0, 4(r12)
/* 801D630C 001D1F6C  93 EC FF FC */	stw r31, -4(r12)
/* 801D6


（二）生态综合治理项目：有明确的区域范围，项目区集中连片，具备开发治理条件，对改善农业生产条件和农业生态具有明显效果；

（三）中型灌区节水配套改造项目：符合区域水资源利用总体规划和节水灌溉发展规划，直接为农业综合开发项目区提供水利灌排条件。

乡（镇）人民政府在申报土地治理项目前，须经项目区村民委员会采取民主方式征求村民对自愿筹资投劳的意见，并出具相关的证明材料。

第十三条 国家和省、市级农业产业化龙头企业，农民专业合作经济组织可以申报产业化经营项目。申报产业化经营项目应当具备下列条件：

（一）符合国家产业政策和行业发展规划，体现当地资源优势和区域特色，以生产、加工、销售当地优势农产品为主营业务；

（二）申报单位或者其控股单位具有独立的法人资格；

（三）申报单位经营期在2年以上，经济、财务指标等符合有关要求；

（四）申报单位与当地农户建立了生产、加工、销售的利益联结机制。

第十四条 申报农业科学技术示范推广项目应当具备下列条件：

（一）符合国家农业产业政策和农业综合开发有关项目管理的要求；

（二）申报单位具有独立的法人资格，有科研推广能力、技术依托单位；

（三）推广的科技成果应当具有地域适应性、技术先进性以及推广效益，并通过省级以上专业部门组织的成果鉴定。

第十五条 开发县农业综合开发管理机构对申请立项的土地治理项目，经实地考察并组织专家评审，符合条件的报省辖市、省农业综合开发管理机构审定，分别编入省、省辖市、开发县土地治理项目库。

第十六条 开发县农业综合开发管理机构根据上级下达的年度土地治理项目财政资金控制指标，从农业综合开发项目库中确定年度土地�


1a4, 0x030501a9, 0x05005504,   // ms.lg.id_322 en.eu.no_433  en.fr.nl_544 rw.fr.un_320
  0x1f05040c, 0x641135a4, 0x18210fa4, 0x0d1613ad,   // fi.fr.cy_543 zu.ro.lg_433  lv.jw.ga_433 et.hr.cs_643
  0x1029350c, 0x322935a4, 0x17286b08, 0x04111a02,   // zu.sl.lt_543 zu.sl.bs_433  ceb.sw.sr_443 tl.ro.fi_222
  // [5f80]
  0x1b311208, 0x212a290c, 0x16002107, 0x10130f08,   // hu.az.tr_443 sl.mt.jw_543  jw.hr.un_420 lv.et.lt_443
  0x16006408, 0x1c2a1ea0, 0x1017040c, 0x190f0bad,   // lg.hr.un_430 ms.mt.id_322  ru.sr.be_543 es.lv.gl_643
  0x201b060c, 0x2800041b, 0x190b23ac, 0x030c2013,   // de.tr.sq_543 fi.sw.un_770  ca.es.gl_632 sq.sv.nl_665
  0x131827a9, 0x04032704, 0x030806ee, 0x041c25a9,   // gd.ga.et_544 gd.nl.fi_332  de.no.nl_422 eu.id.fi_544
  // [5f90]
  0x103f04a7, 0x0a002104, 0x0e001812, 0x3f5310a4,   // fi.af.lt_532 jw.pt.un_320  ga.is.un_640 lt.ht.af_433
  0x0d000f12, 0x273f03af, 0x0a2311af, 0x64001602,   // lv.cs.un_640 nl.af.gd_655  ro.ca.pt_655 hr.lg.un_220
  0x3f032704, 0x3f001f2a, 0x1f3f100c, 0x011f10ee,   // gd.nl.af_332 cy.af.un_970  lt.af.cy_543 lt.cy.en_422
  0x072320a4, 0x211e1a08, 0x1a4a2813, 0x2d18270d,   // sq.ca.it_433 tl.ms.jw_443  sw.yo.tl_665 gd.ga.sk_554
  // [5fa0]
  0x10116ea6, 0x0e2a0b08, 0x4a003113, 0x10072d12,   // hmn.ro.lt_521 es.mt.is_443  az.yo.un_650 sk.it.lt_654
  0x270b18af, 0x1900281a, 0x0f1310ec, 0x08001913,   // ga.es.gd_655 sw.gl.un_760  lt.et.lv_644 gl.no.un_650
  0x05002a02, 0x27003b0c, 0x64133508, 0x0b0a5202,   // mt.fr.un_220 so.gd.un_530  zu.et.lg_443 ha.pt.es_222
  0x21001604, 0x1a006e0d, 0x5200050d, 0x3229080b,   // hr.jw.un_320 hmn.tl.un_540  fr.ha.un_540 no.sl.bs_542
  // [5fb0]
  0x100f0c09, 0x4a0b0a14, 0x175


osen);
  const categoryData = await categories(trait);

  let result = {};

  if ( traitConfig.labels?.all && !any ) {
    const key = prefixed ? `${trait}:ALL` : "ALL";
    result[key] = { label: traitConfig.labels.all, chosen: chosen.has(key), sorting: false };
  }

  if ( prefixed && any ) {
    const key = `${trait}:*`;
    result[key] = {
      label: keyLabel(key).titleCase(),
      chosen: chosen.has(key), sorting: false, wildcard: true
    };
  }

  const prepareCategory = (key, data, result, prefix, topLevel=false) => {
    let label = _innerLabel(data, traitConfig);
    if ( !label ) label = key;
    if ( prefixed ) key = `${prefix}:${key}`;
    result[key] = {
      label,
      chosen: data.selectable !== false ? chosen.has(key) : false,
      selectable: data.selectable !== false,
      sorting: topLevel ? traitConfig.sortCategories === true : true
    };
    if ( data.children ) {
      const children = result[key].children = {};
      if ( prefixed && any ) {
        const anyKey = `${key}:*`;
        children[anyKey] = {
          label: keyLabel(anyKey).titleCase(),
          chosen: chosen.has(anyKey), sorting: false, wildcard: true
        };
      }
      Object.entries(data.children).forEach(([k, v]) => prepareCategory(k, v, children, key));
    }
  };

  Object.entries(categoryData).forEach(([k, v]) => prepareCategory(k, v, result, trait, true));

  return new SelectChoices(result).sort();
}

/* -------------------------------------------- */

/**
 * Prepare an object with all possible choices from a set of keys. These choices will be grouped by
 * trait type if more than one type is present.
 * @param {Set<string>} keys  Prefixed trait keys.
 * @returns {Promise<SelectChoices>}
 */
export async function mixedChoices(keys) {
  if ( !keys.size ) return new SelectChoices();
  const types = {};
  for ( const key of keys ) {
    const split = key.split(":");
    const trait = split.shift();
    const selectChoices = (await choices(trait, { prefixed: true })).filter(new Set([key]));
    types[trait] ??= { label: traitLabel(trait), children: new SelectChoices() };
    types[trait].children.merge(selectChoices);
  }
  if ( Object.keys(types).length > 1 ) return new SelectChoices(types);
  return Object.values(types)[0].children;
}

/* -------------------------------------------- */

/**
 * Fetch an item for the provided ID. If the provided ID contains a compendium pack name
 * it will be fetched from that pack, otherwise it will be fetched from the compendium defined
 * in `DND5E.sourcePacks.ITEMS`.
 * @param {string} identifier            Simple ID or compendium name and ID separated by a dot.
 * @param {object} [options]
 * @param {boolean} [options.indexOnly]  If set to true, only the index data will be fetched (will never return
 *                                       Promise).
 * @param {boolean} [options.fullItem]   If set to true, the full item will be returned as long as `indexOnly` is
 *                                       false.
 * @returns {Promise<Item5e>|object}     Promise for a `Document` if `indexOnly` is false & `fullItem` is true,
 *                                       otherwise else a simple object containing the minimal index data.
 */
export function getBaseItem(identifier, { indexOnly=false, fullItem=false }={}) {
  const uuid = getBaseItemUUID(identifier);
  const { collection, documentId: id } = foundry.utils.parseUuid(uuid);
  const pack = collection?.metadata.id;

  // Full Item5e documen


#0
	bl ov29_022EA428
	mov r0, #8
	mov r1, #0x1b
	bl ov29_022EA370
	mov r4, #0
	b _02385EFC
_02385738:
	ldr r8, [r6, #0xb4]
	ldr r0, _02385F70 ; =OVERLAY31_UNKNOWN_POINTER__NA_238A270
	add sb, r8, #0x124 + HANDLE_MOVES_MENU_OFFSET_2
	ldr fp, [r0]
	bl ov29_022EBA70
	ldrb r0, [r8, #7]
	cmp r0, #0
	beq _023857B0
	ldr r0, [sp, #8]
	cmp r0, #0
	beq _02385770
	mov r0, #0x14
	mov r1, #0
	bl AddDungeonSubMenuOption
_02385770:
	ldrb r0, [sb, fp, lsl #3]
	tst r0, #1
	movne r0, #1
	moveq r0, #0
	tst r0, #0xff
	beq _023857BC
	ldrb r0, [sb, fp, lsl #3]
	mov r1, #0
	tst r0, #8
	beq _023857A4
	mov r0, #0x33
	bl AddDungeonSubMenuOption
	b _023857BC
_023857A4:
	mov r0, #0x1e
	bl AddDungeonSubMenuOption
	b _023857BC
_023857B0:
	mov r0, #0x1f
	mov r1, #0
	bl AddDungeonSubMenuOption
_023857BC:
	ldr r0, [sp, #4]
	cmp r0, #0
	beq _023857E0
	mov r0, #0x20
	mov r1, #0
	bl AddDungeonSubMenuOption
	mov r0, #0x21
	mov r1, #0
	bl AddDungeonSubMenuOption
_023857E0:
	mov r0, #0x1d
	mov r1, #0
	bl AddDungeonSubMenuOption
	ldr r0, [sp, #4]
	cmp r0, #0
	bne _02385804
	mov r0, #0x20
	bl DisableDungeonSubMenuOption
	b _0238595C
_02385804:
	ldr r0, _02385F70 ; =OVERLAY31_UNKNOWN_POINTER__NA_238A270
	ldr fp, [r0]
	add r0, r8, fp, lsl #3
	add r0, r0, #0x100
	ldrh r0, [r0, #0x28 + HANDLE_MOVES_MENU_OFFSET_2]
	mov sb, fp
	bl IsNot2TurnsMoveOrSketch
	cmp r0, #0
	moveq r0, #0
	beq _0238592C
	add sb, sb, #1
	b _02385920
_02385834:
	add r0, r8, sb, lsl #3
	ldrb r0, [r0, #0x124 + HANDLE_MOVES_MENU_OFFSET_2]
	tst r0, #1
	movne r0, #1
	moveq r0, #0
	tst r0, #0xff
	beq _02385928
	add r0, r8, sb, lsl #3
	add r0, r0, #0x100
	ldrh r0, [r0, #0x28 + HANDLE_MOVES_MENU_OFFSET_2]
	bl IsNot2TurnsMoveOrSketch
	cmp r0, #0
	beq _02385928
	add r


 in the debug symbol data. This is likely either a library function or the game was compiled without debug symbols. Please refer to the TDR documentation for additional guidance. */
void g_font1()
{ // line 254, offset 0x001074cc
	/* begin block 1 */
		// Start line: 509
	/* end block 1 */
	// End Line: 510

	/* begin block 2 */
		// Start line: 510
	/* end block 2 */
	// End Line: 511

	/* begin block 3 */
		// Start line: 511
	/* end block 3 */
	// End Line: 512

	/* begin block 4 */
		// Start line: 512
	/* end block 4 */
	// End Line: 513

	/* begin block 5 */
		// Start line: 513
	/* end block 5 */
	// End Line: 514

	/* begin block 6 */
		// Start line: 514
	/* end block 6 */
	// End Line: 515

	/* begin block 7 */
		// Start line: 515
	/* end block 7 */
	// End Line: 516

	return null;
}


 k;
        for (let i = 1; i <= K; i++)
        {

            // in this loop we count all
            // possible leaps to reach
            // the jth stair with the
            // help of ith leap or less
            for (let j = 0; j <= N; j++)
            {

                // if the leap is not
                // more than the i-j
                if (j >= i)
                {

                    // calculate the value and
                    // store in combo[j] to
                    // reuse it for next leap
                    // calculation for the
                    // jth stair
                    combo[j] += combo[j - i];
                }
            }
        }

        // returns the no of possible
        // number of leaps to reach
        // the top of building of
        // n stairs
        return combo[N];
    }

    // N i the no of total stairs
    // K is the value of the
    // greatest leap
    let N = 29;
    let K = 5;

    document.write(solve(N, K));
    solve(N, K);

    // This code is contributed by decode2207.
</script>
```

**Output:**

```
603
```

**时间复杂度:**O(N * K)
T3】辅助空间: O(N)# 检查一个数是否可以表示为 2 的偶次幂的程序

> 原文:[https://www . geeksforgeeks . org/program-to-check-如果一个数字可以表示为 2 的偶数幂或不/](https://www.geeksforgeeks.org/program-to-check-if-a-number-can-be-expressed-as-an-even-power-of-2-or-not/)

给定一个正整数 **N** ，任务是检查给定的整数是否为**2**T5 的偶数[次幂。](https://www.geeksforgeeks.org/program-to-find-whether-a-no-is-power-of-two/)

**示例:**

> **输入:** N = 4
> **输出:**是
> **说明:** 4 可以表示为 2 <sup>2</sup> = 4，是 2 的偶数次方。
>
> **输入:** N = 8
> **输出:** No
> **说明:** 8 可以表示为 2 <sup>3</sup> = 8，是 2 的奇次幂。

**天真法:**最简单的方法是迭代 **2** 的所有指数值，检查对应的值是否为 **N** ，[指数是否为偶数](https://www.geeksforgeeks.org/check-if-a-n-base-number-is-even-or-odd/)。如果两者都为真，则打印**“是”**。否则，如果 **2** 的当前指数超过 **N** ，则打印**“否”**。

下面是上述方法的实现:

## C++

```
// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to check if N can be
// expressed as an even power of 2
bool checkEvenPower(int n)
{
    int x = 0;

    // Iterate till x is N
    while (x < n) {

        int value = pow(2, x);

        if (value == n) {

            // if x is even then
            // return true
            if (x % 2 == 0)
                return true;
            else
                return false;
        }

        // Increment x
        x++;
    }

    // If N is not a power of 2
    return false;
}

// Driver Code
int main()
{
    int N = 4;
    cout << (check


Assertions.assertThrows(
        ExecutionException.class,
        () -> {
          SettableApiFuture<Integer> future = SettableApiFuture.<Integer>create();
          future.setException(new Exception());
          future.get();
        });
  }

  @Test
  void testListener() {
    final AtomicInteger flag = new AtomicInteger();
    SettableApiFuture<Integer> future = SettableApiFuture.<Integer>create();
    future.addListener(
        new Runnable() {
          @Override
          public void run() {
            flag.set(1);
          }
        },
        new Executor() {
          @Override
          public void execute(Runnable r) {
            r.run();
          }
        });
    future.set(0);
    Truth.assertThat(flag.get()).isEqualTo(1);
  }
}
/*
 * Copyright 2025 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.cloud.dataplex.v1.samples;

// [START dataplex_v1_generated_BusinessGlossaryService_CreateGlossaryTerm_GlossarynameGlossarytermString_sync]
import com.google.cloud.dataplex.v1.BusinessGlossaryServiceClient;
import com.google.cloud.dataplex.v1.GlossaryName;
import com.google.cloud.dataplex.v1.GlossaryTerm;

public class SyncCreateGlossaryTermGlossarynameGlossarytermString {

  public static void main(String[] args) throws Exception {
    syncCreateGlossaryTermGlossarynameGlossarytermString();
  }

  public static void syncCreateGlossaryTermGlossarynameGlossarytermString() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (BusinessGlossaryServiceClient businessGlossaryServiceClient =
        BusinessGlossaryServiceClient.create()) {
      GlossaryName parent = GlossaryName.of("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
      GlossaryTerm term = GlossaryTerm.newBuilder().build();
      String termId = "termId-877206873";
      GlossaryTerm response =
          businessGlossaryServiceClient.createGlossaryTerm(parent, term, termId);
    }
  }
}
// [END dataplex_v1_generated_BusinessGlossaryService_CreateGlossaryTerm_GlossarynameGlossarytermString_sync]
/*
 * Copyright 2025 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.cloud.dataplex.v1.samples;

// [START dataplex_v1_generated_BusinessGlossaryService_DeleteGlossaryTerm_String_sync]
import com.google.cloud.dataplex.v1.BusinessGlossaryServiceClient;
import com.google.cloud.dataplex.v1.GlossaryTermName;
import com.google.protobuf.Empty;

public class SyncDeleteGlossaryTermString {

  public sta


 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

package hudson.cli;

import static hudson.cli.CLICommandInvoker.Matcher.failedWith;
import static hudson.cli.CLICommandInvoker.Matcher.hasNoErrorOutput;
import static hudson.cli.CLICommandInvoker.Matcher.hasNoStandardOutput;
import static hudson.cli.CLICommandInvoker.Matcher.succeeded;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.startsWith;

import hudson.model.Computer;
import jenkins.model.Jenkins;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.jvnet.hudson.test.Issue;
import org.jvnet.hudson.test.JenkinsRule;
import org.jvnet.hudson.test.junit.jupiter.WithJenkins;

@WithJenkins
class GetNodeCommandTest {

    private CLICommandInvoker command;

    private JenkinsRule j;

    @BeforeEach
    void setUp(JenkinsRule rule) {
        j = rule;
        command = new CLICommandInvoker(j, new GetNodeCommand());
    }

    @Test
    void getNodeShouldFailWithoutComputerExtendedReadPermission() throws Exception {

        // JENKINS-65578 workaround
        Computer.EXTENDED_READ.enabled = false;

        j.createSlave("MyAgent", null, null);

        final CLICommandInvoker.Result result = command
                .authorizedTo(Jenkins.READ)
                .invokeWithArgs("MyAgent")
        ;

        assertThat(result.stderr(), containsString("ERROR: user is missing the Agent/Configure permission"));
        assertThat(result, failedWith(6));
        assertThat(result, hasNoStandardOutput());
    }

    @Test
    void getNodeShouldYieldConfigXml() throws Exception {

        j.createSlave("MyAgent", null, null);

        final CLICommandInvoker.Result result = command
                .authorizedTo(Computer.EXTENDED_READ, Jenkins.READ)
                .invokeWithArgs("MyAgent")
        ;

        assertThat(result.stdout(), startsWith("<?xml version=\"1.1\" encoding=\"UTF-8\"?>"));
        assertThat(result.stdout(), containsString("<name>MyAgent</name>"));
        assertThat(result, hasNoErrorOutput());
        assertThat(result, succeeded());
    }

    @Test
    void getNodeShouldFailIfNodeDoesNotExist() {

        final CLICommandInvoker.Result result = command
                .authorizedTo(Computer.EXTENDED_READ, Jenkins.READ)
                .invokeWithArgs("MyAgent")
        ;

        assertThat(result.stderr(), containsString("ERROR: No such node 'MyAgent'"));
        assertThat(result, failedWith(3));
        assertThat(result, hasNoStandardOutput());
    }

    @Issue("SECURITY-281")
    @Test
    void getNodeShouldFailForBuiltInNode() {
        CLICommandInvoker.Result result = command.authorizedTo(Computer.EXTENDED_READ, Jenkins.READ).invokeWithArgs("");
        assertThat(result.stderr(), containsString("No such node ''"));
        assertThat(result, failedWith(3));
        assertThat(result, hasNoStandardOutput());

        // old name
        result = command.authorizedTo(Computer.EXTENDED_READ, Jenkins.READ).invokeWithArgs("(master)");
        assertThat(result.stderr(), containsString("No such node '(master)'"));
        assertThat(result, failedWith(3));
        assertThat(result, hasNoStandardOutput());

        // new name
        result = command.authorizedTo(Computer.EXTENDED_READ, Jenkins.READ).invokeWithArgs("(built-in)");
        assertThat(result.stderr(), containsString("No such node '(built-in)'"));
        assertThat(result, failedWith(3));
        assertThat(resul


ImGui::IsKeyPressed(ImGuiKey_DownArrow)) {
                    decrementDigit(i);
                }
                if ((ImGui::IsKeyPressed(ImGuiKey_LeftArrow) || ImGui::IsKeyPressed(ImGuiKey_Backspace)) && i > 0) {
                    moveCursorToDigit(i - 1);
                }
                if (ImGui::IsKeyPressed(ImGuiKey_RightArrow) && i < 11) {
                    moveCursorToDigit(i + 1);
                }

                auto chars = io.InputQueueCharacters;

                // For each keyboard characters, type it
                for (int j = 0; j < chars.Size; j++) {
                    if (chars[j] >= '0' && chars[j] <= '9') {
                        digits[i + j] = chars[j] - '0';
                        if ((i + j) < 11) { moveCursorToDigit(i + j + 1); }
                        frequencyChanged = true;
                    }
                }

                if (mw != 0) {
                    int count = abs(mw);
                    for (int j = 0; j < count; j++) {
                        mw > 0 ? incrementDigit(i) : decrementDigit(i);
                    }
                }
            }
        }
        digitHovered = hovered;

        if (isInArea(mousePos, digitTopMins[0], digitBottomMaxs[11])) {
            bool shortcutKey = io.ConfigMacOSXBehaviors ? (io.KeyMods == ImGuiKeyModFlags_Super) : (io.KeyMods == ImGuiKeyModFlags_Ctrl);
            bool ctrlOnly = (io.KeyMods == ImGuiKeyModFlags_Ctrl);
            bool shiftOnly = (io.KeyMods == ImGuiKeyModFlags_Shift);
            bool copy  = ((shortcutKey && ImGui::IsKeyPressed(ImGuiKey_C)) || (ctrlOnly  && ImGui::IsKeyPressed(ImGuiKey_Insert)));
            bool paste = ((shortcutKey && ImGui::IsKeyPressed(ImGuiKey_V)) || (shiftOnly && ImGui::IsKeyPressed(ImGuiKey_Insert)));
            if (copy) {
                // Convert the freqency to a string
                std::string freqStr = hrfreq::toString(frequency);

                // Write it to the clipboard
                ImGui::SetClipboardText(freqStr.c_str());
            }
            if (paste) {
                // Attempt to parse the clipboard as a number
                const char* clip = ImGui::GetClipboardText();

                // If the clipboard is not empty, attempt to parse it
                if (clip) {
                    double newFreq;
                    if (hrfreq::fromString(clip, newFreq)) {
                        setFrequency(abs(newFreq));
                        frequencyChanged = true;
                    }
                }
            }
        }
    }

    uint64_t freq = 0;
    for (int i = 0; i < 12; i++) {
        freq += digits[i] * pow(10, 11 - i);
    }

    uint64_t orig = freq;
    freq = std::clamp<uint64_t>(freq, minFreq, maxFreq);
    if (freq != orig && limitFreq) {
        setFrequency(freq);
    }
    else {
        frequency = orig;
    }

    ImGui::PopFont();

    ImGui::SetCursorPosX(digitBottomMaxs[11].x + (17.0f * style::uiScale));
}

void FrequencySelect::setFrequency(int64_t freq) {
    freq = std::max<int64_t>(0, freq);
    int i = 11;
    for (uint64_t f = freq; i >= 0; i--) {
        digits[i] = f % 10;
        f -= digits[i];
        f /= 10;
    }
    frequency = freq;
}#include <backend.h>log
#include "


 Fetch Stall", Counter::Units::Percent, [=]() {
         /* Percentage of clock cycles where the shader processors cannot make any more requests for texture data. */
         /* Countables:
          * PERFCOUNTER_GROUP_SP::COUNTABLE_4 = PERF_SP_STALL_CYCLES_TP
          * PERFCOUNTER_GROUP_BV_SP::COUNTABLE_4 = PERF_SP_STALL_CYCLES_TP
          * PERFCOUNTER_GROUP_RBBM::COUNTABLE_6 = PERF_RBBM_STATUS_MASKED
          */
         return percent(cbSum(PERF_SP_STALL_CYCLES_TP), number_of_usptp * PERF_RBBM_STATUS_MASKED);
      }
   );
   counter("% Texture L1 Miss", Counter::Units::Percent, [=]() {
         /* Number of L1 texture cache misses divided by L1 texture cache requests. */
         /* Countables:
          * PERFCOUNTER_GROUP_TP::COUNTABLE_6 = PERF_TP_L1_CACHELINE_REQUESTS
          * PERFCOUNTER_GROUP_TP::COUNTABLE_7 = PERF_TP_L1_CACHELINE_MISSES
          * PERFCOUNTER_GROUP_BV_TP::COUNTABLE_6 = PERF_TP_L1_CACHELINE_REQUESTS
          * PERFCOUNTER_GROUP_BV_TP::COUNTABLE_7 = PERF_TP_L1_CACHELINE_MISSES
          */
         return percent(cbSum(PERF_TP_L1_CACHELINE_MISSES), cbSum(PERF_TP_L1_CACHELINE_REQUESTS));
      }
   );
   counter("% Texture L2 Miss", Counter::Units::Percent, [=]() {
         /* Number of L2 texture cache misses divided by L2 texture cache requests. */
         /* Countables:
          * PERFCOUNTER_GROUP_UCHE::COUNTABLE_4 = PERF_UCHE_VBIF_READ_BEATS_TP
          * PERFCOUNTER_GROUP_UCHE::COUNTABLE_9 = PERF_UCHE_READ_REQUESTS_TP
          * Notes:
          *   - ratio has to be multiplied by two. Unsure how this constant comes up.
          */
         return percent(2 * PERF_UCHE_VBIF_READ_BEATS_TP, PERF_UCHE_READ_REQUESTS_TP);
      }
   );
   counter("% Vertex Fetch Stall", Counter::Units::Percent, [=]() {
         /* Percentage of clock cycles where the GPU cannot make any more requests for vertex data. */
         /* Countables:
          * PERFCOUNTER_GROUP_PC::COUNTABLE_2 = PERF_PC_STALL_CYCLES_VFD
          * PERFCOUNTER_GROUP_BV_PC::COUNTABLE_2 = PERF_PC_STALL_CYCLES_VFD
          * PERFCOUNTER_GROUP_RBBM::COUNTABLE_6 = PERF_RBBM_STATUS_MASKED
          */
         return percent(cbSum(PERF_PC_STALL_CYCLES_VFD), PERF_RBBM_STATUS_MASKED);
      }
   );
}

/**
 * Generate an submit the cmdstream to configure the counter/countable
 * muxing
 */
void
FreedrenoDriver::configure_counters(bool reset, bool wait)
{
   struct fd_submit *submit = fd_submit_new(pipe);
   enum fd_ringbuffer_flags flags =
      (enum fd_ringbuffer_flags)(FD_RINGBUFFER_PRIMARY | FD_RINGBUFFER_GROWABLE);
   struct fd_ringbuffer *ring = fd_submit_new_ringbuffer(submit, 0x1000, flags);

   for (const auto &countable : countables)
      countable.configure(ring, reset);

   struct fd_fence *fence = fd_submit_flush(submit, -1, false);

   fd_fence_flush(fence);
   fd_fence_del(fence);


penssl::ec::{EcPoint, EcGroup};
// //use openssl::ecdsa::EcdsaSig;
// use openssl::bn::{BigNum, BigNumRef, BigNumContext};

// use std::error::Error;
// // int ec_GFp_simple_set_compressed_coordinates(const EC_GROUP *group,
// //                                              EC_POINT *point,
// //                                              const BIGNUM *x_, int y_bit,
// //                                              BN_CTX *ctx)
// pub fn ec_GFp_simple_set_compressed_coordinates(grp: &EcGroup,
//                                                 point: &mut EcPoint,
//                                                 x_: BigNum,
//                                                 y_bit: bool,
//                                                 mut ctx: &mut BigNumContext)
//   -> Result<(), Box<dyn Error>>
// {
// //     BN_CTX *new_ctx = NULL;
// //     BIGNUM *tmp1, *tmp2, *x, *y;
// //     int ret = 0;

// // #ifndef FIPS_MODE
// //     /* clear error queue */
// //     ERR_clear_error();
// // #endif

// //     if (ctx == NULL) {
// //         ctx = new_ctx = BN_CTX_new_ex(group->libctx);
// //         if (ctx == NULL)
// //             return 0;
// //     }

// //     y_bit = (y_bit != 0);

// //     BN_CTX_start(ctx);
// //     tmp1 = BN_CTX_get(ctx);
// //     tmp2 = BN_CTX_get(ctx);
//   let mut tmp1 = BigNum::new()?;
//   let mut tmp2 = BigNum::new()?;
// //     x = BN_CTX_get(ctx);
// //     y = BN_CTX_get(ctx);
// let mut x = BigNum::new()?;
// let mut y = BigNum::new()?;
// //     if (y == NULL)
// //         goto err;

// //     /*-
// //      * Recover y.  We have a Weierstrass equation
// //      *     y^2 = x^3 + a*x + b,
// //      * so  y  is one of the square roots of  x^3 + a*x + b.
// //      */

// //     /* tmp1 := x^3 */
// //     if (!BN_nnmod(x, x_, group->field, ctx))
// //         goto err;
//   let xtmp = BigNum::new()?;
//   x.nnmod(&xtmp, &x_, &mut ctx)?;

//   tmp1.mod_sqr(x_, &grp.field(), &mut ctx)?;

// //     if (group->meth->field_decode == 0) {
// //         /* field_{sqr,mul} work on standard representation */
// //         if (!group->meth->field_sqr(group, tmp2, x_, ctx))
// //             goto err;
// //         if (!group->meth->field_mul(group, tmp1, tmp2, x_, ctx))
// //             goto err;
// //     } else {
// //         if (!BN_mod_sqr(tmp2, x_, group->field, ctx))
// //             goto err;
// //         if (!BN_mod_mul(tmp1, tmp2, x_, group->field, ctx))
// //             goto err;
// //     }

// //     /* tmp1 := tmp1 + a*x */
// //     if (group->a_is_minus3) {
// //         if (!BN_mod_lshift1_quick(tmp2, x, group->field))
// //             goto err;
// //         if (!BN_mod_add_quick(tmp2, tmp2, x, group->field))
// //             goto err;
// //         if (!BN_mod_sub_quick(tmp1, tmp1, tmp2, group->field))
// //             goto err;
// //     } else {
// //         if (group->meth->field_decode) {
// //             if (!group->meth->field_decode(group, tmp2, group->a, ctx))
// //                 goto err;
// //             if (!BN_mod_mul(tmp2, tmp2, x, group->field, ctx))
// //                 goto err;
// //         } else


{saptarshiRamayana.map((mantra)=>{
                        return(

{mantra.kannada}

                        )
                    })}

                    {saptarshiRamayana.map((mantra)=>{
                        return(

{mantra.english}

                        )
                    })}

    )
}

export default Saptarshi;
import React from 'react'

function EkaShlokiRamayanam() {
    const ekaShlokiRamayanam = [
        {
            kannada: `ಆದೌ ರಾಮ ತಪೋವನಾದಿಗಮನಂ ಹತ್ವಾ ಮೃಗಂ ಕಾಂಚನಂ
            ವೈದೇಹೀ ಹರಣಂ ಜಟಾಯು ಮರಣಂ ಸುಗ್ರೀವ ಸಂಭಾಷಣಮ್ |
            ವಾಲೀ ನಿಗ್ರಹಣಂ ಸಮುದ್ರತರಣಂ ಲಂಕಾಪುರೀದಾಹನಂ
            ಪಶ್ಚಾದ್ರಾವಣಕುಂಭಕರ್ಣಹನನಂ ಹ್ಯೇತದ್ಧಿ ರಾಮಾಯಣಮ್ ||`

        },
        {
            english: `Adou Rama tapovanadigamanaṁ hatvaa mṛgam kañchanam
            Vaidehi haraṇaṁ Jatayu maraṇaṁ Sugriva sambhashaṇam
            Vali nigrahaṇaṁ samudrataraṇaṁ Lankāpuri dahanaṁ
            Paschaad Raavana Kumbhakarna hananaṁ hyetaddhi Rāmāyaṇam`
        }
    ]
    return(

                    {ekaShlokiRamayanam.map((mantra)=>{
                        return(

{mantra.kannada}

                        )
                    })}

                    {ekaShlokiRamayanam.map((mantra)=>{
                        return(

{mantra.english}

                        )
                    })}

    )
}

export default EkaShlokiRamayanam;

import React from 'react'

function JayaMantra() {
    const jayaMantra = [
        {
            kannada: `ಜಯತ್ಯತಿಬಲೋ ರಾಮೋ ಲಕ್ಷ್ಮಣಶ್ಚ ಮಹಾಬಲಃ |
            ರಾಜಾ ಜಯತಿ ಸುಗ್ರೀವೋ ರಾಘವೇಣಾಭಿಪಾಲಿತಃ || ೧ ||

            ದಾಸೋಽಹಂ ಕೋಸಲೇಂದ್ರಸ್ಯ ರಾಮಸ್ಯ


<LetsDance>();
        Cast(id + 0x10, AID.ArcadyNightFever, 3.1f, 4.8f);
        ComponentCondition<GetDownAOE>(id + 0x12, 0.4f, g => g.NumCasts > 0, "Proteans start");
        ComponentCondition<GetDownRepeat>(id + 0x14, 20.1f, g => g.NumCasts >= 8, "Proteans end")
            .DeactivateOnExit<GetDownAOE>()
            .DeactivateOnExit<GetDownProtean>()
            .DeactivateOnExit<GetDownRepeat>();

        CastStart(id + 0x100, AID.LetsDance, 1.5f)
            .ActivateOnEnter<Wavelength>();
        CastEnd(id + 0x101, 5.8f);
        ComponentCondition<LetsDance>(id + 0x102, 1, f => f.NumCasts > 0, "Cleave 1");
        ComponentCondition<LetsDance>(id + 0x110, 17.15f, f => f.NumCasts >= 8, "Cleave 8");

        Cast(id + 0x200, AID.LetsPose1, 3.2f, 5, "Resolve")
            .DeactivateOnExit<LetsDance>()
            .DeactivateOnExit<Wavelength>();
    }

    private void RideTheWaves(uint id, float delay)
    {


et="_top">Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method

org.glyptodon.guacamole.net.auth.simple

Class SimpleUserDirectory

java.lang.Object

org.glyptodon.guacamole.net.auth.simple.SimpleDirectory<User>

org.glyptodon.guacamole.net.auth.simple.SimpleUserDirectory

All Implemented Interfaces:

Directory<User>

public class SimpleUserDirectory
extends SimpleDirectory<User>

An extremely simple


context.md#0x2_tx_context_TxContext">tx_context::TxContext): &vector<u8>

Implementation

public fun digest(self: &TxContext): &vector<u8> {
    &self.tx_hash
}

## Function `epoch`

Return the current epoch

public fun epoch(self: &tx_context::TxContext): u64

Implementation

public fun epoch(self: &TxContext): u64 {
    self.epoch
}

## Function `epoch_timestamp_ms`

Return the epoch start time as a unix timestamp in milliseconds.

public fun epoch_timestamp_ms(self: &tx_context::TxContext): u64

Implementation

public fun epoch_timestamp_ms(self: &TxContext): u64 {
   self.epoch_timestamp_ms
}

## Function `fresh_object_address`

Create an address that has not been used. As it is an object address, it will never
occur as the address for a user.
In other words, the generated address is a globally unique object ID.

public fun fresh_o


TestSetup, 1000, node))

	// Create a watchset so we can test that update node drain fires the watch
	ws := memdb.NewWatchSet()
	_, err := state.NodeByID(ws, node.ID)
	must.NoError(t, err)

	expectedDrain := &structs.DrainStrategy{
		DrainSpec: structs.DrainSpec{
			Deadline: -1 * time.Second,
		},
	}

	event := &structs.NodeEvent{
		Message:   "Drain strategy enabled",
		Subsystem: structs.NodeEventSubsystemDrain,
		Timestamp: time.Now(),
	}
	must.Nil(t, state.UpdateNodeDrain(structs.MsgTypeTestSetup, 1001, node.ID, expectedDrain, false, 7, event, nil, ""))
	must.True(t, watchFired(ws))

	ws = memdb.NewWatchSet()
	out, err := state.NodeByID(ws, node.ID)
	must.NoError(t, err)
	must.NotNil(t, out.DrainStrategy)
	must.NotNil(t, out.LastDrain)
	must.Eq(t, structs.DrainStatusDraining, out.LastDrain.Status)
	must.Eq(t, out.DrainStrategy, expectedDrain)
	must.Len(t, 2, out.Events)
	must.Eq(t, 1001, out.ModifyIndex)
	must.Eq(t, 7, out.StatusUpdatedAt)

	index, err := state.Index("nodes")
	must.NoError(t, err)
	must.Eq(t, 1001, index)
	must.False(t, watchFired(ws))
}

func TestStateStore_AddSingleNodeEvent(t *testing.T) {
	ci.Parallel(t)

	state := testStateStore(t)

	node := mock.Node()

	// We create a new node event every time we register a node
	err := state.UpsertNode(structs.MsgTypeTestSetup, 1000, node)
	must.NoError(t, err)

	must.Eq(t, 1, len(node.Events))
	must.Eq(t, structs.NodeEventSubsystemCluster, node.Events[0].Subsystem)
	must.Eq(t, NodeRegisterEventRegistered, node.Events[0].Message)

	// Create a watchset so we can test that AddNodeEvent fires the watch
	ws := memdb.NewWatchSet()
	_, err = state.NodeByID(ws, node.ID)
	must.NoError(t, err)

	nodeEvent := &structs.NodeEvent{
		Message:   "failed",
		Subsystem: "Driver",
		Timestamp: time.Now(),
	}
	nodeEvents := map[string][]*structs.NodeEvent{
		node.ID: {nodeEvent},
	}
	err = state.UpsertNodeEvents(structs.MsgTypeTestSetup, uint64(1001), nodeEvents)
	must.NoError(t, err)

	must.True(t, watchFired(ws))

	ws = memdb.NewWatchSet()
	out, err := state.NodeByID(ws, node.ID)
	must.NoError(t, err)

	must.Eq(t, 2, len(out.Events))
	must.Eq(t, nodeEvent, out.Events[1])
}

// To prevent stale node events from accumulating, we limit the number of
// stored node events to 10.
func TestStateStore_NodeEvents_RetentionWindow(t *testing.T) {
	ci.Parallel(t)

	state := testStateStore(t)

	node := mock.Node()

	err := state.UpsertNode(structs.MsgTypeTestSetup, 1000, node)
	must.NoError(t, err)
	must.Eq(t, 1, len(node.Events))
	must.Eq(t, structs.NodeEventSubsystemClus


1 12,5M12,6C11.59,6.62 11.25,7.29 11.04,8H12.96C12.75,7.29 12.42,6.62 12,6M10.7,6.22C9.78,6.53 9,7.17 8.54,8H10C10.18,7.38 10.4,6.78 10.7,6.22M13.29,6.22C13.59,6.78 13.82,7.38 14,8H15.46C15,7.17 14.21,6.54 13.29,6.22M8.13,9C8.05,9.32 8,9.65 8,10C8,10.35 8.05,10.68 8.13,11H9.82C9.78,10.67 9.75,10.34 9.75,10C9.75,9.66 9.78,9.33 9.82,9H8.13M10.83,9C10.78,9.32 10.75,9.66 10.75,10C10.75,10.34 10.78,10.67 10.83,11H13.17C13.21,10.67 13.25,10.34 13.25,10C13.25,9.66 13.21,9.32 13.17,9H10.83M14.18,9C14.22,9.33 14.25,9.66 14.25,10C14.25,10.34 14.22,10.67 14.18,11H15.87C15.95,10.68 16,10.35 16,10C16,9.65 15.95,9.32 15.87,9H14.18M8.54,12C9,12.83 9.78,13.46 10.7,13.78C10.4,13.22 10.18,12.63 10,12H8.54M11.04,12C11.25,12.72 11.59,13.38 12,14C12.42,13.38 12.75,12.72 12.96,12H11.04M14,12C13.82,12.63 13.59,13.22 13.29,13.78C14.21,13.46 15,12.83 15.46,12H14M7,17H17V19H7V17Z",
        MaterialIconKind.PassportAlert => "M10 6C9.59 6.62 9.25 7.29 9.04 8H10.96C10.75 7.29 10.42 6.62 10 6M8.7 6.22C7.78 6.53 7 7.17 6.54 8H8C8.18 7.38 8.4 6.78 8.7 6.22M11.29 6.22C11.59 6.78 11.82 7.38 12 8H13.46C13 7.17 12.21 6.54 11.29 6.22M6.13 9C6.05 9.32 6 9.65 6 10C6 10.35 6.05 10.68 6.13 11H7.82C7.78 10.67 7.75 10.34 7.75 10C7.75 9.66 7.78 9.33 7.82 9H6.13M8.83 9C8.78 9.32 8.75 9.66 8.75 10C8.75 10.34 8.78 10.67 8.83 11H11.17C11.21 10.67 11.25 10.34 11.25 10C11.25 9.66 11.21 9.32 11.17 9H8.83M12.18 9C12.22 9.33 12.25 9.66 12.25 10C12.25 10.34 12.22 10.67 12.18 11H13.87C13.95 10.68 14 10.35 14 10C14 9.65 13.95 9.32 13.87 9H12.18M6.54 12C7 12.83 7.78 13.46 8.7 13.78C8.4 13.22 8.18 12.63 8 12H6.54M9.04 12C9.25 12.72 9.59 13.38 10 14C10.42 13.38 10.75 12.72 10.96 12H9.04M12 12C11.82 12.


Tr;

    //注册数据库
    register<T>(ware_name: string, ware: T): boolean;

    //写数据库
    write(txhd: Handler, timeout?: number);

    //读数据库
    read(txhd: Handler, timeout?:number);
}

export interface Tr{
    //预提交
    prepare():void;

    //提交
    commit():void;

    //回滚
    rollback(): void;

    //查询
    query(arr: Item[], lock_time:number,read_lock:boolean):Item[];

    //修改
    modify(arr:Item[],lock_time:number,read_lock:boolean):void;

    //创建表
    alter(ware_name:string,tab_name:string,meta:TabMeta):void;

    //迭代器
    iter<K, V>(ware: string, tab: string, key: any, descending:boolean, _filter:string): Iterable<[K, V]>;

    //迭代器
    iter_raw?<K, V>(ware: string, tab: string, key: any, descending:boolean, _filter:string): Iterator<[K, V]>;
}

export interface Handler{
    (tr: Tr): any
}import {
    CollectionView, ArrayCollection, TemplateView, Model, property, Mixins,
    IViewTemplate, IViewElement, getValue, setValue, html
} from '../lib';
import { uniqueId, attributes, event, DelegateEvent } from 'view';

// It isn't really necessary to use a model in
// this implemnentation.
export class TodoModel extends Model {
    @property id: string = uniqueId();
    @property title: string;
    @property done: boolean = false

    constructor(title: string) {
        super()
        this.title = title;
    }
}

@attributes({
    tagName: 'li'
})
export class TodoListItemView extends TemplateView {
    template = (data: TodoModel) => {
        this.el!.setAttribute('data-id', data.id);
        const style = data.done ? 'line-through' : 'none';
        return `
            ${data.title}
            <button class="done">${data.done ? 'not done' : 'done'}</button>
        `
    }
    // FIXME: see https://github.com/kildevaeld/view.extras/issues/1
    data: TodoModel
}

export class BaseTodoListView extends CollectionView<TodoModel, TodoListItemView> { }

@attributes({
    ui: {
        input: 'input',
        btn: 'button.add-btn'
    }
})
export class TodoListView extends Mixins.ViewTemplate(Mixins.ViewElement(BaseTodoListView)) implements IViewTemplate, IViewElement {
    childView = TodoListItemView;
    collection: ArrayCollection<TodoModel> = new ArrayCollection();
    childViewContainer = "ul";

    template = _ => `

                <input type="text" />
                <button class="add-btn" disabled>New Todo</button>

`

    @event.click('@btn')
    onNewClicked() {
        this.collection.push(new TodoModel(getValue(this.ui.input) as string));
        setValue(this.ui.input, null);
        this.ui.btn.setAttribute('disabled', 'disabled');
        this.ui.input.focus();

    }

    @event('keyup', '@input')
    onInputKeyPress(e: KeyboardEvent) {
        if (e.keyCode === 13 && getValue(this.ui.input))
            return this.onNewClicked();
        if (getValue(this.ui.input))
            this.ui.btn.removeAttribute('disabled');
        else this.ui.btn.setAttribute('disabled', 'disabled');
    }

    @event.click('li button')
    onTodoItemClicked(e: DelegateEvent) {
        // This should be way more simple, when implementing: https://github.com/kildevaeld/view.extras/issues/1
        let id = e.delegateTarget.parentElement!.getAttribute('data-id');
        let model = this.c


gPainting));
    m_forceRepaintWhenResumingPainting = false;
}

void ChunkedUpdateDrawingAreaProxy::didSetSize(UpdateChunk* updateChunk)
{
    ASSERT(m_isWaitingForDidSetFrameNotification);
    m_isWaitingForDidSetFrameNotification = false;

    IntSize viewSize = updateChunk->rect().size();

    if (viewSize != m_size)
        sendSetSize();

    invalidateBackingStore();
    if (!updateChunk->isEmpty())
        drawUpdateChunkIntoBackingStore(updateChunk);
}

void ChunkedUpdateDrawingAreaProxy::deprecatedUpdate(UpdateChunk* updateChunk)
{
    if (!m_isVisible) {
        // We got an update request that must have been sent before we told the web process to suspend painting.
        // Don't paint this into the backing store, because that could leave the backing store in an inconsistent state.
        // Instead, we will just tell the drawing area to repaint everything when we resume painting.
        m_forceRepaintWhenResumingPainting = true;
    } else {
        // Just paint into backing store.
        drawUpdateChunkIntoBackingStore(updateChunk);
    }

    WebPageProxy* page = this->page();
    page->process()->deprecatedSend(DrawingAreaLegacyMessage::DidUpdate, page->pageID(), CoreIPC::In());
}

void ChunkedUpdateDrawingAreaProxy::sendSetSize()
{
    if (!m_webPageProxy->isValid())
        return;

    if (m_isWaitingForDidSetFrameNotification)
        return;
    m_isWaitingForDidSetFrameNotification = true;

    m_webPageProxy->process()->deprecatedSend(DrawingAreaLegacyMessage::SetSize, m_webPageProxy->pageID(), CoreIPC::In(m_size));
}

void ChunkedUpdateDrawingAreaProxy::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
{
    switch (messageID.get<DrawingAreaProxyLegacyMessage::Kind>()) {
        case DrawingAreaProxyLegacyMessage::Update: {
            UpdateChunk updateChunk;
            if (!arguments->decode(updateChunk))
                return;

            deprecatedUpdate(&updateChunk);
            break;
        }
        case DrawingAreaProxyLegacyMessage::DidSetSize: {
            UpdateChunk updateChunk;
            if (!arguments->decode(CoreIPC::Out(updateChunk)))
                return;

            didSetSize(&updateChunk);
            break;
        }
        default:
            ASSERT_NOT_REACHED();
    }
}

} // namespace WebKit
/*
 * Copyright (C) 2011 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "DrawingAreaProxyImpl.h"


lication{
	// 						{
	// 							PhysicalPath: to.Ptr("site\\wwwroot"),
	// 							PreloadEnabled: to.Ptr(false),
	// 							VirtualPath: to.Ptr("/"),
	// 					}},
	// 					VnetName: to.Ptr(""),
	// 					VnetPrivatePortsCount: to.Ptr[int32](0),
	// 					VnetRouteAllEnabled: to.Ptr(false),
	// 					WebSocketsEnabled: to.Ptr(false),
	// 				},
	// 				State: to.Ptr("Running"),
	// 				StorageAccountRequired: to.Ptr(false),
	// 				UsageState: to.Ptr(armappservice.UsageStateNormal),
	// 			},
	// 		}
}

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/82e9c6f9fbfa2d6d47d5e2a6a11c0ad2eb345c43/specification/web/resource-manager/Microsoft.Web/stable/2024-11-01/examples/CreateOrUpdateFunctionAppFlexConsumptionWithDetails.json
func ExampleWebAppsClient_BeginCreateOrUpdate_createOrUpdateFlexConsumptionFunctionAppWithDetails() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armappservice.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewWebAppsClient().BeginCreateOrUpdate(ctx, "testrg123", "sitef6141", armappservice.Site{
		Kind:     to.Ptr("functionapp,linux"),
		Location: to.Ptr("East US"),
		Properties: &armappservice.SiteProperties{
			FunctionAppConfig: &armappservice.FunctionAppConfig{
				Deployment: &armappservice.FunctionsDeployment{
					Storage: &armappservice.FunctionsDeploymentStorage{
						Type: to.Ptr(armappservice.FunctionsDeploymentStorageTypeBlobContainer),
						Authentication: &armappservice.FunctionsDeploymentStorageAuthentication{
							Type:                               to.Ptr(armappservice.AuthenticationTypeStorageAccountConnectionString),
							StorageAccountConnectionStringName: to.Ptr("TheAppSettingName"),
						},
						Value: to.Ptr("https://storageAccountName.blob.core.windows.net/containername"),
					},
				},
				Runtime: &armappservice.FunctionsRuntime{
					Name:    to.Ptr(armappservice.RuntimeNamePython),
					Version: to.Ptr("3.11"),
				},
				ScaleAndConcurrency: &armappservice.FunctionsScaleAndConcurrency{
					AlwaysReady: []*armappservice.FunctionsAlwaysReadyConfig{
						{
							Name:          to.Ptr("http"),
							InstanceCount: to.Ptr[int32](2),
						}},
					InstanceMemoryMB:     to.Ptr[int32](2048),
					MaximumInstanceCount: to.Ptr[int32](100),
					Triggers: &armappservice.FunctionsScaleAndConcurrencyTriggers{
						HTTP: &armappservice.FunctionsScaleAndConcurrencyTriggersHTTP{
							PerInstanceConcurrency: to.Ptr[int32](16),
						},
					},
				},
			},
			SiteConfig: &armappservice.SiteConfig{
				AppSettings: []*armappservice.NameValuePair{
					{
						Name:  to.


:!0,attrs:{class:"token number"}},[s._v("1")]),s._v(" user group "),t("span",{pre:!0,attrs:{class:"token number"}},[s._v("6586816")]),s._v(" Dec "),t("span",{pre:!0,attrs:{class:"token number"}},[s._v("24")]),s._v(" "),t("span",{pre:!0,attrs:{class:"token number"}},[s._v("12")]),s._v(":07 big.zip\n\n")])])]),t("p",[s._v("In this example, the total size of the contents is 6460KB.")]),s._v(" "),t("p",[s._v("Then there is an entry for each file/directory in alphabetical order with upper case before lower case.")]),s._v(" "),t("p",[s._v("The first character is the type (e.g. d - directory, l - link).")]),s._v(" "),t("p",[s._v("The next 9 characters show the permissions for the user, group and other.")]),s._v(" "),t("p",[s._v("This is followed by the number of hard links, then the owner's name and group.")]),s._v(" "),t("p",[s._v("The next field is the size in bytes.  This can be displayed in a human friendly form by adding the "),t("code",[s._v("-h")]),s._v(" option e.g. 6586816 is displayed as 6.3M")]),s._v(" "),t("p",[s._v("There then follows a timestamp (usually the modification time).")]),s._v(" "),t("p",[s._v("The final field is the name. Note: links also show the target of the link.")])])}),[],!1,null,null,null);e.default=r.exports}}]);(window.webpackJsonp=window.webpackJsonp||[]).push([[647],{1055:function(a,s,t){"use strict";t.r(s);var e=t(31),r=Object(e.a)({},(function(){var a=this,s=a.$createElement,t=a._self._c||s;return t("ContentSlotsDistributor",{attrs:{"slot-key":a.$parent.slotKey}},[t("h1",{attrs:{id:"digit-separators"}},[t("a",{staticClass:"header-anchor",attrs:{href:"#digit-separators"}},[a._v("#")]),a._v(" Digit separators")]),a._v(" "),t("h2",{attrs:{id:"digit-separator"}},[t("a",{staticClass:"header-anchor",attrs:{href:"#digit-separator"}},[a._v("#")]),a._v(" Digit Separator")]),a._v(" "),t("p",[a._v("Numeric literals of more than a few digits are hard to read.")]),a._v(" "),t("ul",[t("li",[a._v("Pronounce 7237498123.")]),a._v(" "),t("li",[a._v("Compare 237498123 with 237499123 for equality.")]),a._v(" "),t("li",[a._v("Decide whether 237499123 or 20249472 is larger.")])]),a._v(" "),t("p",[t("code",[a._v("C++14")]),a._v(" define Simple Quotation Mark "),t("code",[a._v("'")]),a._v(" as a digit separator, in numbers and user-defined literals. This can make it easier for human readers to parse large numbers.")]),a._v(" "),t("div",{staticClass:"language-cpp extra-class"},[t("pre",{pre:!0,attrs:{class:"language-cpp"}},[t("code",[t("span",{pre:!


= fullOrigHeight.toFloat(), clipOp = ClipOp.Intersect)
            }) {
                innerPaint(this)
            }
        }
    }
}

package org.pushingpixels.aurora.demo.svg.tango

import androidx.compose.ui.geometry.*
import androidx.compose.ui.graphics.*
import androidx.compose.ui.graphics.drawscope.DrawScope
import androidx.compose.ui.graphics.drawscope.Fill
import androidx.compose.ui.graphics.drawscope.Stroke
import androidx.compose.ui.graphics.drawscope.clipRect
import androidx.compose.ui.graphics.drawscope.translate
import androidx.compose.ui.graphics.drawscope.withTransform
import androidx.compose.ui.graphics.painter.Painter
import java.lang.ref.WeakReference
import java.util.*
import kotlin.math.min

/**
 * This class has been automatically generated using
 * Aurora SVG transcoder.
 */
class applications_multimedia : Painter() {
    @Suppress("UNUSED_VARIABLE") private var shape: Outline? = null
    @Suppress("UNUSED_VARIABLE") private var generalPath: Path? = null
    @Suppress("UNUSED_VARIABLE") private var brush: Brush? = null
    @Suppress("UNUSED_VARIABLE") private var stroke: Stroke? = null
    @Suppress("UNUSED_VARIABLE") private var clip: Shape? = null
    private var alpha = 1.0f
    private var blendMode = DrawScope.DefaultBlendMode
    private var alphaStack = mutableListOf(1.0f)
    private var blendModeStack = mutableListOf(DrawScope.DefaultBlendMode)

	@Suppress("UNUSED_VARIABLE", "UNUSED_VALUE", "VARIABLE_WITH_REDUNDANT_INITIALIZER", "UNNECESSARY_NOT_NULL_ASSERTION")
private fun _paint0(drawScope : DrawScope) {
var shapeText: Outline?
var generalPathText: Path? = null
var alphaText = 0.0f
var blendModeText = DrawScope.DefaultBlendMode
with(drawScope) {
//
alphaStack.add(0, alpha)
alpha *= 1.0f
blendModeStack.add(0, BlendMode.SrcOver)
blendMode = BlendMode.SrcOver
// _0
alphaStack.add(0, alpha)
alpha *= 1.0f
blendModeStack.add(0, BlendMode.SrcOver)
blendMode = BlendMode.SrcOver
// _0_0
alphaStack.add(0, alpha)
alpha *= 0.74372f
blendModeStack.add(0, BlendMode.SrcOver)
blendMode = BlendMode.SrcOver
withTransform({
transform(
Matrix(values=floatArrayOf(
1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, -0.8571400046348572f, 0.0f, 1.0f)
))}){
// _0_0_0
if (generalPath == null) {
   generalPath = Path()
} else {
   generalPath!!.reset()
}
generalPath?.run {
    moveTo(46.714f, 44.286f)
    cubicTo(46.74937f, 45.92411f, 42.55032f, 47.440933f, 35.706844f, 48.26211f)
    cubicTo(28.863367f, 49.083286f, 20.421633f, 49.083286f, 13.578157f, 48.26211f)
    cubicTo(6.734681f, 47.440933f, 2.5356293f, 45.92411f, 2.5709991f, 44.286f)
    cubicTo(2.5356293f, 42.64789f, 6.734681f, 41.131065f, 13.578157f, 40.309887f)
    cubicTo(20.421633f, 39.488712f, 28.863367f, 39.488712f, 35.706844f, 40.309887f)
    cubicTo(42.55032f, 41.131065f, 46.74937f, 42.64789f, 46.714f, 44.286f)
    close()
}
shape = Outline.Generic(generalPath!!)
brush = Brush.radialGradient(0.0f to Color


 FROM GenericBookmarkWithNotes
    JOIN GenericBookmarkToLabel ON GenericBookmarkWithNotes.id = GenericBookmarkToLabel.bookmarkId
    JOIN Label ON GenericBookmarkToLabel.labelId = Label.id
    WHERE Label.id = :labelId
"""

@Dao
interface BookmarkDao {
    @Query("SELECT * from BibleBookmarkWithNotes WHERE $search ORDER BY $orderBy")
    fun searchAllBookmarksImpl(orderBy: String, search:String): List<BibleBookmarkWithNotes>

    fun searchAllBookmarks(orderBy: String, search:String): List<BibleBookmarkWithNotes> =
        searchAllBookmarksImpl(orderBy, "%$search%")

    @Query("SELECT * from GenericBookmarkWithNotes WHERE $search ORDER BY $genericOrderBy")
    fun searchAllGenericBookmarksImpl(search:String): List<GenericBookmarkWithNotes>
    fun searchAllGenericBookmarks(search:String): List<GenericBookmarkWithNotes>
        = searchAllGenericBookmarksImpl("%$search%")

    fun searchAllBookmarks(orderBy: BookmarkSortOrder = BookmarkSortOrder.BIBLE_ORDER, search:String): List<BibleBookmarkWithNotes> =
        searchAllBookmarks(orderBy.name, search)

    @Query("SELECT * from BibleBookmarkWithNotes ORDER BY $orderBy")
    fun allBookmarks(orderBy: String): List<BibleBookmarkWithNotes>

    @Query("SELECT * from GenericBookmarkWithNotes ORDER BY $genericOrderBy")
    fun allGenericBookmarks(): List<GenericBookmarkWithNotes>

    fun allBookmarks(orderBy: BookmarkSortOrder = BookmarkSortOrder.BIBLE_ORDER): List<BibleBookmarkWithNotes> =
        allBookmarks(orderBy.name)

    @Query("SELECT * from BibleBookmarkWithNotes WHERE notes IS NOT NULL ORDER BY $orderBy")
    fun allBookmarksWithNotes(orderBy: String): List<BibleBookmarkWithNotes>
    fun allBookmarksWithNotes(orderBy: BookmarkSortOrder): List<BibleBookmarkWithNotes> =
        allBookmarksWithNotes(orderBy.name)

    @Query("SELECT * from BibleBookmarkWithNotes where id = :bookmarkId")
    fun bibleBookmarkById(bookmarkId: IdType): BibleBookmarkWithNotes?

    @Query("SELECT * from GenericBookmarkWithNotes where id = :bookmarkId")
    fun genericBookmarkById(bookmarkId: IdType): GenericBookmarkWithNotes?

    @Query("SELECT * from BibleBookmarkWithNotes where id IN (:bookmarkIds)")
    fun bibleBookmarksByIds(bookmarkIds: List<IdType>): List<BibleBookmarkWithNotes>

    @Query("SELECT * from GenericBookmarkWithNotes where id IN (:bookmarkIds)")
    fun genericBookmarksByIds(bookmarkIds: List<IdType>): List<GenericBookmarkWithNotes>

    //https://stackoverflow.com/questions/325933/determine-whether-two-date-ranges-overlap
    @Query(
        """SELECT * from BibleBookmarkWithNotes where
        kjvOrdinalStart <= :rangeEnd AND :rangeStart <= kjvOrdinalEnd
        ORDER BY kjvOrdinalStart, startOffset
        """
    )
    fun bookmarksForKjvOrdinalRange(rangeStart: Int, rangeEnd: Int): List<BibleBookmarkWithNotes>
    fun bookmarksForVerseRange(verseRange: VerseRange): List<BibleBookmarkWithNotes> {
        val v = verseRange.toV11n(KJVA)
        return bookmarksForKjvOrdinalRange(v.start.ordinal, v.end.ordinal)
    }
    fun bookmarksInBook(book: BibleBook): List<BibleBookmarkWithNotes> = bookmarksForVerseRange(KJVA.allVerses)

    @Query("SELECT * from BibleBookmarkWithNotes where kjvOrdinalStart <= :verseId AND :verseId <= kjvOrdinalEnd")
    fun bookmarksForKjvOrdinal(verseId: Int): List<BibleBookmarkWithNotes>
    fun bookmarksForVerse(verse: Verse): List<BibleBookmarkWithNotes> =
        book


C40 00454180  80 03 1B 40 */	lwz r0, 0x1b40(r3)
/* 80458C44 00454184  2C 00 00 06 */	cmpwi r0, 6
/* 80458C48 00454188  41 82 00 14 */	beq lbl_80458C5C
/* 80458C4C 0045418C  40 80 00 3C */	bge lbl_80458C88
/* 80458C50 00454190  2C 00 00 00 */	cmpwi r0, 0
/* 80458C54 00454194  41 82 00 08 */	beq lbl_80458C5C
/* 80458C58 00454198  48 00 00 30 */	b lbl_80458C88
lbl_80458C5C:
/* 80458C5C 0045419C  48 04 F4 8D */	bl OSDisableInterrupts
/* 80458C60 004541A0  7C 7B 1B 78 */	mr r27, r3
/* 80458C64 004541A4  38 60 00 00 */	li r3, 0
/* 80458C68 004541A8  4B FF E0 7D */	bl func_80456CE4
/* 80458C6C 004541AC  3B C0 00 05 */	li r30, 5
/* 80458C70 004541B0  4B FF E0 81 */	bl func_80456CF0
/* 80458C74 004541B4  93 C3 1B 40 */	stw r30, 0x1b40(r3)
/* 80458C78 004541B8  4B FF E0 79 */	bl func_80456CF0
/* 80458C7C 004541BC  93 A3 1B 48 */	stw r29, 0x1b48(r3)
/* 80458C80 004541C0  7F 63 DB 78 */	mr r3, r27
/* 80458C84 004541C4  48 04 F4 8D */	bl OSRestoreInterrupts
lbl_80458C88:
/* 80458C88 004541C8  4B FF E0 71 */	bl func_80456CF8
/* 80458C8C 004541CC  39 61 00 30 */	addi r11, r1, 0x30
/* 80458C90 004541D0  48 0B E8 E5 */	bl func_80517574
/* 80458C94 004541D4  80 01 00 34 */	lwz r0, 0x34(r1)
/* 80458C98 004541D8  7C 08 03 A6 */	mtlr r0
/* 80458C9C 004541DC  38 21 00 30 */	addi r1, r1, 0x30
/* 80458CA0 004541E0  4E 80 00 20 */	blr
lbl_80458CA4:
/* 80458CA4 004541E4  94 21 FF E0 */	stwu r1, -0x20(r1)
/* 80458CA8 004541E8  7C 08 02 A6 */	mflr r0
/* 80458CAC 004541EC  90 01 00 24 */	stw r0, 0x24(r1)
/* 80458CB0 004541F0  39 61 00 20 */	addi r11, r1, 0x20
/* 80458CB4 004541F4  48 0B E8 7D */	bl _savegpr_27
/* 80458CB8 004541F8  7C 7B 1B 78 */	mr r27, r3
/* 80458CBC 004541FC  7C 83 23 78 */	mr r3, r4
/* 80458CC0 00454200  48 07 3C 71 */	bl func_804CC930
/* 80458CC4 00454204  80 63 00 04 */	lwz r3, 4(r3)
/* 80458CC8 00454208  4B FF E0 E1 */	bl func_80456DA8
/* 80458CCC 0045420C  2C 9B 00 00 */	cmpwi cr1, r27, 0
/* 80458CD0 00454210  7C 7D 1B 78 */	mr r29,


, iv_vec, plaintext, bs)
            }
            SymmetricKeyAlgorithm::AES128 => encrypt_regular!(Aes128, key, iv_vec, plaintext, bs),
            SymmetricKeyAlgorithm::AES192 => encrypt_regular!(Aes192, key, iv_vec, plaintext, bs),
            SymmetricKeyAlgorithm::AES256 => encrypt_regular!(Aes256, key, iv_vec, plaintext, bs),
            SymmetricKeyAlgorithm::Twofish => encrypt_regular!(Twofish, key, iv_vec, plaintext, bs),
            SymmetricKeyAlgorithm::Camellia128 => {
                unimplemented_err!("Camellia 128 not yet available")
            }
            SymmetricKeyAlgorithm::Camellia192 => {
                unimplemented_err!("Camellia 192 not yet available")
            }
            SymmetricKeyAlgorithm::Camellia256 => {
                unimplemented_err!("Camellia 256 not yet available")
            }
            SymmetricKeyAlgorithm::Private10 => {
                unimplemented_err!("Private10 should not be used, and only exist for compatability")
            }
        }
        Ok(())
    }

    /// Generate a new session key.
    pub fn new_session_key<R: Rng + CryptoRng>(self, rng: &mut R) -> Vec<u8> {
        let mut session_key = vec![0u8; self.key_size()];
        rng.fill_bytes(&mut session_key);
        session_key
    }
}

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

    use rand::{Rng, SeedableRng};
    use rand_xorshift::XorShiftRng;

    macro_rules! roundtrip {
        ($name:ident, $alg:path) => {
            #[test]
            fn $name() {
                let rng = &mut XorShiftRng::from_seed([
                    0x3, 0x8, 0x3, 0xe, 0x3, 0x8, 0x3, 0xe, 0x3, 0x8, 0x3, 0xe, 0x3, 0x8, 0x3, 0xe,
                ]);

                // Protected
                for i in 1..1024 {
                    let data = (0..i).map(|_| rng.gen()).collect::<Vec<_>>();
                    let key = (0..$alg.key_size()).map(|_| rng.gen()).collect::<Vec<_>>();

                    let mut ciphertext = $alg.encrypt_protected(&key, &data).unwrap();
                    assert_ne!(data, ciphertext);

                    let plaintext = $alg.decrypt_protected(&key, &mut ciphertext).unwrap();
                    assert_eq!(data, plaintext);
                }

                // Unprotected
                // resync is not implemented yet
                // {
                //     let data = vec![2u8; 256];
                //     let key = vec![1u8; $alg.key_size()];

                //     let mut ciphertext = $alg.encrypt(&key, &data).unwrap();
                //     assert_ne!(data, ciphertext);

                //     let plaintext = $alg.decrypt(&key, &mut ciphertext).unwrap();
                //     assert_eq!(data, plaintext);
                // }
            }
        };
    }

    roundtrip!(roundtrip_aes128, SymmetricKeyAlgorithm::AES128);
    roundtrip!(roundtrip_aes192, SymmetricKeyAlgorithm::AES192);
    roundtrip!(roundtrip_aes256, SymmetricKeyAlgorithm::AES256);
    roundtrip!(roundtrip_tripledes, SymmetricKeyAlgorithm::TripleDES);
    roundtrip!(roundtrip_blowfish, Symmetric


Docker 存储

                    Docker应用程序数据

                    调整dokcer容器可用磁盘空间

                    Docker开发指南（学习和实践）

                    容器技术简介

                    安装Docker

                    Docker快速起步

                    Docker启动容器报错"error response from daemon: secret store is not initialized"

                    使用Docker快速部署不同版本CentOS容器

                    Docker容器启动时启动服务

                    操作系统重启时自动启动Docker容器


Results(bool live) {
    showUnelectedParties = !live;
    _liveResults = live;
  }

  bool get liveResults => this._liveResults;

  Iterable<PartyColor> get displayParties {
    if (showUnelectedParties) {
      return parties;
    }
    return parties.where((pc) => pc.p.seatsInNation > 0);
  }

  @Input()
  set partyMap(Map<String, Party> partyMap) {
    parties = new List<PartyColor>();
    if (parties == null) {
      return;
    }
    try {
      List<String> keys = new List.from(partyMap.keys);
      keys.sort((a, b) {
        var ap = partyMap[a];
        var bp = partyMap[b];
        num c = bp.seatsInNation.compareTo(ap.seatsInNation);
        if (c != 0) {
          return c;
        }
        return ap.name.compareTo(bp.name);
      });
      for (var key in keys) {
        var p = partyMap[key];
        if (!p.active) {
          continue;
        }
        parties.add(new PartyColor(p, getColorForParty(p, partyMap)));
      }
    } catch (exception, stacktrace) {
      print("Couldn't parse parties: $exception");
      print(stacktrace);
    }
  }

  toggleUnelected() => showUnelectedParties = !showUnelectedParties;

  String getColorForParty(Party p, Map<String, Party> allParties) {
    if (p.seatsInNation >= 3) {
      return p.color;
    }
    if (PartyAlignment.relatedPartiesHaveMoreThan3SeatsTotal(
        p.id, allParties)) {
      return p.color;
    }
    // Default
    return "#bdbdbd";
  }

  String get moreOrLess =>
      showUnelectedParties ? messages.show_less() : messages.show_more();

  PartyListComponent(this.messages) {}
}

class PartyColor {
  PartyColor(this.p, this.color);
  final Party p;
  final String color;
}
/*
 * Copyright 2016 Google Inc. All rights reserved.
 *
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
 * file except in compliance with the License. You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
 * ANY KIND, either express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */

import 'dart:html';
import 'package:angular2/core.dart';
import 'package:google_maps/google_maps_geometry.dart';
import '../i18n/messages.dart';
import '../map/map_utils.dart' as mapUtils;
import '../services/election_firebase_service.dart';
import '../services/electorate_spatial_service.dart';
import '../services/page_state_service.dart';
import '../services/place_tooltip_service.dart';
import 'polling_place_details_component.dart';

@Component(
    selector: 'pollingplaceslist',
    templateUrl: 'polling_places_list_component.html',
    directives: const [PollingPlaceDetailsComponent])
class PollingPlacesListComponent {
  @Input()
  Electorate electorate;

  List<PollingPlaceMarker> _pollingPlaces;
  List<PollingPlaceMarker> _clippedPollingPlaces;

  final Messages _messages;
  final PlaceTooltipService _placeTooltipService;
  final PageStateService _pageStateService;

  static const _collapsedLength = 10;

  @Input()
  Election election;

  bool navigateOnClick;

  @Input()
  set pollingPlaces(List<PollingPlaceMarker> places) {
    _pollingPlaces = places;
    if


 => _B,
  c: (c: _B) => _C,
  d: (d: _C) => _D,
  e: (e: _D) => _E,
  f: (f: _E) => _F,
  g: (g: _F) => _G,
  h: (h: _G) => _H,
  i: (i: _H) => _I,
  j: (j: _I) => _J,
  k: (k: _J) => _K,
  l: (l: _K) => R,
): R
export function pipeValue<V, R, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L>(
  value: V,
  a: (a: V) => _A,
  b: (b: _A) => _B,
  c: (c: _B) => _C,
  d: (d: _C) => _D,
  e: (e: _D) => _E,
  f: (f: _E) => _F,
  g: (g: _F) => _G,
  h: (h: _G) => _H,
  i: (i: _H) => _I,
  j: (j: _I) => _J,
  k: (k: _J) => _K,
  l: (l: _K) => _L,
  m: (m: _L) => R,
): R
export function pipeValue<
  V,
  R,
  _A,
  _B,
  _C,
  _D,
  _E,
  _F,
  _G,
  _H,
  _I,
  _J,
  _K,
  _L,
  _M
>(
  value: V,
  a: (a: V) => _A,
  b: (b: _A) => _B,
  c: (c: _B) => _C,
  d: (d: _C) => _D,
  e: (e: _D) => _E,
  f: (f: _E) => _F,
  g: (g: _F) => _G,
  h: (h: _G) => _H,
  i: (i: _H) => _I,
  j: (j: _I) => _J,
  k: (k: _J) => _K,
  l: (l: _K) => _L,
  m: (m: _L) => _M,
  n: (n: _M) => R,
): R
export function pipeValue<
  V,
  R,
  _A,
  _B,
  _C,
  _D,
  _E,
  _F,
  _G,
  _H,
  _I,
  _J,
  _K,
  _L,
  _M,
  _N
>(
  value: V,
  a: (a: V) => _A,
  b: (b: _A) => _B,
  c: (c: _B) => _C,
  d: (d: _C) => _D,
  e: (e: _D) => _E,
  f: (f: _E) => _F,
  g: (g: _F) => _G,
  h: (h: _G) => _H,
  i: (i: _H) => _I,
  j: (j: _I) => _J,
  k: (k: _J) => _K,
  l: (l: _K) => _L,
  m: (m: _L) => _M,
  n: (n: _M) => _N,
  o: (o: _N) => R,
): R
export function pipeValue<
  V,
  R,
  _A,
  _B,
  _C,
  _D,
  _E,
  _F,
  _G,
  _H,
  _I,
  _J,


3FAA4E = 0x00DB0BC05E3FAA4E, //
			_0x0C392DB374655176 = 0x0C392DB374655176, //
			_0xC687A23E166DCF68 = 0xC687A23E166DCF68, //
			_0x002BABE0B7D53136 = 0x002BABE0B7D53136, //
			_0x26934083D3F2579C = 0x26934083D3F2579C, //
			_0x532C5FDDB986EE5C = 0x532C5FDDB986EE5C, //
			_0xB527099D1E1EED49 = 0xB527099D1E1EED49, //
			_0xBCC6DC59E32A2BDC = 0xBCC6DC59E32A2BDC, //
			_0xE0FA74AA3CCE650B = 0xE0FA74AA3CCE650B, //
			_0x73BAD7B2F2DB50DE = 0x73BAD7B2F2DB50DE, //
			_0xD6C0A8C7C0B2F82C = 0xD6C0A8C7C0B2F82C, //
			_0xFEC85339AACA2A35 = 0xFEC85339AACA2A35, //
			_0x7EF2A2FE38D74456 = 0x7EF2A2FE38D74456, //
			_0xC7DC5A0A7DF608CB = 0xC7DC5A0A7DF608CB, //
			_0xDE5FAA741A781F73 = 0xDE5FAA741A781F73, //
			_0x362086B911657B1A = 0x362086B911657B1A, //
			_CREATE_GUARD_ZONE = 0x8F9DE75680275C9F, //
			_REMOVE_GUARD_ZONE = 0x67EBDD958835956C, //
			_0x9772395CC73E8D1F = 0x9772395CC73E8D1F, //
			_DISABLE_GUARD_ZONE = 0x26D558692B25DD95, //
			_0x0DBACA9C38C9A686 = 0x0DBACA9C38C9A686, //
			_0xD743C4293F47AFAD = 0xD743C4293F47AFAD, //
			_0x8C598A930F471938 = 0x8C598A930F471938, //
			_0x35815F372D43E1E5 = 0x35815F372D43E1E5, //
			_0xA1B0E6301E2E02A6 = 0xA1B0E6301E2E02A6, //
			_0xAD3E07C37A7C1ADC = 0xAD3E07C37A7C1ADC, //
			_0xA8A74AA79FB67159 = 0xA8A74AA79FB67159, //
			_SET_GUARD_ZONE_POSITION = 0x7E7BF59F89FC6C6D, //
			_SET_GUARD_ZONE_POSITION_2 = 0x2F9005E2EA4E5EE4, //
			/*
				LOCALIZATION
			*/
			_LOCALIZATION_GET_SYSTEM_LANGUAGE = 0x3C1A05F86AE6ACB5, //
			GET_CURRENT_LANGUAGE = 0xDB917DA5C6835FCC, //
			_0x45D50415E4D885FF = 0x45D50415E4D885FF, //
			_LOCALIZATION_GET_USER_LANGUAGE = 0x76E30B799EBEEA0F,


00000100000000000010000000000010000
    )

    # Batch Test 2: cur_t: 172
    v0 = 1225051666414313504
    v1 = 1157429502285062340
    v2 = 9223381383253332224

    m, _ = len3_mask(to_bitsequence_64([v0, v1, v2]))

    assert int(m, 2) == 4432414638080

    print_mask64(int(m, 2))
    print_mask64(1134696008253440)

    # app input 2: cur_t: 0
    # note: highest mask bit must be set in this case
    print("app input 2")
    v0 = 15995499993133274059
    v1 = 17575218449657001922
    v2 = 13172742451556175867

    m, consumed_bits = len3_mask(to_bitsequence_64([v0, v1, v2]))

    print(int(m, 2))
    print(consumed_bits)

    print_mask64(int(m, 2))
    print_mask64(8933997687287561919)

    # Generate additional test data for C++ test
    import random

    random.seed(0)

    for i in range(0, 5):
        v0 = random.randint(0, 2**64 - 1)
        v1 = random.randint(0, 2**64 - 1)
        v2 = random.randint(0, 2**64 - 1)

        m, _ = len3_mask(to_bitsequence_64([v0, v1, v2]))
        print(f"// random values test {i}")
        print(f"v0={v0}lu;")
        print(f"v1={v1}lu;")
        print(f"v2={v2}lu;")
        print(f"len3_mask_expected = {int(m,2)}lu;")
        print(
            f"""\
len3_mask = get_len3_mask(v0,v1,v2);
std::cout << len3_mask << std::endl;

if ( len3_mask != len3_mask_expected ) {{
  std::cout << "random values test {i}: FAIL" << std::endl;
}}
"""
        )


// select end
			vec4 clip = ( position.y < 0.5 ) ? clipStart : clipEnd;

			// back to clip space
			offset *= clip.w;

			clip.xy += offset;

			gl_Position = clip;

			vec4 mvPosition = ( position.y < 0.5 ) ? start : end; // this is an approximation

			#include <logdepthbuf_vertex>
			#include <clipping_planes_vertex>
			#include <fog_vertex>

		}`,

	fragmentShader: /* glsl */`
		uniform vec3 diffuse;
		uniform float opacity;

		#ifdef USE_DASH

			uniform float dashSize;
			uniform float dashOffset;
			uniform float gapSize;

		#endif

		varying float vLineDistance;

		#include <common>
		#include <color_pars_fragment>
		#include <fog_pars_fragment>
		#include <logdepthbuf_pars_fragment>
		#include <clipping_planes_pars_fragment>

		varying vec2 vUv;

		void main() {

			#include <clipping_planes_fragment>

			#ifdef USE_DASH

				if ( vUv.y < - 1.0 || vUv.y > 1.0 ) discard; // discard endcaps

				if ( mod( vLineDistance + dashOffset, dashSize + gapSize ) > dashSize ) discard; // todo - FIX

			#endif

			float alpha = 1.0;

			#ifdef ALPHA_TO_COVERAGE

			// artifacts appear on some hardware if a derivative is taken within a conditional
			float a = vUv.x;
			float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0;
			float len2 = a * a + b * b;
			float dlen = fwidth( len2 );

			if ( abs( vUv.y ) > 1.0 ) {

				alpha = 1.0 - smoothstep( 1.0 - dlen, 1.0 + dlen, len2 );

			}

			#else

			if ( abs( vUv.y ) > 1.0 ) {

				float a = vUv.x;
				float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0;
				float len2 = a * a + b * b;

				if ( len2 > 1.0 ) discard;

			}

			#endif

			vec4 diffuseColor = vec4( diffuse, opacity * alpha );

			#include <logdepthbuf_fragment>
			#include <color_fragment>

			gl_FragColor = diffuseColor;

			#include <tonemapping_fragment>
			#include <encodings_fragment>
			#include <fog_fragment>
			#include <premultiplied_alpha_fragment>

		}`

};

class LineMaterial extends ShaderMaterial {

	constructor( parameters ) {

		super( {

			type: 'LineMaterial',

			uniforms: UniformsUtils.clone( ShaderLib[ 'line' ].uniforms ),

			vertexShader: ShaderLib[ 'line' ].vertexShader,
			fragmentShader: ShaderLib[ 'line' ].fragmentShader,

			clipping: true // required for clipping support

		} );

		Object.defineProperties( this, {

			color: {

				enumerable: true,

				get: function () {

					return this.uniforms.diffuse.value;

				},

				set: function ( value ) {

					this.uniforms.diffuse.value = value;

				}

			},

			linewidth: {

				enumerable: true,

				get: function () {

					return this.uniforms.linewidth.value;

				},

				set: function ( value ) {

					this.uniforms.linewidth.value = value;

				}

			},

			dashed: {

				enumerable: true,

				get: function () {

					return Boolean( 'USE_DASH' in this.defines );

				},

				set( value ) {

					if ( Boolean( value ) !== Boolean( 'USE_DASH' in this.defines ) ) {


e error list will be suppressed. Otherwise, all suppressable entries in the error list will be suppressed.</param>
    /// <param name="suppressInSource">If true, then suppressions will be generated inline in the source file. Otherwise, they will be generated in a separate global suppressions file.</param>
    /// <param name="projectHierarchy">An optional project hierarchy object in the solution explorer. If non-null, then only the diagnostics from the project will be suppressed.</param>
    bool AddSuppressions(bool selectedErrorListEntriesOnly, bool suppressInSource, IVsHierarchy? projectHierarchy);

    /// <summary>
    /// Removes source suppressions for suppressed diagnostics.
    /// </summary>
    /// <param name="selectedErrorListEntriesOnly">If true, then only the currently selected entries in the error list will be unsuppressed. Otherwise, all unsuppressable entries in the error list will be unsuppressed.</param>
    /// <param name="projectHierarchy">An optional project hierarchy object in the solution explorer. If non-null, then only the diagnostics from the project will be unsuppressed.</param>
    bool RemoveSuppressions(bool selectedErrorListEntriesOnly, IVsHierarchy? projectHierarchy);
}


zA-Z0-9_]+';
/**
 * Regular expression for extracting rule data.
 */
const ruleExtractor = new RegExp(`^(${hintPattern}?${rulePattern})(?:\\:(.*)+)?$`, 'i');
/**
 * Validation hints are special characters preceding a validation rule, like
 * !phone
 */
const hintExtractor = new RegExp(`^(${hintPattern})(${rulePattern})$`, 'i');
/**
 * Given a hint string like ^(200)? or ^? or (200)?^ extract the hints to
 * matches.
 */
const debounceExtractor = /([\*+?]+)?(\(\d+\))([\*+?]+)?/;
/**
 * Determines if a given string is in the proper debounce format.
 */
const hasDebounce = /\(\d+\)/;
/**
 * The default values of the available validation hints.
 */
const defaultHints = {
    blocking: true,
    debounce: 0,
    force: false,
    skipEmpty: true,
    name: '',
};
/**
 * Parse validation intents and strings into validation rule stacks.
 * @param validation - Either a string a validation rules, or proper array of structured rules.
 * @internal
 */
function parseRules(validation, rules) {
    if (!validation)
        return [];
    const intents = typeof validation === 'string'
        ? extractRules(validation)
        : (0,_formkit_utils__WEBPACK_IMPORTED_MODULE_2__.clone)(validation);
    return intents.reduce((validations, args) => {
        let rule = args.shift();
        const hints = {};
        if (typeof rule === 'string') {
            const [ruleName, parsedHints] = parseHints(rule);
            if ((0,_formkit_utils__WEBPACK_IMPORTED_MODULE_2__.has)(rules, ruleName)) {
                rule = rules[ruleName];
                Object.assign(hints, parsedHints);
            }
        }
        if (typeof rule === 'function') {
            validations.push({
                rule,
                args,
                timer: 0,
                state: null,
                queued: true,
                deps: new Map(),
                ...defaultHints,
                ...fnHints(hints, rule),
            });
        }
        return validations;
    }, []);
}
/**
 * A string of validation rules written in FormKitRule notation.
 * @param validation - The string of rules
 * @internal
 */
function extractRules(validation) {
    return validation.split('|').reduce((rules, rule) => {
        const parsedRule = parseRule(rule);
        if (parsedRule) {
            rules.push(parsedRule);
        }
        return rules;
    }, []);
}
/**
 * Given a rule like confirm:password_confirm produce a FormKitValidationIntent
 * @param rule - A string representing a validation rule.
 * @returns
 */
function parseRule(rule) {
    const trimmed = rule.trim();
    if (trimmed) {
        const matches = trimmed.match(ruleExtractor);
        if (matches && typeof matches[1] === 'string') {
            const ruleName = matches[1].trim();
            const args = matches[2] && typeof matches[2] === 'string'
                ? matches[2].split(',').map((s) => s.trim())
                : [];
            return [ruleName, ...args];
        }
    }
    return false;
}
/**
 * Given a rule name, detect if there are any additional hints like !
 * @param ruleName - string representing a rule name
 * @returns
 */
function parseHints(ruleName) {
    const matches = ruleName.match(hintExtractor);
    if (!matches) {
        return [ruleName, { name: ruleName }];
    }
    const map = {
        '*': { force: true },
        '+': { skipEmpty: false },
        '?': { blocking: false },
    };
    const [, hints, rule] = matches;
    const hintGroups = hasDebounce.test(hints)
        ? hints.match(


 a single file, possibly thanks to the \`@yarnpkg/builder\` package).
    `,examples:[['Download and activate the "@yarnpkg/plugin-exec" plugin',"$0 plugin import @yarnpkg/plugin-exec"],['Download and activate the "@yarnpkg/plugin-exec" plugin (shorthand)',"$0 plugin import exec"],["Download and activate a community plugin","$0 plugin import https://example.org/path/to/plugin.js"],["Activate a local plugin","$0 plugin import ./path/to/plugin.js"]]});async function _8(t,e,{checksum:r=!0,project:o,report:a}){let{configuration:n}=o,u={},A={exports:u};(0,rde.runInNewContext)(e.toString(),{module:A,exports:u});let h=`.yarn/plugins/${A.exports.name}.cjs`,E=V.resolve(o.cwd,h);a.reportInfo(0,`Saving the new plugin in ${de.pretty(n,h,"magenta")}`),await oe.mkdirPromise(V.dirname(E),{recursive:!0}),await oe.writeFilePromise(E,e);let I={path:h,spec:t};r&&(I.checksum=wn.makeHash(e)),await Ke.addPlugin(o.cwd,[I])}var tgt=({pluginName:t,noMinify:e},r)=>[["yarn",`build:${t}`,...e?["--no-minify"]:[],"|"]],zh=class extends ut{constructor(){super(...arguments);this.installPath=ge.String("--path",{description:"The path where the repository should be cloned to"});this.repository=ge.String("--repository","https://github.com/yarnpkg/berry.git",{description:"The repository that should be cloned"});this.branch=ge.String("--branch","master",{description:"The branch of the repository that should be cloned"});this.noMinify=ge.Boolean("--no-minify",!1,{description:"Build a plugin for development (debugging) - non-minified and non-mangled"});this.force=ge.Boolean("-f,--force",!1,{description:"Always clone the repository instead of trying to fetch the latest commits"});this.name=ge.String()}async execute(){let r=await Ke.find(this.context.cwd,this.context.plugins),o=typeof this.installPath<"u"?V.resolve(this.context.cwd,ue.toPortablePath(this.installPath)):V.resolve(ue.toPortablePath((0,nde.tmpdir)()),"yarnpkg-sources",wn.makeHash(this.repository).slice(0,6));return(await Nt.start({configuration:r,stdout:this.context.stdout},async n=>{let{project:u}=await Pt.find(r,this.context.cwd),A=W.parseIdent(this.name.replace(/^((@yarnpkg\/)?plugin-)?/,"@yarnpkg/plugin-")),p=W.stringifyIdent(A),h=await zd(r,rn);if(!Object.hasOwn(h,p))throw new zt(51,`Couldn't find a plugin named "${p}" on the remote registry. Note that only the plugins referenced on our website (https://github.com/yarnpkg/berry/blob/master/plugins.yml) can be built and imported from sources.`);let E=p;await M8(this,{configuration:r,report:n,target:o}),await U8(E,this,{project:u,report:n,target:o})})).exitCode()}};zh.paths=[["plugin","import","from","sources"]],zh.usage=nt.Usage({category:"Plugin-related commands",description:"build a plugin from sources",details:`
      This command clones the Yarn repository into a temporary folder, builds the specified contrib plugin and updates the configuration to reference it in further CLI invocations.

      The plugins can be referenced by their short name if sourced from the official Yarn repository.
    `,examples:[['Build and activate the "@ya