tack.length !== 0 && max>0) {
        let connection = stack.shift();
        if (input === connection.output) {return true;}
        stack.push(
          ...axons.filter((axon) => axon.input === connection.output && axon.output.type!==NeuronType.OUTPUT)
        );
        max--
      }
      return false;
    }

  /**
   * Compute the distance between two Genomes using
   * [equation 2](https://github.com/onino-js/NEAT/blob/main/documentation/neat-implementation.md)
   *
   * @param {[Genome, Genome]} genomes An array of exactly two Genomes.
   * @return {number} the distance between the two Genomes.
   */
  static computeDistance({
    genomes,
    distanceConfiguration,
  }: {
    genomes: [Genome, Genome];
    distanceConfiguration: IdistanceConfiguration;
  }): number {
    const { c1, c2, c3 } = distanceConfiguration;
    const E = NeatUtils.computeNumberOfExcessGenes(genomes);
    const D = NeatUtils.computeNumberOfDisjointGenes(genomes);
    const W = NeatUtils.computeAverageWieghtDifference(genomes);
    const N = Math.max(genomes[0].genes.length, genomes[1].genes.length);
    return (c1 * E) / N + (c2 * D) / N + c3 * W;
  }

  /**
   * Compute the number of genes who missmatch between two genomes.
   *
   * @param {[Genome, Genome]} genomes An array of exactly two Genomes.
   * @return {number} the number of disjoint genes.
   */
  static computeNumberOfMissmatchGenes(genomes: [Genome, Genome]): number {
    return genomes[0].genes
      .concat(genomes[1].genes)
      .map((g) => g.innovation)
      .reduce(
        (acc, cur, i, arr) =>
          arr.filter((a) => a === cur).length === 2 ? acc : acc + 1,
        0
      );
  }

  /**
   * Compute the number of disjoint genes between two genomes.
   *
   * @param {[Genome, Genome]} genomes An array of exactly two Genomes.
   * @return {number} the number of disjoint genes.
   */
  static computeNumberOfDisjointGenes(genomes: [Genome, Genome]): number {
    return (
      NeatUtils.computeNumberOfMissmatchGenes(genomes) -
      NeatUtils.computeNumberOfExcessGenes(genomes)
    );
  }

  /**
   * Compute the number of excess genes between two genomes.
   *
   * @param {[Genome, Genome]} genomes An array of exactly two Genomes.
   * @return {number} the number of disjoint genes.
   */
  static computeNumberOfExcessGenes(genomes: [Genome, Genome]): number {
    const genes1 = NeatUtils.getGenesIndexedByInnovation(genomes[0].axonGenes);
    const genes2 = NeatUtils.getGenesIndexedByInnovation(genomes[1].axonGenes);
    return Math.abs(genes1.length - genes2.length);
  }

  /**
   * Compute the average weight difference of matching genes between two genomes.
   *
   * @param {[Genome, Genome]} genomes An array of exactly two Genomes.
   * @return {number} the average weight difference of matching genes.
   */
  static computeAverageWieghtDifference(genomes: [Genome, Genome]): number {
    let nbOdMatchingGene = 0;
    let totalDofference = 0;
    genomes[0].axonGenes.forEach((ag) => {
      const twin = genomes[1].axonGenes.find(
        (_ag) => _ag.innovation === ag.innovation
      )!;
      if (twin !== undefined) {
        nbOdMatchingGene += 1;
        totalDofference += Math.abs(twin.weight - ag.weight);
      }


namespace NServiceBus.AcceptanceTesting.Support;

using System;
using System.Threading;
using System.Threading.Tasks;

public class EndpointBehaviorBuilder<TContext> where TContext : ScenarioContext
{
    public EndpointBehaviorBuilder(IEndpointConfigurationFactory endpointConfigurationFactory)
    {
        behavior = new EndpointBehavior(endpointConfigurationFactory)
        {
            Whens = []
        };
    }

    public EndpointBehaviorBuilder<TContext> When(Func<IMessageSession, TContext, Task> action)
    {
        return When(c => true, action);
    }

    public EndpointBehaviorBuilder<TContext> When(Func<IMessageSession, Task> action)
    {
        return When(c => true, action);
    }

    public EndpointBehaviorBuilder<TContext> When(Func<TContext, Task<bool>> condition, Func<IMessageSession, Task> action)
    {
        behavior.Whens.Add(new WhenDefinition<TContext>(condition, action));

        return this;
    }

    public EndpointBehaviorBuilder<TContext> When(Predicate<TContext> condition, Func<IMessageSession, Task> action)
    {
        behavior.Whens.Add(new WhenDefinition<TContext>(ctx => Task.FromResult(condition(ctx)), action));

        return this;
    }

    public EndpointBehaviorBuilder<TContext> When(Func<TContext, Task<bool>> condition, Func<IMessageSession, TContext, Task> action)
    {
        behavior.Whens.Add(new WhenDefinition<TContext>(condition, action));

        return this;
    }

    public EndpointBehaviorBuilder<TContext> When(Predicate<TContex


n        'max_depth': 4, # Increased max_depth for more capacity\\n        'min_child_weight': 5, # Drastically reduced for better fitting, but still more than 1\\n        'subsample': 0.7,\\n        'colsample_bytree': 0.7,\\n        'random_state': 42,\\n        'n_jobs': -1,\\n        'tree_method': 'hist',\\n        'gamma': 0.1, # Reduced gamma regularization\\n        'reg_lambda': 1.0, # Reduced L2 regularization\\n        'reg_alpha': 0.1 # Reduced L1 regularization\\n    }\\n    # Override defaults with config-specific XGBoost parameters\\n    xgb_params = {**default_xgb_params, **config.get('xgb_params', {})}\\n    xgb_params.pop('eval_metric', None) # Safely remove eval_metric if present, as it's not standard for reg:quantile objective or set automatically\\n\\n    # Feature engineering parameters.\\n    LAG_WEEKS = config.get('lag_weeks', [1, 4, 8, 16, 26, 52])\\n    LAG_DIFF_PERIODS = config.get('lag_diff_periods', [1, 2, 4, 8])\\n    ROLLING_WINDOWS = config.get('rolling_windows', [8, 16, 26])\\n    ROLLING_STD_WINDOWS = config.get('rolling_std_windows', [4, 8])\\n\\n    target_transform_type = config.get('target_transform', 'fourth_root')\\n\\n    ensemble_model_types = config.get('ensemble_model_types', ['lgbm', 'xgb'])\\n    n_lgbm_ensemble_members = config.get('n_lgbm_ensemble_members', 1)\\n    n_xgb_ensemble_members = config.get('n_xgb_ensemble_members', 1)\\n\\n    # Max admissions per million cap. This value is critical for scaling and numerical stability.\\n    MAX_ADMISSIONS_PER_MILLION = float(config.get('max_admissions_per_million', 5000.0))\\n\\n    # Minimal difference between adjacent quantile predictions to avoid zero-width intervals.\\n    MIN_PRED_SPREAD = float(config.get('min_pred_spread', 1))\\n\\n    # A global cap for final predictions to prevent excessively large (e.g., infinite) scores.\\n    MAX_FINAL_PREDICTION = float(config.get('max_final_prediction', 500000.0))\\n\\n    # --- 1. Combine train_x and train_y, and prepare for transformations ---\\n    df_train_full = train_x.copy()\\n    df_train_full[TARGET_COL] = train_y\\n    df_train_full[DATE_COL] = pd.to_datetime(df_train_full[DATE_COL])\\n    df_train_full = df_train_full.sort_values(by=[LOCATION_COL, DATE_COL]).reset_index(drop=True)\\n\\n    # Handle zero population by using 1.0 to avoid division by zero\\n    safe_population = np.where(df_train_full[POPULATION_COL] == 0, 1.0, df_train_full[POPULATION_COL])\\n    admissions_per_million = df_train_full[TARGET_COL] / safe_population * 1_000_000\\n\\n    # Clip admissions per million before transformation to prevent extreme values.\\n    admissions_per_million = np.clip(admissions_per_million, 0.0, MAX_ADMISSIONS_PER_MILLION)\\n\\n    # Define transform and inverse transform functions based on configuration\\n    if target_transform_type == 'fourth_root':\\n        df_train_full[TRANSFORMED_TARGET_COL] = np.power(admissions_per_million + 1.0, 0.25)\\n        def inverse_transform(x):\\n            # Ensure


.161-1.337.771-2.599 1.64-3.957.031.063.073.124.109.187a1.82 1.82 0 001.599.808c.292-.011.808.036 1.647.312a3.578 3.578 0 012.14 1.901c.432.907.469 1.921.109 2.864a3.638 3.638 0 01-1.077 1.48l-.543-.672-.005-.005a1.94 1.94 0 00-1.509-.713 1.945 1.945 0 00-1.943 1.854c-1.605-.724-2.401-2.192-2.172-4.057zm5.739 6.813-.692.568a.315.315 0 01-.199.067.306.306 0 01-.235-.109l-.145-.181a.315.315 0 01.041-.443l.683-.563-1.407-1.729a.415.415 0 01.057-.584.416.416 0 01.261-.099c.119 0 .239.052.317.151l3.953 4.865a.407.407 0 01-.057.577.378.378 0 01-.167.084.284.284 0 01-.093.016.44.44 0 01-.324-.152l-.391-.489-1.396 1.141a.319.319 0 01-.452-.048l-.636-.771a.322.322 0 01.047-.448l1.401-1.145zm-7.26-8.579-1.593-.104a.613.613 0 01-.584-.645l.12-1.871a.62.62 0 01.615-.583h.031l1.871.125a.556.556 0 01.421.203.607.607 0 01.156.448l-.011.131c-.427.76-.78 1.515-1.031 2.296zm16.697 15.308c-.755 1.072-2.249 1.443-3.9.957-5.177-1.52-9.86-1.208-13.953.933l2.177-6.828-7.053 7.479c.131-5.021 3.272-9.292 7.677-11.084.631.495 1.38.881 2.229 1.12.213.057.432.099.641.136a1.874 1.874 0 00.281 1.875l.099.125a1.836 1.836 0 00.296 1.828l.631.776c.355.432.88.688 1.437.688a1.88 1.88 0 001.183-.423l.38-.307c.235.099.489.151.756.151.151 0 .296-.016.443-.047.285-.068.561-.204.796-.391a1.955 1.955 0 00.276-2.745l-2.224-2.739c.193-.157.376-.329.541-.511.183.052.365.104.537.161.353.129.708.26 1.057.416a12.753 12.753 0 013.692 2.532c.043.041.084.072.115.109l.229.235c.047.052.099.104.147.161.104.115.213.233.317.353l.172.204c.057.067.115.135.172.213l.151.197.156.204c1.12 1.536 1.317 3.109.536 4.213v.005zM10.292 5.484l-1.115-.068.073-1.109 1.109.068z"/></svg>';
  static const String keycdn =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="32" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 32 32"><path fill="currentColor" d="M3.07


摘要，提取出最重要的信息？ |
| 烹饪 | 如何制作一份口感香脆的炸鸡？ |
| 医学 | 哪些食物可以帮助预防贫血？ |
| 编程 | 如何在Python中实现二叉树的遍历算法？ |
| 电影 | 在经典电影《肖申克的救赎》中，主人公在监狱中是如何生存的？ |
| 旅游 | 如果只有两天时间，如何最好地游览北京市内的名胜古迹？ |
| 国际政治 | 阿富汗塔利班组织最近的动态是什么？ |
| 营养学 | 健康成年人需要每天摄入多少纤维素？ |
| 经济学 | 货币政策和财政政策的区别是什么？ |
| 数学 | 求解以下方程组：$\begin{cases}x+2y=5 \\ 3x-4y=-2 \end{cases}$ |
| 历史 | 英国工业革命对全球的影响是什么？ |
| 文本生成 | 能否根据以下内容，为我创作一篇关于绿色能源的文章？请在文章中讨论太阳能和风能，并探讨其优缺点。|
| 情感分类 | 请将以下段落分类：「我最近看到了一部非常好看的电影，它的情节复杂而有趣。」|
| 文本编辑 | 请将以下句子改写为更加简洁明了的表达方式：「由于天气极度恶劣，在这个周末我们不可能前往海滩度假。」|
| 实体识别 | 下面的文本中，找出所有和计算机科学相关的实体和专业术语：「人工智能是计算机科学领域发展最快的分支之一。它涵盖了机器学习、自然语言处理、深度学习等多个方面。」|
| 开放性生成 | 请为一个名叫小明的人物编写一段人物介绍。|
| 知识问答 | 什么是欧拉公式？|
| 文本转换 | 将以下短信的语气由负面改为正面：「今天约会又被泡汤了，他真的好讨厌！」|
| 关键词提取 | 从以下文章中挑选出包含环保主题的词汇或短语：「随着全球变暖的加剧，环境保护已经成为了人们关注的焦点。许多国家都开始采取行动，推动可持续发展和绿色增长。」|
| 文本摘要 | 将以下文章压缩成一两句话的摘要：「她是一位成功的企业家，曾经创建


,"LC","S"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
["Pygmy Rattlesnake","LC","S"],
["Eastern Diamond-backed Rattlesnake","LC","D"],
[,"NE","U"],
[,"NE","U"],
["Transvaal Quillsnout Snake","DD","U"],
["Common Purple-glossed Snake","NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
["Red-headed Krait","NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"LC","S"],
[,"LC","S"],
[,"LC","S"],
["Paradise Flying Snake","NE","U"],
["Golden Flying Snake","NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
["Kirtland's Snake","NT","D"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
[,"NE","U"],
["Heptner's Pygmy Jerboa","DD","U"],
["Kluchor Birch Mouse","NT","U"],
["Altai Birch Mouse","LC","U"],
["Tien Shan Birch Mouse","LC","U"],
["Strand's Birch Mouse","LC","S"],
["Kazbeg Birch Mouse","EN","U"],
["Southern Birch Mouse","LC","D"],
["Severtzov's Birch Mouse","LC","S"],
["Sandy Mole Rat","EN","D"],
["Crump's Mouse","DD","U"],
["Giant Sulawesi Rat","LC","S"],
["Ryukyus Islands Tree Rat","EN","D"],
["Luzon Batomys","NT","D"],
["Javan Sundamys","EN","D"],
["Mountain Sundamys","LC","U"],
["Mount Oku Rat","EN","D"],
["Nusa Tenggara Komodomys","VU","S"],
["Armandville's Papagomys","NT","D"],
["Ammodile","DD","S"],
["Boehm's Gerbil","LC","S"],
["Dwarf Gerbil","LC","S"],
[,"NE","U"],
["Namib Brush-tailed Gerbil","LC","S"],
["Forest Giant Pouched Rat","LC","S"],
[,"NE","U"],
["Gambian Rat","LC","S"],
[,"NE","U"],
["Hairy-tailed Bolo Mouse","LC","U"],
[,"LC","S"],
["Brazilian Arboreal Mouse","NT","D"],
["Cerrado Mouse","LC","U"],
["Hairy-eared Cerrado Mouse","LC","U"],
["Venezuelan Climbing Mouse","LC","S"],
["Delta Pygmy Rice Rat","LC","S"],
["Edwards's Long-clawed Mouse","LC","S"],
["Colombian Forest Mouse","LC","S"],
["Tweedy's Crab-eating Rat","DD","U"],
["Underwood's Water Mouse","LC","S"],
["Thomas's Water Mouse","NT","U"],
["Oyapock's Fish-eating Rat","DD","D"],
["Peruvian Fish-eating Rat","LC","S"],
["Tawny-bellied Cotton Rat","LC","S"],
["Alston's Cotton Rat","LC","U"],
["Yellow-nosed Cotton Rat","LC","U"],
["Michoacan Deer Mouse","LC","U"],
["Nelson's Giant Deer Mouse","EN","D"],
["Pinyon Mouse","LC","S"],
["Rock Mouse","LC","S"],
["N


func (mfi *MetadataFileInfo) Sys() interface{}   { return nil }

// MetadataSegmentLoader adapts metadata segments to the usenet.SegmentLoader interface
type MetadataSegmentLoader struct {
	segments []*metapb.SegmentData
}

// newMetadataSegmentLoader creates a new metadata segment loader
func newMetadataSegmentLoader(segments []*metapb.SegmentData) *MetadataSegmentLoader {
	return &MetadataSegmentLoader{
		segments: segments,
	}
}

// GetSegment implements usenet.SegmentLoader interface
func (msl *MetadataSegmentLoader) GetSegment(index int) (segment usenet.Segment, groups []string, ok bool) {
	if index < 0 || index >= len(msl.segments) {
		return usenet.Segment{}, nil, false
	}

	seg := msl.segments[index]

	// Important: range builder only knows (Start, Size) and assumes usable bytes are [Start, Size-1].
	// Our metadata may have a trimmed EndOffset (< SegmentSize-1). Provide a synthetic Size = EndOffset+1
	// so usable length becomes (EndOffset - StartOffset + 1) and no extra tail bytes are exposed.
	size := seg.SegmentSize
	if seg.EndOffset > 0 && seg.EndOffset < seg.SegmentSize-1 {
		size = seg.EndOffset + 1
	}

	// Keep original start offset (could be >0 due to RAR processing) and size
	return usenet.Segment{
		Id:    seg.Id,
		Start: seg.StartOffset,
		Size:  size,
	}, []string{}, true // Empty groups for now - could be stored in metadata if needed
}

// MetadataVirtualDirectory implements afero.File for metadata-backed virtual directories
type MetadataVirtualDirectory struct {
	name            string
	normalizedPath  string
	metadataService *metadata.MetadataService
	showCorrupted   bool
}

// Read implements afero.File.Read (not supported for directories)
func (mvd *MetadataVirtualDirectory) Read(p []byte) (n int, err error) {
	return 0, ErrCannotReadDirectory
}

// ReadAt implements afero.File.ReadAt (not supported for directories)
func (mvd *MetadataVirtualDirectory) ReadAt(p []byte, off int64) (n int, err error) {
	return 0, ErrCannotReadDirectory
}

// Seek implements afero.File.Seek (not supported for directories)
func (mvd *MetadataVirtualDirectory) Seek(offset int64, whence int) (int64, error) {
	return 0, ErrCannotReadDirectory
}

// Close implements afero.File.Close
func (mvd *MetadataVirtualDirectory) Close() error {
	return nil
}

// Name implements afero.File.Name
func (mvd *MetadataVirtualDirectory) Name() string {
	return mvd.name
}

// Readdir implements afero.File.Readdir
func (mvd *MetadataVirtualDirectory) Readdir(count int) ([]fs.FileInfo, error) {
	// Create metadata reader for directory operations
	reader := metadata.NewMetadataReader(mvd.metadataService)

	// Get directory contents - we only need the directory infos, not the file metadata
	dirInfos, _, err := reader.ListDirectoryContents(mvd.normalizedPath)
	if err != nil {
		return nil, err
	}

	var infos []fs.FileInfo

	// Add directories first
	for _, dirInfo := range dirInfos {
		infos = append(infos, dirInfo)
		if count > 0 && len(infos) >= count {
			return infos, nil
		}
	}

	// Add files - we need to get the virtual filename from the metadata path
	// Since ListDirectoryContents already reads the metadata files, we need to get the filenames differently
	// Let's use the metadata service directly to list files in the directory
	fileNames, err := mvd.metadat


络威胁。最终，Cloudflare 的服务实质上是在执行自身的隐私增强功能。我们从一开始就构建了自己的系统来确保数据的隐私性，甚至对我们自己也保密，我们就保护数据的私密性和安全性制定了公共策略和合同承诺。但是，除了为客户利益而保护我们的网络外，我们还大力投资新技术，旨在保护通信不受不良行为者的影响；不受 ISP 或其他中间机器的窥探，这些机器可能会为广告目的而发现您感兴趣的互联网通信内容；或政府实体可能想打击行使言论自由权利的个人。

例如，Cloudflare 运营着 Apple 的 iCloud 私人中继系统的部分组件，该系统确保处理用户数据的任何一方都不会拥有关于用户是谁、试图访问什么内容的完整信息。相反，用户的原始 IP 地址对接入网络（例如您所在的咖啡厅，或您的家庭互联网服务提供商）和第一个中继（由 Apple 运营）可见，但服务器或网站名称是加密的，对两者都不可见。第一个中继将加密数据交给第二个中转（例如 Cloudflare），但无法看到传往 Cloudflare 的流量“内部”。而 Cloudflare 运营的中继只知道它在接收来自私人中继用户的流量，但不知道具体是谁，也不知道客户端 IP 地址。然后，Cloudflare 中继将流量转发给目的地服务器。

当然，如果不提 Cloudflare 隐私至上的 1.1.1.1 公共解析器，任何关于安全措施如何更好地保障数据隐私性的文章都有失严谨。通过使用 1.1.1.1，个人可以在互联网上搜索，而 ISP 不会知道他们浏览了什么内容。与大多数 DNS 解析器不同，1.1.1.1 不会向广告商出售用户数据。

总而言之，上述技术和安全措施共同确保个人数据的隐私性，免遭行为广告、中间人攻击、恶意代码等各类隐私威胁。在 2023 年数据隐私日来临之际，我们督促监管者认识到，目前强调的数据本地化措施可能操之过激，而且还排除了跨境数据传输可能给数据安全以及数据隐私带来的诸多益处。

28 分钟（阅读时间）

<div class="post-cont


 the output Channel. Additionally it sends back a
// StandbyStatus when requested from postgres.
// Start needs to be provided a progressChan because we need to initialize all the modules first to produce a
// progressChan needed for the replication.client
func (c *Replicator) Start(progressChan <-chan uint64) {
	defer c.shutdown()

	log.Info("Starting")
	c.progressChan = progressChan

	var pgConn conn.Conn
	var message pgproto3.BackendMessage
	var rplErr error

	// Get a connection
	pgConn, rplErr = c.connManager.GetConnWithStartLsn(c.shutdownHandler.TerminateCtx, 0)
	if rplErr != nil {
		log.Error(rplErr.Error())
		return
	}

	// First replication message will be a ServerHeartbeat which contains
	// the current wal end location. This is our starting location.
	func() {
		replicationCtx, cancelFn := context.WithTimeout(c.shutdownHandler.TerminateCtx, 5*time.Second)
		defer cancelFn()

		message, rplErr = pgConn.ReceiveMessage(replicationCtx)
	}()

	cd, ok := message.(*pgproto3.CopyData)
	if !ok {
		log.Errorf("Received unexpected message: %#v", message)
		return
	}

	if cd.Data[0] != pglogrepl.PrimaryKeepaliveMessageByteID {
		log.Error("server did not send a heartbeat as the first message")
		return
	}

	pkm, err := pglogrepl.ParsePrimaryKeepaliveMessage(cd.Data[1:])
	if err != nil {
		log.WithError(err).Error("unable to parse keepalive")
	}

	// Set overall status to that of server's location
	log.Infof("replication slot LSN: %s / %d",
		pkm.ServerWALEnd,
		uint64(pkm.ServerWALEnd))
	c.overallProgress = uint64(pkm.ServerWALEnd)

	// Ticker to force update of progress
	ticker := time.NewTicker(c.progressFreq)
	defer ticker.Stop()

	// Loop reading replication messages
	for {
		// Check to see if a termination is initiated
		select {
		case <-c.shutdownHandler.TerminateCtx.Done():
			log.Debug("received terminateCtx cancellation")
			return
		default:
		}

		// If the ticker ticked then do a force progress send. This way we are always
		// reporting progress regardless of downstream.
		forceProgress := false
		select {
		case <-ticker.C:
			forceProgress = true
		default:
			forceProgress = false
		}

		// Check progress channel and only send an update if there is one
		if err := c.handleProgress(forceProgress); err != nil {
			log.Error(err)
			return
		}

		// Get a connection
		pgConn, rplErr = c.connManager.GetConnWithStartLsn(c.shutdownHandler.TerminateCtx, c.highestWalStart)
		if rplErr != nil {
			log.WithError(rplErr).Error("fatal")
			return
		}

		// Setup a timeout and then read from replication slot on server
		func() {
			replicationCtx, cancelFn := context.WithTimeout(c.shutdownHandler.TerminateCtx, 5*time.Second)
			defer cancelFn()

			message, rplErr = pgConn.ReceiveMessage(replicationCtx)
		}()

		// Check for error and connection status
		if rplErr != nil {
			if pgconn.Timeout(rplErr) || errors.Is(rplErr, context.DeadlineExceeded) {
				if err := c.handleProgress(true); err != nil {
					log.Error(err)
					return
				}

				continue
			}

			log.WithError(rplErr).Warn("handling replication error")

			// TODO(#8): what about other types of errors?
			if pgConn.IsClosed() {
				log.Warn("connection was closed")
				continue
			}


us loadModuleStatus = PageStatus.init;
  late VoltronJSLoaderManager _loaderManager;
  late VoltronJSLoader _jsLoader;
  int errorCode = -1;
  late bool _debugMode;
  late String _coreBundle;
  late String _indexBundle;
  late String _remoteServerUrl;

  @override
  void initState() {
    super.initState();
    _debugMode = widget.debugMode;
    _coreBundle = widget.coreBundle;
    _indexBundle = widget.indexBundle;
    _remoteServerUrl = widget.remoteServerUrl;
    _initVoltronData();
  }

  void _initVoltronData() async {
    IosDeviceInfo? deviceData;
    if (Platform.isIOS) {
      try {
        deviceData = await DeviceInfoPlugin().iosInfo;
      } catch (err) {
        setState(() {
          engineStatus = PageStatus.error;
        });
      }
    }
    var initParams = EngineInitParams();
    initParams.debugMode = _debugMode;
    initParams.enableLog = true;
    if (_debugMode) {
      // 调试模式下直接使用debug参数
      initParams.remoteServerUrl = _remoteServerUrl;
    } else {
      // 如果是不分包加载，可以只填写coreJSAssetsPath，下面的jsAssetsPath直接忽略即可
      initParams.coreJSAssetsPath = _coreBundle;
      initParams.codeCacheTag = "common";
    }
    initParams.integratedMode = IntegratedMode.flutterApp;
    initParams.providers = [
      MyAPIProvider(),
    ];
    initParams.engineMonitor = Monitor();
    initParams.exceptionHandler = CustomExceptionHandler(_debugMode, dialogRootKey);
    _loaderManager = VoltronJSLoaderManager.createLoaderManager(
      initParams,
      (statusCode, msg) {
        LogUtils.i(
          'loadEngine',
          'code($statusCode), msg($msg)',
        );
        if (statusCode == EngineInitStatus.ok) {
          setState(() {
            engineStatus = PageStatus.success;
          });
        } else {
          setState(() {
            engineStatus = PageStatus.error;
            errorCode = statusCode.value;
          });
        }
      },
    );
    var loadParams = ModuleLoadParams();
    loadParams.componentName = "Demo";
    loadParams.codeCacheTag = "Demo";
    if (isWebUrl(_indexBundle)) {
      loadParams.jsHttpPath = _indexBundle;
    } else {
      loadParams.jsAssetsPath = _indexBundle;
    }
    loadParams.jsParams = VoltronMap();
    loadParams.jsParams?.push(
      "msgFromNative",
      "Hi js developer, I come from native code!",
    );
    if (deviceData != null) {
      loadParams.jsParams?.push(
        "isSimulator",
        !deviceData.isPhysicalDevice,
      );
    }
    _jsLoader = _loaderManager.createLoader(
      loadParams,
      moduleListener: (status, msg) {
        if (status == ModuleLoadStatus.ok) {
          loadModuleStatus = PageStatus.success;
        } else {
          loadModuleStatus = PageStatus.error;
        }
        LogUtils.i(
          "flutterRender",
          "loadModule status($status), msg ($msg)",
        );
      },
    );
  }

  @override
  void dispose() {
    super.dispose();
    _jsLoader.destroy();
    _loaderManager.destroy();
  }

  @override
  Widget build(BuildContext context) {
    Widget child;
    if (engineStatus == PageStatus.success) {
      child = Scaffold(
        body: VoltronWidget(
          loader: _jsLoader,
          loadingBuilder: _debugMode ? null : (context) => Container(),
        ),
      );
    } else if (engineStatus == PageStatus.error) {
      child = Center(
        child: Text('init engine error, code: ${errorCode.toString()}'),
      );


ertificate field of the structure.
     * @return  tbsCertificate
     */
    public TBSCertificate getTbsCertificate() {
        return tbsCertificate;
    }

    /**
     * Returns the value of signatureAlgorithm field of the structure.
     * @return  signatureAlgorithm
     */
    public AlgorithmIdentifier getSignatureAlgorithm() {
        return signatureAlgorithm;
    }

    /**
     * Returns the value of signatureValue field of the structure.
     * @return  signatureValue
     */
    public byte[] getSignatureValue() {
        byte[] result = new byte[signatureValue.length];
        System.arraycopy(signatureValue, 0, result, 0, signatureValue.length);
        return result;
    }

    public String toString() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("X.509 Certificate:\n[\n"); //$NON-NLS-1$
        tbsCertificate.dumpValue(buffer);
        buffer.append("\n  Algorithm: ["); //$NON-NLS-1$
        signatureAlgorithm.dumpValue(buffer);
        buffer.append(']');
        buffer.append("\n  Signature Value:\n"); //$NON-NLS-1$
        buffer.append(Array.toString(signatureValue, "")); //$NON-NLS-1$
        buffer.append(']');
        return buffer.toString();
    }

    /**
     * Returns ASN.1 encoded form of this X.509 TBSCertificate value.
     * @return a byte array containing ASN.1 encode form.
     */
    public byte[] getEncoded() {
        if (encoding == null) {
            encoding = Certificate.ASN1.encode(this);
        }
        return encoding;
    }

    /**
     * X.509 Certificate encoder/decoder.
     */
    public static final ASN1Sequence ASN1 =
        new ASN1Sequence(new ASN1Type[]
                {TBSCertificate.ASN1, AlgorithmIdentifier.ASN1, ASN1BitString.getInstance()}) {

        protected Object getDecodedObject(BerInputStream in) {
            Object[] values = (Object[]) in.content;
            return new Certificate(
                    (TBSCertificate) values[0],
                    (AlgorithmIdentifier) values[1],
                    ((BitString) values[2]).bytes, // FIXME keep as BitString object
                    in.getEncoded()
                    );
        }

        protected void getValues(Object object, Object[] values) {

            Certificate cert = (Certificate) object;

            values[0] = cert.tbsCertificate;
            values[1] = cert.signatureAlgorithm;
            values[2] = new BitString(cert.signatureValue, 0);
        }
    };
}

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

/**
* @author Alexander Y. Kleymenov
* @version $Revision$
*/

/*
 * Imported by CG 20090321 based on Apache Harmony ("enhanced") revision 490473.
 */

package org.apache.harmony.security.x509;

import org.apache.harmony.security.asn1.ASN1Sequence;
import org.apache.harmony.security.asn1.ASN1Type;
import org.apache.harmony.security.asn1.BerInputStream;

/**
 * The class encapsulates the ASN.1 DER encoding/decoding work
 * with the ORAddress structure which is a part of X.509 certificate:


path.name.as_ref())
        //     .send()?;

        Ok(AnalyzeDependenciesOutcome { crates, duration })
    }

    pub async fn analyze_crate_dependencies(
        &self,
        crate_path: CratePath,
    ) -> Result<AnalyzeDependenciesOutcome, Error> {
        let start = Instant::now();

        let query_response = self
            .query_crate
            .cached_query(crate_path.name.clone())
            .await?;

        let engine = self.clone();

        match query_response
            .releases
            .iter()
            .find(|release| release.version == crate_path.version)
        {
            None => Err(anyhow!(
                "could not find crate release with version {}",
                crate_path.version
            )),

            Some(release) => {
                let analyzed_deps =
                    analyze_dependencies(engine.clone(), release.deps.clone()).await?;

                let crates = vec![(crate_path.name, analyzed_deps)];
                let duration = start.elapsed();

                Ok(AnalyzeDependenciesOutcome { crates, duration })
            }
        }
    }

    pub async fn find_latest_crate_release(
        &self,
        name: CrateName,
        req: VersionReq,
    ) -> Result<Option<CrateRelease>, Error> {
        let query_response = self.query_crate.cached_query(name).await?;

        let latest = query_response
            .releases
            .iter()
            .filter(|release| req.matches(&release.version))
            .max_by(|r1, r2| r1.version.cmp(&r2.version))
            .cloned();

        Ok(latest)
    }

    fn fetch_releases<'a, I>(&'a self, names: I) -> BoxStream<'a, anyhow::Result<Vec<CrateRelease>>>
    where
        I: IntoIterator<Item = CrateName>,
        <I as IntoIterator>::IntoIter: Send + 'a,
    {
        let engine = self.clone();

        let s = stream::iter(names)
            .zip(stream::repeat(engine))
            .map(resolve_crate_with_engine)
            .buffer_unordered(25);

        Box::pin(s)
    }

    async fn retrieve_manifest_at_path(
        &self,
        repo_path: &RepoPath,
        path: &RelativePathBuf,
    ) -> Result<String, Error> {
        let manifest_path = path.join(RelativePath::new("Cargo.toml"));

        let mut service = self.retrieve_file_at_path.clone();
        Ok(service.call((repo_path.clone(), manifest_path)).await?)
    }

    async fn fetch_advisory_db(&self) -> Result<Arc<Database>, Error> {
        Ok(self.fetch_advisory_db.cached_query(()).await?)
    }
}

async fn resolve_crate_with_engine(
    (crate_name, engine): (CrateName, Engine),
) -> anyhow::Result<Vec<CrateRelease>> {
    let crate_res = engine.query_crate.cached_query(crate_name).await?;
    Ok(crate_res.releases)
}

static POPULAR_REPO_BLOCK_LIST: Lazy<HashSet<RepoPath>> = Lazy::new(|| {
    vec![
        RepoPath::from_parts("github", "rust-lang", "rust"),
        RepoPath::from_parts("github", "xi-editor", "xi-editor"),
        RepoPath::from_parts("github", "lk-geimfari", "awesomo"),
        RepoPath::from_parts("github", "redox-os", "tfs"),
        RepoPath::from_parts("github", "rust-lang", "rustlings"),
        RepoPath::from_parts("github", "rust-unofficial", "awesome-rust"),
        RepoPath::from_parts("github", "996icu", "996.ICU"),
    ]


work:before {
  content: '\e274';
}

.ms-Icon--move:before {
  content: '\e275';
}

.ms-Icon--classroom:before {
  content: '\e276';
}

.ms-Icon--menu2:before {
  content: '\e277';
}

.ms-Icon--plus2:before {
  content: '\e278';
}

.ms-Icon--tag:before {
  content: '\e279';
}

.ms-Icon--arrowUp2:before {
  content: '\e27a';
}

.ms-Icon--arrowDown2:before {
  content: '\e27b';
}

.ms-Icon--circlePlus:before {
  content: '\e27c';
}

.ms-Icon--circleInfo:before {
  content: '\e27d';
}

.ms-Icon--section:before {
  content: '\e27e';
}

.ms-Icon--sections:before {
  content: '\e27f';
}

.ms-Icon--at:before {
  content: '\e282';
}

.ms-Icon--arrowUpRight:before {
  content: '\e283';
}

.ms-Icon--arrowDownRight:before {
  content: '\e284';
}

.ms-Icon--arrowDownLeft:before {
  content: '\e285';
}

.ms-Icon--arrowUpLeft:before {
  content: '\e286';
}

.ms-Icon--bundle:before {
  content: '\e287';
}

.ms-Icon--pictureEdit:before {
  content: '\e288';
}

.ms-Icon--protectionCenter:before {
  content: '\e289';
}

.ms-Icon--alert2:before {
  content: '\e28a';
}

.ms-Icon--circle {
  position: relative;
  display: inline-block;
  font-size: 1rem;
  width: 1em;
  height: 1em;
  margin: 0 0.5em 0 0;
  padding: 0;
  text-align: left;
  -webkit-font-smoothing: antialiased;
}

.ms-Icon--circle:before,
.ms-Icon--circle:after {
  line-height: 1;
  font-size: inherit;
}

.ms-Icon--circle:before {
  display: block;
  width: 100%;
  height: 100%;
  margin: 0;
  padding: 0;
  vertical-align: top;
  position: absolute;
}

.ms-Icon--circle:after {
  content: '\e000';
  position: absolute;
  top: 0;
  left: 0;
  -ms-transform: scale(2);
      transform: scale(2);
  -ms-transform-origin: 50% 50%;
      transform-origin: 50% 50%;
  z-index: 0;
}

.ms-Icon--circle.ms-Icon--star:before {
  top: -2%;
  left: 1%;
}

.ms-Icon--circle.ms-Icon--person:before {
  top: -2%;
  left: -3%;
}

.ms-Icon--circle.ms-Icon--alert:before {
  top: -4%;
}

.ms-Icon--circle.ms-Icon--mailOpen:before {
  top: -5%;
}

.ms-Icon--circle.ms-Icon--people:before {
  top: -4%;
  left: -7%;
}

.ms-Icon--circle.ms-Icon--bell:before {
  top: -3%;
}

.ms-Icon--circle.ms-Icon--scheduling:before {
  top: -3%;
  left: 6%;
}

.ms-Icon--circle.ms-Icon--documents:before {
  top: -1%;


assert(CurRC && "Invalid initial register class");
  if (unsigned SubIdx = MO.getSubReg()) {
    if (OpRC)
      CurRC = TRI->getMatchingSuperRegClass(CurRC, OpRC, SubIdx);
    else
      CurRC = TRI->getSubClassWithSubReg(CurRC, SubIdx);
  } else if (OpRC)
    CurRC = TRI->getCommonSubClass(CurRC, OpRC);
  return CurRC;
}

/// Return the number of instructions inside the MI bundle, not counting the
/// header instruction.
unsigned MachineInstr::getBundleSize() const {
  MachineBasicBlock::const_instr_iterator I = getIterator();
  unsigned Size = 0;
  while (I->isBundledWithSucc()) {
    ++Size;
    ++I;
  }
  return Size;
}

/// Returns true if the MachineInstr has an implicit-use operand of exactly
/// the given register (not considering sub/super-registers).
bool MachineInstr::hasRegisterImplicitUseOperand(unsigned Reg) const {
  for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
    const MachineOperand &MO = getOperand(i);
    if (MO.isReg() && MO.isUse() && MO.isImplicit() && MO.getReg() == Reg)
      return true;
  }
  return false;
}

/// findRegisterUseOperandIdx() - Returns the MachineOperand that is a use of
/// the specific register or -1 if it is not found. It further tightens
/// the search criteria to a use that kills the register if isKill is true.
int MachineInstr::findRegisterUseOperandIdx(
    unsigned Reg, bool isKill, const TargetRegisterInfo *TRI) const {
  for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
    const MachineOperand &MO = getOperand(i);
    if (!MO.isReg() || !MO.isUse())
      continue;
    unsigned MOReg = MO.getReg();
    if (!MOReg)
      continue;
    if (MOReg == Reg || (TRI && TargetRegisterInfo::isPhysicalRegister(MOReg) &&
                         TargetRegisterInfo::isPhysicalRegister(Reg) &&
                         TRI->isSubRegister(MOReg, Reg)))
      if (!isKill || MO.isKill())
        return i;
  }
  return -1;
}

/// readsWritesVirtualRegister - Return a pair of bools (reads, writes)
/// indicating if this instruction reads or writes Reg. This also considers
/// partial defines.
std::pair<bool,bool>
MachineInstr::readsWritesVirtualRegister(unsigned Reg,
                                         SmallVectorImpl<unsigned> *Ops) const {
  bool PartDef = false; // Partial redefine.
  bool FullDef = false; // Full define.
  bool Use = false;

  for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
    const MachineOperand &MO = getOperand(i);
    if (!MO.isReg() || MO.getReg() != Reg)
      continue;
    if (Ops)
      Ops->push_back(i);
    if (MO.isUse())
      Use |= !MO.isUndef();
    else if (MO.getSubReg() && !MO.isUndef())
      // A partial def undef doesn't count as reading the register.
      PartDef = true;
    else
      FullDef = true;
  }
  // A partial redefine uses Reg unless there is also a full define.
  return std::make_pair(Use || (PartDef && !FullDef), PartDef || FullDef);
}

/// findRegisterDefOperandIdx() - Returns the operand index that is a def of
/// the specified register or -1 if it is not found. If isDead is true, defs
/// that are not dead are skipped. If TargetRegisterInfo is non-null, then it
/// also checks if there is a def of a super-register.
int
MachineInstr::findRegisterDefOperandIdx


eters.
// [#next-free-field: 10]
type FilterChain struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// The criteria to use when matching a connection to this filter chain.
	FilterChainMatch *FilterChainMatch `protobuf:"bytes,1,opt,name=filter_chain_match,json=filterChainMatch,proto3" json:"filter_chain_match,omitempty"`
	// A list of individual network filters that make up the filter chain for
	// connections established with the listener. Order matters as the filters are
	// processed sequentially as connection events happen. Note: If the filter
	// list is empty, the connection will close by default.
	//
	// For QUIC listeners, network filters other than HTTP Connection Manager (HCM)
	// can be created, but due to differences in the connection implementation compared
	// to TCP, the onData() method will never be called. Therefore, network filters
	// for QUIC listeners should only expect to do work at the start of a new connection
	// (i.e. in onNewConnection()). HCM must be the last (or only) filter in the chain.
	Filters []*Filter `protobuf:"bytes,3,rep,name=filters,proto3" json:"filters,omitempty"`
	// Whether the listener should expect a PROXY protocol V1 header on new
	// connections. If this option is enabled, the listener will assume that that
	// remote address of the connection is the one specified in the header. Some
	// load balancers including the AWS ELB support this option. If the option is
	// absent or set to false, Envoy will use the physical peer address of the
	// connection as the remote address.
	//
	// This field is deprecated. Add a
	// :ref:`PROXY protocol listener filter <config_listener_filters_proxy_protocol>`
	// explicitly instead.
	//
	// Deprecated: Marked as deprecated in envoy/config/listener/v3/listener_components.proto.
	UseProxyProto *wrapperspb.BoolValue `protobuf:"bytes,4,opt,name=use_proxy_proto,json=useProxyProto,proto3" json:"use_proxy_proto,omitempty"`
	// Filter chain metadata.
	Metadata *v3.Metadata `protobuf:"bytes,5,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// Optional custom transport socket implementation to use for downstream connections.
	// To setup TLS, set a transport socket with name “envoy.transport_sockets.tls“ and
	// :ref:`DownstreamTlsContext <envoy_v3_api_msg_extensions.transport_sockets.tls.v3.DownstreamTlsContext>` in the “typed_config“.
	// If no transport socket configuration is specified, new connections
	// will be set up with plaintext.
	// [#extension-category: envoy.transport_sockets.downstream]
	TransportSocket *v3.TransportSocket `protobuf:"bytes,6,opt,name=transport_socket,json=transportSocket,proto3" json:"transport_socket,omitempty"`
	// If present and nonzero, the amount of time to allow incoming connections to complete any
	// transport socket negotiations. If this expires before the transport reports connection
	// establishment, the connection is summarily closed.
	TransportSocketConnectTimeout *durationpb.Duration `protobuf:"bytes,9,opt,name=transport_socket_connect_timeout,json=transportSocketConnectTimeout,proto3" json:"transport_socket_connect_timeout,omitempty"`
	// The unique name (or empty) by which this filter chain is known.
	// Note: :ref:`filter_chain_matcher
	// <envoy_v3_api_field_


, r6, r7, r8, r9, r10, fp, sp, pc}
.L663:
	mov	r0, #2
.L664:
	movw	r6, #42004
	add	r8, r7, #11141120
	movt	r6, 169
	add	r6, r7, r6
	add	r8, r8, #12288
	add	r5, r7, #256
	ldr	r2, [r6, #4]!
	mov	lr, r7
	mov	r4, #0
	mov	r9, #1
	cmp	r2, #0
	beq	.L666
.L686:
	ldr	r10, [lr, #256]
	cmp	r10, #0
	bne	.L680
	mov	ip, r5
	mov	r3, r10
	b	.L668
.L669:
	ldr	r1, [ip, #4]!
	cmp	r1, #0
	bne	.L671
.L668:
	add	r3, r3, #1
	cmp	r3, r2
	bne	.L669
	ldr	r3, [r7, #224]
	ldr	r3, [r3, #12]
	cmp	r3, #2
	bne	.L675
	ldr	r1, [r8, #3416]
	add	r1, r1, #696
.L671:
	mov	ip, r5
	mov	r3, #0
	b	.L677
.L673:
	ldr	r10, [ip, #4]!
.L677:
	add	r3, r3, #1
	cmp	r10, #0
	streq	r1, [ip]
	cmp	r3, r2
	bne	.L673
.L674:
	add	r4, r4, #1
	add	r5, r5, #132
	cmp	r0, r4
	add	lr, lr, #132
	bls	.L679
	ldr	r2, [r6, #4]!
	cmp	r2, #0
	bne	.L686
.L666:
	ldr	r3, [r7, #224]
	ldr	r3, [r3, #12]
	cmp	r3, #2
	bne	.L675
	str	r9, [r6]
	ldr	r3, [r8, #3416]
	add	r3, r3, #696
	str	r3, [lr, #256]
	b	.L674
.L680:
	mov	r1, r10
	b	.L671
.L678:
	mov	r0, #1
	b	.L664
	UNWIND(.fnend)
	.size	MVC_RepairList, .-MVC_RepairList
	.align	2
	.global	MVC_GetShortTermPicPoint
	.type	MVC_GetShortTermPicPoint, %function
MVC_GetShortTermPicPoint:
	UNWIND(.fnstart)
	@ args = 0, pretend = 0, frame = 0
	@ frame_needed = 1, uses_anonymous_args = 0
	UNWIND(.movsp ip)
	mov	ip, sp
	stmfd	sp!, {r4, r5, fp, ip, lr, pc}
	UNWIND(.pad #4)
	UNWIND(.save {r4, r5, fp, ip, lr})
	UNWIND(.setfp fp, ip, #-4)
	sub	fp, ip, #4
	add	r3, r0, #11075584
	add	r2, r3, #40960
	ldrb	r4, [r2, #1001]	@ zero_extendqisi2
	cmp	r4, #0
	beq	.L688
	ldrb	r2, [r


this[ExtensionKey] = value; }
        }

        [ConfigurationProperty(MemeTypeKey, IsKey = true, IsRequired = true)]
        public string MimeType
        {
            get { return this[MemeTypeKey].ToString(); }
            set { this[MemeTypeKey] = value; }
        }

        [ConfigurationProperty(TargetBlankKey, IsKey = true, IsRequired = true)]
        public bool IstargetBlank
        {
            get { return Convert.ToBoolean(this[TargetBlankKey]); }
            set { this[TargetBlankKey] = value; }
        }
    }
}


px%7D46.875%25%7Bcy:20px;rx:4px;ry:4px%7D50%25%7Banimation-timing-function:cubic-bezier(0.33,.66,.66,1);cy:20.5px;rx:4.8px;ry:3px%7D53.125%25%7Brx:4px;ry:4px%7D100%25%7Bcy:5px%7D%7D%3C/style%3E%3Cellipse class='spinner_rXNP' cx='12' cy='5' rx='4' ry='4'/%3E%3C/svg%3E");
}
.loading-bars {
  mask-image: url("data:image/svg+xml,%0A%3Csvg width='24' height='24' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'%3E%3Cstyle%3E.spinner_hzlK%7Banimation:spinner_vc4H .8s linear infinite;animation-delay:-.8s%7D.spinner_koGT%7Banimation-delay:-.65s%7D.spinner_YF1u%7Banimation-delay:-.5s%7D@keyframes spinner_vc4H%7B0%25%7By:1px;height:22px%7D93.75%25%7By:5px;height:14px;opacity:.2%7D%7D%3C/style%3E%3Crect class='spinner_hzlK' x='1' y='1' width='6' height='22'/%3E%3Crect class='spinner_hzlK spinner_koGT' x='9' y='1' width='6' height='22'/%3E%3Crect class='spinner_hzlK spinner_YF1u' x='17' y='1' width='6' height='22'/%3E%3C/svg%3E");
}
.loading-infinity {
  mask-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' style='shape-rendering: auto;' width='200px' height='200px' viewBox='0 0 100 100' preserveAspectRatio='xMidYMid'%3E%3Cpath fill='none' stroke='%230a0a0a' stroke-width='10' stroke-dasharray='205.271142578125 51.317785644531256' d='M24.3 30C11.4 30 5 43.3 5 50s6.4 20 19.3 20c19.3 0 32.1-40 51.4-40 C88.6 30 95 43.3 95 50s-6.4 20-19.3 20C56.4 70 43.6 30 24.3 30z' stroke-linecap='round' style='transform:scale(0.8);transform-origin:50px 50px'%3E%3Canimate attributeName='stroke-dashoffset' repeatCount='indefinite' dur='2s' keyTimes='0;1' values='0;256.58892822265625'%3E%3C/animate%3E%3C/path%3E%3C/svg%3E");
}
.loading-xs {
  width: 1rem;
}
.loading-sm {
  width: 1.25rem;
}
.loading-md {
  width: 1.5rem;
}
.loading-lg {
  width: 2.5rem;
}
.mask-squircle {
    mask-image: url("data:image/svg+xml,%3csvg width='200' height='200' xmlns='http://www.w3.org/2000/svg'%3e%3cpath d='M100 0C20 0 0 20 0 100s20 100 100 100 100-20 100-100S180 0 100 0Z'/%3e%3c/svg%3e");
  }
  .mask-decagon {
    mask-image: url("data:image/svg+xml,%3csv


.syntax unified
        .type   fixedpoint_radix4_fft_ref, %function
        .global fixedpoint_radix4_fft_ref

        inA .req r0
        pW0 .req r1 // Use the same twiddle data for TESTING ONLY
        sz  .req r2

        inB .req r3
        inC .req r4
        inD .req r5

        pW1 .req r6
        pW2 .req r7
        pW3 .req r8

        // NOTE:
        // We deliberately leave some aliases undefined
        // SLOTHY will fill them in as part of a 'dry-run'
        // merely concretizing ref registers, but not
        // yet reordering.

        .text
        .align 4
fixedpoint_radix4_fft_ref:
        push {r4-r12,lr}
        vpush {d0-d15}

        add inB, inA, sz
        add inC, inB, sz
        add inD, inC, sz

        add pW1, pw0, sz
        add pW2, pW1, sz
        add pW3, pW2, sz

        lsr lr, sz, #4
        wls lr, lr, end

fixedpoint_radix4_fft_loop_start:
        vldrw.s32     q<vA>,   [inA]
        vldrw.s32     q<vC>,   [inC]
        vldrw.s32     q<vB>,   [inB]
        vldrw.s32     q<vD>,   [inD


 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.

#include <exception>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>

#include "CLI11.hpp"

#include "deferred_gdal_writer.h"
#include "feature_sequential_processor.h"
#include "gdal_dataset_wrapper.h"
#include "gdal_raster_wrapper.h"
#include "gdal_writer.h"
#include "operation.h"
#include "processor.h"
#include "raster_sequential_processor.h"
#include "utils.h"
#include "utils_cli.h"
#include "version.h"
#include <ogr_srs_api.h>

#ifdef EE_PARALLEL
#include "raster_parallel_processor.h"
#endif

using exactextract::GDALDatasetWrapper;
using exactextract::GDALRasterWrapper;
using exactextract::Operation;

static GDALDatasetWrapper
load_dataset(const std::string& descriptor,
             const std::vector<std::string>& include_cols,
             const std::string& src_id_name,
             const std::string& dst_id_name,
             const std::string& dst_id_type);

static void
check_crs_consistent(const GDALDatasetWrapper& features, const std::vector<std::unique_ptr<exactextract::RasterSource>>& rasters, const std::vector<std::unique_ptr<exactextract::RasterSource>>& weights);

int
main(int argc, char** argv)
{
    CLI::App app{ "Zonal statistics using exactextract: version " + exactextract::version() };

    std::string poly_descriptor, src_id_name, output_filename, strategy, dst_id_type, dst_id_name;
    std::vector<std::string> stats;
    std::vector<std::string> raster_descriptors;
    std::vector<std::string> weight_descriptors;
    std::vector<std::string> include_cols;
    size_t max_cells_in_memory = 30;
    size_t threads = 4;

    bool progress = false;
    bool nested_output = false;
    bool include_geom = false;
    double grid_compat_tol = std::numeric_limits<double>::quiet_NaN();

    app.add_option("-p,--polygons", poly_descriptor, "polygon dataset")->required(true);
    app.add_option("-r,--raster", raster_descriptors, "raster dataset")->required(true);
    app.add_option("-w,--weights", weight_descriptors, "weighting dataset")->required(false);
    app.add_option("-f,--fid", src_id_name, "id from polygon dataset to retain in output")->required(false);
    app.add_option("-o,--output", output_filename, "output filename")->required(true);
    app.add_option("-s,--stat", stats, "statistics")->required(false)->expected(-1);
    app.add_option("--max-cells", max_cells_in_memory, "maximum number of raster cells to read in memory at once, in millions")->required(false)->default_val("30");
    app.add_option("--strategy", strategy, "processing strategy")->required(false)->default_val("feature-sequential");
    app.add_option("--threads", threads, "maximum number of parallel items that can processed at one time, default 4")->required(false


bNodesAft.setBounds(350+IntentionalAttackGraphBefPanel.WIDTH+170+100, 20, 200, 50);

		jtfNodesAft = new JTextField();
		jtfNodesAft.setEditable(false);
		jtfNodesAft.setFont(new Font("Times",1 , 15));
		jtfNodesAft.setBorder(null);
		jtfNodesAft.setBounds(350+IntentionalAttackGraphBefPanel.WIDTH+170+270, 20, 40, 50);

		jlbEdgesAft = new JLabel("边数: ");
		jlbEdgesAft.setFont(new Font("Times", 1, 15));
		jlbEdgesAft.setBounds(350+IntentionalAttackGraphBefPanel.WIDTH+170+100, 60, 200, 50);

		jtfEdgesAft = new JTextField();
		jtfEdgesAft.setEditable(false);
		jtfEdgesAft.setFont(new Font("Times", 1, 15));
		jtfEdgesAft.setBorder(null);
		jtfEdgesAft.setBounds(350+IntentionalAttackGraphBefPanel.WIDTH+170+270, 60, 40, 50);

		jbtAttAftDeg = new JButton("????????");
		jbtAttAftDeg.setFont(new Font("Times", 1, 15));
		jbtAttAftDeg.setBounds(350+IntentionalAttackGraphBefPanel.WIDTH+170+100, 180, 200, 40);

		jbtReady = new JButton("准备攻击");
		jbtReady.setFont(new Font("Times", 1, 20));
		jbtReady.setBounds(30, 180, 200, 30);

		jbtStart = new JButton("开始攻击");
		jbtStart.setFont(new Font("Times", 1, 20));
		jbtStart.setBounds(30, 220, 200, 30);

		jbtReset = new JButton("回到开始");
		jbtReset.setFont(new Font("Times", 1, 20));
		jbtReset.setBounds(30, 260, 200, 30);

		jlbOr = new JLabel("输入或选择最大度数的节点:");
		jlbOr.setFont(new Font("Times", 1, 15));
		jlbOr.setBounds(10, 70, 200, 30);

		input = new JTextField();
		input.setFont(new Font("Times", 1, 15));
		input.setBounds(10, 110, 50, 30);

		jbtMaxDeg = new JButton("最大度");
		jbtMaxDeg.setFont(new Font("Times", 1, 13));
		jbtMaxDeg.setBounds(60, 110, 85, 30);

		jbtMaxCore = new JButton("最大coreness");
		jbtMaxCore.setFont(new Font("Times",1, 13));
		jbtMaxCore.setBounds(145, 110, 125, 30);

		jbtMaxNodeBet = new JButton("最大node-betweenness");
		jbtMaxNodeBet.setFont(new Font("Times", 1, 13));
		jbtMaxNodeBet.setBounds(60, 140, 210, 30);
		jbtMaxNodeBet.setEnabled(false);

		this.add(jlbNodes);
		this.add(jtfNodes);
		this.add(jlbedges);
		this.add(jtfEdges);
		this.add(jlbClusBef);
		this.add(jtfClusBef);
		this.add(jlbConnBef);
		this.add(jtfConnBef);
		this.add(jlbDegBef);
		this.add(jtfDegBef);
		this.add(jlbPathBef);
		this.add(jtfPathBef);
		this.add(jlbSizeBef);
		this.add(jtfSizeBef);
		this.add(jlbClusAft);
		this.add(jtfClusAft);
		this.add(jlbConnAft);
		this.add(j


ntext));
          }
        }
      }
    }
  }

  return items;

  fn get_conditional_blank_line(range: &Range, context: &mut Context) -> PrintItems {
    let mut items = PrintItems::new();
    if !context.is_in_list() || utils::has_leading_blankline(range.start, context.file_text) {
      items.push_signal(Signal::NewLine);
    }
    items.push_signal(Signal::NewLine);
    items
  }
}

fn gen_heading(heading: &Heading, context: &mut Context) -> PrintItems {
  let mut items = PrintItems::new();

  items.push_string(format!("{} ", "#".repeat(heading.level as usize)));
  items.extend(with_no_new_lines(gen_nodes(&heading.children, context)));

  items
}

fn gen_paragraph(paragraph: &Paragraph, context: &mut Context) -> PrintItems {
  gen_nodes(&paragraph.children, context)
}

fn gen_block_quote(block_quote: &BlockQuote, context: &mut Context) -> PrintItems {
  let mut items = PrintItems::new();

  // add a > for any string that is on the start of a line
  for print_item in gen_nodes(&block_quote.children, context).iter() {
    match print_item {
      PrintItem::String(text) => {
        items.push_condition(if_true(
          "angleBracketIfStartOfLine",
          |context| Some(context.writer_info.is_start_of_line()),
          "> ".into(),
        ));
        items.push_item(PrintItem::String(text));
      }
      PrintItem::Signal(Signal::NewLine) => {
        items.push_condition(if_true(
          "angleBracketIfStartOfLine",
          |context| Some(context.writer_info.is_start_of_line()),
          ">".into(),
        ));
        items.push_signal(Signal::NewLine);
      }
      _ => items.push_item(print_item),
    }
  }

  items
}

fn gen_code_block(code_block: &CodeBlock, context: &mut Context) -> PrintItems {
  let mut items = PrintItems::new();
  let code_text = get_code_text(code_block, context);
  let code_text = utils::unindent(&code_text);
  let backtick_text = "`".repeat(get_backtick_count(&code_text));
  let indent_level = if code_block.is_fenced { 0 } else { 4 };

  // header
  if code_block.is_fenced {
    items.push_string(backtick_text.clone());
    if let Some(tag) = &code_block.tag {
      items.push_str(tag);
    }
    items.push_signal(Signal::NewLine);
  }

  // body
  if !code_text.is_empty() {
    items.extend(ir_helpers::gen_from_string(&code_text));
  }

  // footer
  if code_block.is_fenced {
    if !code_text.is_empty() {
      items.push_signal(Signal::NewLine);
    }
    items.push_string(backtick_text);
  }

  return with_indent_times(items, indent_level);

  fn get_code_text<'a>(code_block: &'a CodeBlock, context: &mut Context) -> Cow<'a, str> {
    let code = &code_block.code;
    if code.trim().is_empty() {
      return Cow::Borrowed("");
    }
    let start_pos = get_code_block_start_pos(&code);
    let code = code[start_pos..].trim_end();
    if let Some(tag) = &code_block.tag {
      if let Ok(text) = context.format_text(tag, code) {
        return Cow::Owned(text.trim_end().to_string());
      }
    }
    Cow::Borrowed(code)
  }

  fn get_code_block_start_pos(text: &str) -> usize {
    let mut start_pos = 0;
    for (i, c) in text.char_indices() {
      if c == '\n' {
        start_pos = i + 1;
      } else


יקה",
        "AR": "ארגנטינה",
        "AS": "סמואה האמריקנית",
        "AT": "אוסטריה",
        "AU": "אוסטרליה",
        "AW": "ארובה",
        "AX": "איי אולנד",
        "AZ": "אזרבייג׳ן",
        "BA": "בוסניה והרצגובינה",
        "BB": "ברבדוס",
        "BD": "בנגלדש",
        "BE": "בלגיה",
        "BF": "בורקינה פאסו",
        "BG": "בולגריה",
        "BH": "בחריין",
        "BI": "בורונדי",
        "BJ": "בנין",
        "BL": "סנט ברתולומיאו",
        "BM": "ברמודה",
        "BN": "ברוניי",
        "BO": "בוליביה",
        "BQ": "האיים הקריביים ההולנדיים",
        "BR": "ברזיל",
        "BS": "איי בהאמה",
        "BT": "בהוטן",
        "BV": "האי בובה",
        "BW": "בוצוואנה",
        "BY": "בלארוס",
        "BZ": "בליז",
        "CA": "קנדה",
        "CC": "איי קוקוס (קילינג)",
        "CD": "קונגו - קינשאסה",
        "CF": "הרפובליקה המרכז-אפריקאית",
        "CG": "קונגו - ברזאויל",
        "CH": "שווייץ",
        "CI": "חוף השנהב",
        "CK": "איי קוק",
        "CL": "צ׳ילה",
        "CM": "קמרון",
        "CN": "סין",
        "CO": "קולומביה",
        "CP": "האי קליפרטון",
        "CR": "קוסטה ריקה",
        "CU": "קובה",
        "CV": "כף ורדה",
        "CW": "קוראסאו",
        "CX": "אי חג המולד",
        "CY": "קפריסין",
        "CZ": "צ׳כיה",
        "DE": "גרמניה",
        "DG": "דייגו גרסיה",
        "DJ": "ג׳יבוטי",
        "DK": "דנמרק",
        "DM": "דומיניקה",
        "DO": "הרפובליקה הדומיניקנית",
        "DZ": "אלג׳יריה",
        "EA": "סאוטה ומלייה",
        "EC": "אקוודור",
        "EE": "אסטוניה",
        "EG": "מצרים",
        "EH": "סהרה המערבית",
        "ER": "אריתריאה",
        "ES": "ספרד",
        "ET": "אתיופיה",
        "EU": "האיחוד האירופי",
        "EZ": "גוש האירו",
        "FI": "


	name = L["Text"],
			desc = FormatDesc("%keystone%", L["Keystone"]),
			width = 2,
		},
		useDefaultText = {
			order = 6,
			type = "execute",
			func = function(info)
				E.db.WT.announcement.keystone.text = P.announcement.keystone.text
			end,
			name = L["Default Text"],
		},
		channel = {
			order = 7,
			name = L["Channel"],
			type = "group",
			inline = true,
			get = function(info)
				return E.db.WT.announcement.keystone[info[#info - 1]][info[#info]]
			end,
			set = function(info, value)
				E.db.WT.announcement.keystone[info[#info - 1]][info[#info]] = value
			end,
			args = {
				party = {
					order = 1,
					name = L["In Party"],
					type = "select",
					values = {
						NONE = L["None"],
						SELF = L["Self (Chat Frame)"],
						EMOTE = L["Emote"],
						PARTY = L["Party"],
						YELL = L["Yell"],
						SAY = L["Say"],
					},
				},
			},
		},
	},
}

options.general = {
	order = 14,
	type = "group",
	name = L["General"],
	get = function(info)
		return E.db.WT.announcement[info[#info]]
	end,
	set = function(info, value)
		E.db.WT.announcement[info[#info]] = value
	end,
	args = {
		emoteFormat = {
			order = 1,
			type = "input",
			name = L["Emote Format"],
			desc = L["The text template used in emote channel."]
				.. "\n"
				.. format(L["Default is %s."], W.Utilities.Color.StringByTemplate(": %s", "blue-500")),
			width = 2,
		},
		betterAlign = {
			order = 2,
			type = "description",
			fontSize = "small",
			name = " ",
			width = "full",
		},
		sameMessageInterval = {
			order = 3,
			type = "range",
			name = L["Same Message Interval"],
			desc = L["Time interval between sending same messages measured in seconds."]
				.. " "
				.. L["Set to 0 to disable."],
			min = 0,
			max = 3600,
			step = 1,
			width = 1.5,
		},
	},
}


을 제로 맵으로 초기화한다.\n' +
      '\n' +
      '백본 네트워크가 잡음이 많은 프레임들을 잡음제거하기 위해 여러 번 반복될 수 있지만, 타겟 이미지 및 모션 프레임들은 연결되고 참조넷에 한 번만 입력된다는 것에 유의해야 한다. 결과적으로, 추출된 특징들은 프로세스 전반에 걸쳐 재사용되어, 추론 동안 계산 시간의 실질적인 증가가 없음을 보장한다.\n' +
      '\n' +
      '####4.2.2 페이스 로케이터 및 스피드 레이어.\n' +
      '\n' +
      '시간 모듈들은 생성된 프레임들의 연속성과 비디오 클립들 사이의 끊김 없는 전이를 보장할 수 있지만, 독립적인 생성 프로세스로 인해 생성된 캐릭터의 모션의 일관성과 안정성을 보장하기에는 불충분하다. 기존의 연구들은 골격[9], 블렌드쉐이프[33], 또는 3DMM[28]과 같은 캐릭터 동작을 제어하기 위해 일부 신호를 사용하지만, 이러한 제어 신호를 사용하는 것은 제한된 자유도로 인해 생동감 있는 표정 및 동작을 생성하는 데 좋지 않을 수 있으며, 훈련 단계 동안 부적절한 라벨링은 얼굴 동역학의 전체 범위를 포착하기에 불충분하다. 또한, 동일한 제어 신호는 서로 다른 문자 간의 불일치를 초래하여 개별 뉘앙스를 설명하지 못할 수 있다. 제어 신호들의 생성을 가능하게 하는 것은 실행 가능한 접근법(28)일 수 있지만, 실제와 같은 동작을 생성하는 것은 여전히 과제로 남아 있다. 따라서, 우리는 "약한" 제어 신호 접근법을 선택한다.\n' +
      '\n' +
      '구체적으로, 그림 2와 같이 비디오 클립의 얼굴


 darken($success-a0, 10%);
  }

  &:disabled {
    color: withAlpha($neutral-a0, 0.5);
    background-color: withAlpha($success-a0, 0.5);
  }
}

QMessageBox {
  QPushButton {
    padding-left: 10px;
    padding-right: 10px;
  }
}
.content-block {
    padding-top: 20px;
    padding-bottom: 10px;
    margin-left: 30px;
    margin-right: 30px;
  }

  @media(min-width: 900px) {
  .content-block {
    margin-left: 50px;
    margin-right: 50px;
  }
  }

  @media (min-width: 1200px) {
  .content-block {
    max-width: 1100px;
    margin-left: auto;
    margin-right: auto;
  }
  }

  .hero-banner {
    position: relative;
    background-color: rgb(237,243,249);
    display: flex;
    justify-content: center;
  }

  .hero-banner h1 {
    color: #39729E;
    font-size: 2.5rem;
  }

  .hero-banner .hero-image {
    position: absolute;
    display: none;
    height: auto;
  }

  @media (min-width: 1000px) {
  .hero-banner .hero-image {
    display: initial;
    width: 270px;
  }
  }

  @media (min-width: 1200px) {
  .hero-banner .hero-image {
    width: 340px;
  }
  }

  @media (min-width: 1400px) {
  .hero-banner .hero-image {
    width: 440px;
  }
  }

  .hero-banner .hero-image p {
    margin-bottom: 0;
  }

  .hero-banner .hero-image-left {
    left: 0;
    bottom: 0;
  }

  .hero-banner .hero-image-right {
    right: 0;
    bottom: 0;
  }

  .hero-banner .content-block {
    max-width: 600px;
    z-index: 2;
  }

  .hero-banner a {
    text-decoration: none;
  }

  .hero-banner h3 {
    margin-top: 1.3rem;
    margin-bottom: 1.3rem;
  }

  .hero-banner h4 {
    margin-top: 0;
  }

  .hero-banner a[role="button"] {
    margin-right: 17px;
    margin-top: 0.6rem;
    margin-bottom: 1.6rem;
  }

  .hero-banner #btn-guide {
    background-color: #959595 !important;
    border: none;
  }

  .hero-banner ul {
    padding-inline-start: 21px;
    font-size: 1.1rem;
  }

  .hero-banner ul li {
    padding-bottom: 0.4rem;
  }

  .alt-background {
    background-color: rgb(247,249,251);
    border-top: 1px solid #dee2e6;
    border-bottom: 1px solid #dee2e6;
  }

  .hello-quarto {
    padding-bottom: 1rem;
  }

  @media (min-width: 600px) {
  .hello-quarto-banner {
    display: inline-flex;
    align-content: center;
    justify-content: center;
  }

  .hello-quarto-banner h1 {
    margin-right: 40px;
  }

  .hello-quarto-banner ul {

  }
  }

  .hello-quarto-banner .nav-pills .nav-link.active, .nav-pills .show>.nav-link {
    border: none;
    border-bottom: 2px solid #39729E !important;
    color: #39729E;


299, 277, 309, 576];

// checkAllNumbers(testInput, 5); //?
checkAllNumbers(data, 25); //?

// Part 2: Find the "encryption weakness"
// 1) Find the range of numbers in the input array that add up to the anomaly from Part 1.
// 2) Of that group, find the minimum and maximum numbers.
// 3) Add those two numbers together for the result.

function contigSumInArray(target: number, blockLength: number, input: Array<number>) {
  if (blockLength > input.length) throw('Attempting to sum an oversized block, you blockhead.');
  let lowIndex = 0;
  let highIndex = blockLength - 1;
  let sum: number = input.slice(lowIndex, highIndex + 1).reduce((a, b) => a + b, 0);
  if (sum === target) return [lowIndex, highIndex];

  while (highIndex < input.length)
  {
    sum -= input[lowIndex];
    lowIndex++;
    highIndex++;
    sum += input[highIndex];
    if (sum === target) {
      blockLength; //?
      lowIndex
      highIndex

      let resultArr = input.slice(lowIndex, highIndex + 1)
      let low = Math.min(...resultArr);
      let high = Math.max(...resultArr);

      console.log(`${low} + ${high} = ${low + high}`);
      return [low, high];
    }
  }

  return [null, null];
}

function findContiguousSet (target: number, input: Array<number>): Array<number> {
  const targetIndex = input.indexOf(target);

  for (let blockSize = 2; blockSize < input.length; blockSize++) {
    let result = contigSumInArray(target, blockSize, input);
    if (result[0] !== null) return result;
  }

  return [null, null];
}

// findContiguousSet(127, testInput); //?
// contigSumInArray(127, 4, testInput); //?
// findContiguousSet(51, data); //?
findContiguousSet(373803594, data); //?
function sumAllPrimes(num: number): number {

}

console.log(sumAllPrimes(10));
console.log(sumAllPrimes(977));import * as ko from "knockout";

class Meal {

    mealName: string
    price: number

    constructor(mealName: string, price: number) {
        this.mealName = mealName
        this.price = price
    }

}

class SeatReservation {

    name: string
    meal: KnockoutObservable<Meal>

    formattedPrice: KnockoutComputed<string>

    constructor(name: string, initialMeal: Meal) {
        this.name = name;
        this.meal = ko.observable(initialMeal);

        this.formattedPrice = ko.computed(function () {
            let price = this.meal().price
            return price ? "$" + price.toFixed(2) : "None";
        }, this);

    }

}

class AppViewModel {

    constructor() {

    }

    availableMeals: [Meal] = [
        new Meal("Standard (sandwich)", 0),
        new Meal("Premium (lobster)", 34.95),
        new Meal("Coquilles Saint-Jacques", 70.00)
    ]

    seats: KnockoutObservableArray<SeatReservation> = ko.observableArray([
        new SeatReservation("Steve", this.availableMeals[0]),
        new SeatReservation("Bert", this.availableMeals[2])
    ]);

    totalSurcharge: KnockoutComputed<number> = ko.computed(function () {
        let total = 0;
        for (let seat of this.seats()) {
            total += seat.meal().price;
        }

        return total;

    }, this);

    addSeat() {
        this.seats.push(new SeatReservation("", this.availableMeals[0]));


string sText, Cockpit cockpit)
        {
            HUDPopupMessage message = new HUDPopupMessage() {
                Width = 500*cockpit.GetPixelScale(), Height = 250*cockpit.GetPixelScale(),
                TitleTextHeight = 30 * cockpit.GetPixelScale(),
                TextHeight = 20 * cockpit.GetPixelScale(),
                BackgroundColor = Colorf.Silver,
                TextColor = Colorf.VideoBlack,
                TitleText = sTitleText,
                Text = sText
            };
            message.Create();
            if ( FPlatform.IsUsingVR() )
                HUDUtil.PlaceInSphere(message, 0.5f, 0, 0);
            else
                HUDUtil.PlaceInSphere(message, 1.5f, 0, 0);
            message.Name = "popup";
            cockpit.AddUIElement(message, true);
            message.OnDismissed += (s, e) => {
                AnimatedDimiss_Cockpit(message, cockpit, true);
            };
            AnimatedShow(message);
        }

        public static void ShowToastPopupMessage(string sText, Cockpit cockpit, float heightScale = 1.0f, float textScale = 1.0f)
        {
            // [TODO] should size based on VR or not-VR...for VR use visual radius?

            HUDPopupMessage message = new HUDPopupMessage() {
                Width = 500*cockpit.GetPixelScale(), Height = heightScale*150*cockpit.GetPixelScale(),
                TextHeight = textScale * 50 * cockpit.GetPixelScale(),
                BackgroundColor = Colorf.DarkYellow,
                TextColor = Colorf.VideoBlack,
                Text = sText
            };
            message.Create();
            HUDUtil.PlaceInSphere(message, 1.0f, 30, -30);
            message.Name = "popup";
            cockpit.AddUIElement(message, true);
            message.OnDismissed += (s, e) => {
                AnimatedDimiss_Cockpit(message, cockpit, true);
            };
            AnimatedShow(message, 0.5f);
        }

        public static void AnimatedShow(HUDStandardItem hudItem, float fDuration = 0.25f, Action OnCompleted = null)
        {
            AnimatedDisplayHUDItem anim = hudItem.RootGameObject.AddComponent<AnimatedDisplayHUDItem>();
            if (OnCompleted != null) {
                anim.CompleteCallback += () => {
                    OnCompleted();
                };
            }
            anim.Play(hudItem, fDuration);
        }

        public static void AnimatedDimiss_Cockpit(HUDStandardItem hudItem, Cockpit cockpit, bool bDestroy, float fDuration = 0.25f)
        {
            AnimatedDismissHUDItem anim = hudItem.RootGameObject.AddComponent<AnimatedDismissHUDItem>();
            anim.CompleteCallback += () => {
                if ( bDestroy )
                    anim.HUDItem.ClearGameObjects(false);       // what is this line for??
                cockpit.RemoveUIElement(anim.HUDItem, bDestroy);
                if (bDestroy == false)
                    anim.HUDItem.IsVisible = false;
            };
            anim.Play(hudItem, fDuration);
        }

        public static void AnimatedShowHide_Cockpit(HUDStandardItem hudItem, Cockpit cockpit, float fShowDuration = 3.0f, float fFadeDuration = 0.25f)
        {
            AnimatedShowHideHUDItem anim = hudItem.RootGameObject.AddComponent<AnimatedShowHideHUDItem>();
            anim.CompleteCallback += () => {
                anim.HUDItem.ClearGameObjects(false);
                cockpit.RemoveUIElement(anim.HUDItem, true);
            };


        }
        return -1;
    }

    let tcss_slice = unsafe { slice::from_raw_parts(tcss, total as usize) };
    let mut result = 0;
    for tcs in tcss_slice.iter() {
        result = get_tcs_event(*tcs as usize).wake();
        if result != 0 {
            if !error.is_null() {
                unsafe { *error = Error::last_os_error().raw_os_error().unwrap_or(0); }
            }
            return -1;
        }
    }

    if !error.is_null() {
        unsafe { *error = 0; }
    }
    result as c_int
}

#[no_mangle]
pub extern "C" fn u_thread_setwait_events_ocall(error: *mut c_int,
                                                waiter_tcs: *const c_void,
                                                self_tcs: *const c_void,
                                                timeout: *const timespec) -> c_int {

    let result = u_thread_set_event_ocall(error, waiter_tcs);
    if result < 0 {
        result
    } else {
        u_thread_wait_event_ocall(error, self_tcs, timeout)
    }
}
<gh_stars>1-10
#[macro_use]
extern crate log;

use bytes::{BufMut, Bytes, BytesMut};
use gen_layouts_sys::*;

use std::fmt;

const UNICODE_ENTER: u16 = 10; // \n
const UNICODE_TAB: u16 = 9; // \t
// https://stackoverflow.com/questions/23320417/what-is-this-character-separator
const CONTROL_CHARACTER_OFFSET: u16 = 0x40;
const UNICODE_FIRST_ASCII: u16 = 0x20; // SPACE
const UNICODE_LAST_ASCII: u16 = 0x7F; // BACKSPACE
const UNICODE_DIGIT_OFFSET: usize = 48; // 0
const KEY_MASK: u16 = 0x3F; // Remove SHIFT/ALT/CTRL from keycode
/// The number of bytes in a keyboard HID packet
pub const HID_PACKET_LEN: usize = 8;
const HID_PACKET_SUFFIX: [u8; 5] = [0u8; 5];
const RELEASE_KEYS_HID_PACKET: [u8; 8] = [0u8; 8];

#[derive(Debug)]
pub enum Error {
    InvalidLayoutKey(String),
    InvalidCharacter(char),
}

#[derive(Debug)]
#[repr(u8)]
pub enum Release {
    All = 0,
    Keys = 1,
    None = 2,
}

#[derive(Debug)]
pub struct KeyMod {
    pub key: u8,
    pub modifier: u8,
    pub release: Release,
}

enum Keycode {
    ModifierKeySequence(u16, Vec<u16>),
    RegularKey(u16),
    InvalidCharacter,
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Error::InvalidLayoutKey(key) => write!(f, "No layout defined for {}", key),
            Error::InvalidCharacter(c) => write!(f, "Invalid character: '{}' or [{:?}]", c, c),
        }
    }
}

/// Get a list of the supported keyboard layouts
pub fn available_layouts() -> Vec<&'static str> {
    LAYOUT_MAP.keys().map(|k| *k).collect()
}

/// Get a list of the key and modifier pairs required to type the given string on a keyboard with
/// the specified layout.
pub fn string_to_keys_and_modifiers(layout_key: &str, string: &str) -> Result<Vec<KeyMod>, Error> {
    let layout = LAYOUT_MAP
        .get(layout_key)
        .ok_or_else(|| Error::InvalidLayoutKey(layout_key.to_string()))?;

    let mut keys_and_modifiers: Vec<KeyMod> = Vec::with_capacity(string.len());

    for c in string.chars() {
        match keycode_for_unicode(layout, c as u16) {
            Keycode::ModifierKeySequence(modifier, sequence) => {
                for keycode in


tent>pre+table,.content>blockquote+table,.content>pre+ul,.content>blockquote+ul,.content>pre+ol,.content>blockquote+ol,.content>pre+aside,.content>blockquote+aside,.content>pre+dl,.content>blockquote+dl{margin-top:28px}}.highlight .c,.highlight .cm,.highlight .c1,.highlight .cs{color:#909090}.highlight,.highlight .w{background-color:#1E2224}:root {
  --shadow-color: rgba(0, 0, 0, .2);
}

.contribute-card {
  border: 0;
  box-shadow: 0 10px 10px var(--shadow-color), 0 0 20px var(--shadow-color);
  height: 500px;
  margin: 30px 0;
  padding-top: 20px;
  transition: box-shadow 0.3s ease, transform 0.3s ease;

  &:hover {
    box-shadow: 0 15px 15px var(--shadow-color), 0 0 30px var(--shadow-color);
    transform: scale(1.05);
  }
}

.contribute-card-image {
  height: 150px;
  width: 150px;
}

.contribute-card-body {
  h3 {
    text-align: center;
  }

  ul {
    text-align: left;
  }
}

.contribute-pay-card-container {
  display: inline-block;
  height: 100px;
  margin-bottom: 40px;
  margin-left: 30px;
  margin-right: 30px;
  margin-top: 50px;
  text-align: center;
  width: 200px;

  p {
    font-weight: 550;
  }
}

.contribute-pay-card {
  border: 1.5px solid $black;
  border-radius: 8px;
  box-shadow: 3px 3px 6px $shadow-black;
  padding: 4px;
  transition: box-shadow .2s ease-in;

  &:hover {
    box-shadow: 0 9px 9px $shadow-black;
  }

  img {
    height: 70px;
    width: 160px;
    object-fit: contain;
    padding: 5px;
  }
}

.centered-paragraph {
  text-align: center;
}

//breakpoints
@media (max-width: 1199px) {
  .contribute-social-card {
    margin-bottom: 10px;
    margin-top: 10px;
  }

  .contribute-card {
    height: 100%;
  }
}

@media (min-width: 401px) and (max-width: 590px) {
  .contribute-card {
    height: 100%;
    width: 100%;
  }
}

@media (max-width: 400px) {
  .contribute-card {
    height: 100%;
    width: 100%;
  }
}
// Bootstrap theming
// Ref: https://getbootstrap.com/docs/4.0/getting-started/theming/

$black: #000000;
$white: #fff;
$primary-green: #42b983;
$secondary-green: #026e57;
$primary-red: #ff5959;
$secondary-red: #c21d1d;
$card-green: #f9fffc;
$light-green-bg: #eef7f3;
$border-light-grey: #e5e5e5;
$badge-green: #e9f9f5;
$shadow-black: #00000029;
$grey: #f8fafc;
$card-grey: #fcfcfc;
$error-red: #fae3e3;
$navbar-dark-grey: #374151;
$footer-dark-grey: #1c1c1c;
$mini-button-blue: #42b9b6;
$form-border-grey: #f2f2f2;
$border-light-grey: #e5e5e5;
$iframe-container-grey: #707070;
$project-card-grey: #fafafa;
$star-yellow: #ffb60a;
$search-yellow: #ffff00;
$shadow-grey: #d5d5d5;
$form-input-green: #9edcc0;
$form-input-focus-green: rgba(


python fallback key"
    )
    assert len(kwargs) == 0

    example_out = call_hop(*args, **kwargs)
    proxy_args = pytree.tree_map(proxy_mode.tracer.unwrap_proxy, args)  # type: ignore[union-attr]

    out_proxy = proxy_mode.tracer.create_proxy(
        "call_function", call_hop, proxy_args, {}
    )

    # extract local_map args, post-dispatch operates on GraphModules
    assert gm.meta["local_map_kwargs"]
    local_map_kwargs = gm.meta["local_map_kwargs"]

    # propagate local_map args to the call_function node
    out_proxy.node.meta["local_map_kwargs"] = local_map_kwargs
    return track_tensor_tree(
        example_out, out_proxy, constant=None, tracer=proxy_mode.tracer
    )

@local_map_hop.py_impl(ProxyTorchDispatchMode)
def proxy_mode_key(
    proxy_mode: ProxyTorchDispatchMode,
    gm: GraphModule,
    *args: Any,
    **kwargs: Any,
) -> tuple[torch.Tensor]:
    # TODO: get rid of this when we can install as a subgraph
    def call_local_map(*_args: Any, **_kwargs: Any) -> Any:
        return functools.partial(local_map_hop, gm)(*_args, **_kwargs)

    return proxy_mode_key_common(call_local_map, proxy_mode, gm, *args, **kwargs)

# Running HOP in eager with real tensors
@local_map_hop.py_impl(DispatchKey.CompositeExplicitAutograd)
def real_impl(
    gm: GraphModule,
    *args: Any,
    **kwargs: Any,
) -> tuple[torch.Tensor]:
    return gm(*args, **kwargs)


4.488 4.586-8.082 9.063-8.812.469-.07.922-.11 1.375-.125zM14 7a1.999 1.999 0 100 4 1.999 1.999 0 100-4zm7 2a1.999 1.999 0 100 4 1.999 1.999 0 100-4zM9 11a1.999 1.999 0 100 4 1.999 1.999 0 100-4zm14 5a1.999 1.999 0 100 4 1.999 1.999 0 100-4zm-4 5a1.999 1.999 0 100 4 1.999 1.999 0 100-4z"/></svg>';
  static const String palfed =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="32" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 32 32"><path fill="currentColor" d="M14 4c-.55 0-1 .45-1 1v1c-4.418 0-8 1.791-8 4H4c-1.1 0-2 .9-2 2s.9 2 2 2h1.375l1.406 11.248A2 2 0 008.766 27h14.468c1.01 0 1.86-.751 1.987-1.752L26.625 14H28c1.1 0 2-.9 2-2s-.9-2-2-2h-1c0-2.209-3.582-4-8-4V5c0-.55-.45-1-1-1h-4zm1.328 4.188c.38.035.72.318.813.78C19.804 7.844 23 9.019 23 12.622c0 3.953-3.915 7.745-7 7.014v5.084c.01.173.059.633-.24.968-.487.538-1.696.509-1.848-1.13-.208-2.253.01-10.458.07-12.305-1.09.761-2.966 2.55-2.966 3.85.01.127.019.204.029.234.01 0 .33-.139.568-.139 1.35 0 1.05 2.239-.73 2.239-1.09 0-1.883-.916-1.883-2.18 0-2.131 2.176-4.852 5.11-6.42.05-.63.152-1.117.533-1.432a.949.949 0 01.685-.216zm3.211 2.496c-.779.008-1.636.202-2.389.476a311.237 311.237 0 00-.15 6.08c.035.142.13.315.754.315 1.838 0 4.165-2.172 4.16-4.881 0-1.504-1.077-2.005-2.375-1.99z"/></svg>';
  static const String pallet =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="32" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 32 32"><path fill="currentColor" d="M6.125 5 6 5.844l-2 14V27h6v-2h12v2h6v-7.156l-2-14L25.875 5zm1.75 2h2.063l-.876 12H6.156zm4.063 0H15v12h-3.938zM17 7h3.063l.875 12H17zm5.063 0h2.062l1.719 12h-2.907zM6 21h20v4h-2v-2H8v2H6z"/></svg>';
  static const String paper_plane =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="32" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 32 32"><path fill=


ARRAYLEADERMERGE:
        subq	$18, TypeArray, $1 	# [1]
        and	$1, 62, $1 	# Strip CDR code, low bits [1]
        bne	$1, STOREARRAYLEADEREXCEPTION	# [1]
        ldq	$24, PROCESSORSTATE_STACKCACHEBASEVMA($14)	#  [0di]
        ldl	$25, PROCESSORSTATE_SCOVLIMIT($14)	# Size of the stack cache (words) [1]
/* Memory Read Internal */
G15073:
        addq	$19, $14, $3 	# [0di]
        s4addq	$3, $31, $20 	# [1]
        ldq_u	$21, 0($3)	#  [1di]
        subq	$19, $24, $1 	# Stack cache offset [1-]
        ldq	$4, PROCESSORSTATE_HEADER_MASK($14)	#  [0di]
        cmpult	$1, $25, $2 	# In range? [1-]
        ldl	$20, 0($20)	#  [0di]
        extbl	$21, $3, $21 	# [1-]
        bne	$2, G15075	# [0di]
G15074:
        lda	$3, 64	#  [1-]
        srl	$4, $21, $4 	# [1]
        srl	$3, $21, $3 	# [1]
        blbs	$4, G15077	# [1di]
G15082:
/* TagType. */
        and	$21, 63, $1 	# [1-]
        subq	$1, TypeHeaderI, $1 	# [1]
        bne	$1, STOREARRAYLEADERIOP	# [1]
        srl	$20, ArrayLeaderLengthFieldPos, $2 	# [0di]
        and	$2, ArrayLeaderLengthFieldMask, $2 	# [2]
        cmpult	$17, $2, $1 	# [1]
        beq	$1, STOREARRAYLEADERBOUNDS	# [1]
        subq	$19, $17, $17 	# [0di]
        subq	$17, 1, $17 	# [1]
/* Memory Read Internal */
G15083:
        addq	$17, $14, $5 	# [1]
        s4addq	$5, $31, $2 	# [1]
        ldq_u	$1, 0($5)	#  [1di]
        subq	$17, $24, $3 	# Stack cache offset [1-]
        ldq	$8, PROCESSORSTATE_DATAWRITE_MASK($14)	#  [0di]
        cmpult	$3, $25, $4 	# In range? [1-]
        ldl	$2, 0($2)	#  [0di]
        extbl	$1, $5, $1 	# [1-]
        bne	$4, G15085	# [0di]
G15084:
        lda	$5, 240	#  [1-]
        srl	$8, $1, $8 	# [1]
        srl	$5, $1, $5 	# [1]
        blbs	$8, G15087	# [1di]
G15093:
/* Merge cdr-code */
        and	$6, 63, $2 	# [1-]
        and	$1, 192, $1 	# [1]
        bis	$1, $2, $1 	# [1]
        addq	$17, $14, $3 	# [1]
        s4addq	$3, $31, $2 	# [1]
        ldq_u	$5, 0($3)	#  [1di]
        subq	$17, $24, $4 	# Stack c


r<
  S,
  Unpack<S>,
  Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Unpack<Unpack<S>>[K3][K4]>[K6]>
>;

export function get<T1, T2, K3 extends string, K4 extends string>(
  t1: Traversal<T1>,
  t2: Traversal<T2>,
  k3: K3,
  k4: K4,
  i5: number,
  i6: number
): <
  S extends Collection<
    T1 & Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Indexable>>>>
  >
>(
  s: S
) => Functor<
  S,
  Unpack<S>,
  Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Index<Unpack<Unpack<S>>[K3][K4]>>>
>;

export function get<T1, T2, K3 extends string, K4 extends string, T6>(
  t1: Traversal<T1>,
  t2: Traversal<T2>,
  k3: K3,
  k4: K4,
  i5: number,
  t6: Traversal<T6>
): <
  S extends Collection<
    T1 & Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>
  >
>(
  s: S
) => Functor<
  S,
  Unpack<S>,
  Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Unpack<Unpack<S>>[K3][K4]>>
>;

export function get<
  T1,
  T2,
  K3 extends string,
  K4 extends string,
  T5,
  K6 extends string
>(
  t1: Traversal<T1>,
  t2: Traversal<T2>,
  k3: K3,
  k4: K4,
  t5: Traversal<T5>,
  k6: K6
): <
  S extends Collection<
    T1 & Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>
  >
>(
  s: S
) => Functor<
  S,
  Unpack<S>,
  Functor<
    Unpack<S>,
    Unpack<Unpack<S>>,
    Functor<
      Unpack<Unpack<S>>[K3][K4],
      Unpack<Unpack<Unpack<S>>[K3][K4]>,
      Unpack<Unpack<Unpack<S>>[K3][K4]>[K6]
    >
  >
>;

export function get<T1, T2, K3 extends string, K4 extends string, T5>(
  t1: Traversal<T1>,
  t2: Traversal<T2>,
  k3: K3,
  k4: K4,
  t5: Traversal<T5>,
  i6: number
): <
  S extends Collection<
    T1 & Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>
  >
>(
  s: S
) => Functor<
  S,
  Unpack<S>,
  Functor<
    Unpack<S>,
    Unpack<Unpack<S>>,
    Functor<
      Unpack<Unpack<S>>[K3][K4],
      Unpack<Unpack<Unpack<S>>[K3][K4]>,
      Index<Unpack<Unpack<Unpack<S>>[K3][K4]>>
    >
  >
>;

export function get<T1, T2, K3 extends string, K4 extends string, T5, T6>(
  t1: Traversal<T1>,
  t2: Traversal<T2>,
  k3: K3,
  k4: K4,
  t5: Traversal<T5>,


s.
#[derive(Debug)]
pub struct FdbStreamMappedKeyValue {
    mapped_range_result_state_machine: MappedRangeResultStateMachine,
}

#[cfg(feature = "fdb-7_1")]
impl FdbStreamMappedKeyValue {
    pub(crate) fn new(
        transaction: FdbTransaction,
        begin: KeySelector,
        end: KeySelector,
        mapper: Mapper,
        options: RangeOptions,
        snapshot: bool,
    ) -> FdbStreamMappedKeyValue {
        let limit = if options.get_limit() == 0 {
            None
        } else {
            Some(options.get_limit())
        };

        // Binding tester tests for `2210` error. So, if we are
        // provided with `StreamingMode::Exact` and a `limit` of `0`,
        // we can't change it to `StreamingMode::WantAll`
        let mode = options.get_mode();

        let reverse = options.get_reverse();

        // `iteration` is only valid when mode is
        // `StreamingMode::Iterator`. It is ignored in other modes.
        let iteration = if options.get_mode() == StreamingMode::Iterator {
            Some(1)
        } else {
            None
        };

        let fdb_future_mapped_key_value_array = fdb_transaction_get_mapped_range(
            transaction.get_c_api_ptr(),
            begin.clone(),
            end.clone(),
            mapper.clone(),
            RangeOptions::new(limit.unwrap_or(0), mode, reverse),
            iteration.unwrap_or(0),
            snapshot,
        );

        let mapped_range_result_state_machine = MappedRangeResultStateMachine::new(
            transaction,
            begin,
            end,
            mapper,
            mode,
            iteration,
            reverse,
            limit,
            snapshot,
            fdb_future_mapped_key_value_array,
        );

        FdbStreamMappedKeyValue {
            mapped_range_result_state_machine,
        }
    }
}

#[cfg(feature = "fdb-7_1")]
impl Stream for FdbStreamMappedKeyValue {
    type Item = FdbResult<MappedKeyValue>;

    fn poll_next(
        mut self: Pin<&mut FdbStreamMappedKeyValue>,
        cx: &mut Context<'_>,
    ) -> Poll<Option<FdbResult<MappedKeyValue>>> {
        Pin::new(&mut self.mapped_range_result_state_machine).poll_next(cx)
    }
}

#[cfg(test)]
mod tests {
    use futures::task::AtomicWaker;
    use futures::Stream;

    use impls::impls;

    use std::future::Future;
    use std::marker::PhantomData;
    use std::ptr::NonNull;
    use std::sync::Arc;

    use super::{
        FdbFutureCStringArray, FdbFutureI64, FdbFutureKey, FdbFutureKeyValueArray,
        FdbFutureMaybeValue, FdbFutureUnit, FdbStreamKeyValue,
    };

    #[cfg(feature = "fdb-7_1")]
    use super::{FdbFutureKeyArray, FdbFutureMappedKeyValueArray, FdbStreamMappedKeyValue};

    #[test]
    fn impls() {
        #[rustfmt::skip]
	assert!(impls!(
	    FdbFutureUnit:
	        Send &
	        Future &
		!Clone &
		!Copy));

        #[rustfmt::skip]
	assert!(impls!(
	    FdbFutureI64:
	        Send &
	        Future &
		!Clone &
		!Copy));

        #[rustfmt::skip]
	assert!


ernativa, puoi compilare l'estensione per il Chrome Web Store: `pnpm plasmo build --target=chrome-mv3 --release`

### Firefox

1. Entra nella directory dell'estensione: `cd apps/extension`
2. Installa le dipendenze necessarie: `pnpm i`
3. Esegui la build di Plasmo: `pnpm plasmo build --target=firefox-mv3`
4. L'output si troverà in `apps/extension/build/firefox-mv3-prod`, che può essere caricato in Chrome come estensione non impacchettata.
5. In alternativa, puoi compilare l'estensione per il Chrome Web Store: `pnpm plasmo build --target=firefox-mv3 --release`

### Desktop

1. Entra nella directory dell'app: `cd apps/app`
2. Installa le dipendenze necessarie: `pnpm i`
3. Esegui la build di Tauri: `pnpm tauri build`
4. Puoi trovare l'eseguibile nella cartella `apps/app/target/release`.

## Contribuire

Accogliamo con piacere contributi dalla community! Se desideri contribuire a Whispering, segui questi passaggi:

1. Fai un fork del repository.
2. Crea un nuovo branch per la tua funzionalità o bugfix: `git checkout -b feature/your-feature-name` oppure `git checkout -b fix/your-bugfix-name`
3. Apporta le tue modifiche e falle il commit con un messaggio descrittivo.
4. Fai il push del tuo branch sul tuo fork: `git push origin your-branch-name`
5. Crea una pull request dal tuo fork al repository originale.

Assicurati che il tuo codice segua le convenzioni stabilite e sia ben documentato.

## Licenza

Whispering è rilasciato sotto [Licenza MIT](https://opensource.org/licenses/MIT).

## Sponsor

Questo progetto è supportato dalle seguenti persone e organizzazioni straordinarie:

## Supporto e feedback

Se riscontri problemi o hai suggerimenti per miglioramenti, apri una issue sulla [scheda GitHub issues](https://github.com/braden-w/whispering/issues) o contattami via [whispering@bradenwong.com](mailto:whispering@bradenwong.com). Apprezzo davvero il tuo feedback!

Grazie per aver scelto Whispering e buona scrittura!

---

Tranlated By [Open Ai Tx](https://github.com/OpenAiTx/OpenAiTx) | Last indexed: 2025-06-09

---

  <a href="https://whispering.bradenw


font-size: 20px;
    line-height: 30px;
}

/*Pricing*/
.inner-style .tab-button {
    float: left;
    margin-top: -23px;
    margin-bottom: 26px;
}

.inner-style li.nav-item {
    margin-bottom: 15px;
}

.inner-style .pricing-head {
    padding: 28px 26px 14px;
}

.inner-style .pricing-body {
    padding: 27px 10px  34px;
}

.inner-style .single-pricing-box {
    margin-bottom: 20px;
}

.inner-style .pricing-textar-text {
    display: none;
}

/*faqs*/
.inner-style.faqs-area .section-title.left p {
    margin: 25px 0 0 0;
}

.inner-style .faqs-thumb {
    margin: 0 0 15px;
}

.inner-style .faqs-icon-thumb {
    margin-bottom: 19px;
}

.inner-style .faqs-icon-content p {
    width: 100%;
}

.inner-style .faqs-icon-box {
    margin: 33px 0 42px;
    display: block;
}

.inner-style .faq-answer {
    padding: 21px 10px 25px;
}

.inner-style .faq-singular .faq-question {
    padding: 16px 1px 15px 12px;
    font-size: 15px;
}

.inner-style .faq-question img {
    display: none;
}

/*careers Pages*/
.inner-style.careers-area .row.title {
    margin-bottom: 44px;
}

.inner-style .careers-desc p {
    width: 100%;
    float: left;
    margin: 13px 0 0;
}

.inner-style.careers-area .row.add-border {
    padding-top: 43px;
    padding-bottom: 42px;
}

.inner-style .job-desc p {
    margin: 13px 0 28px;
    width: 92%;
}

.inner-style .job-apply-button {
    text-align: left;
}

.inner-style .job-desc p {
    margin: 13px 0 28px;
    width: 100%;
}

.inner-style .job-requirements-content p {
    text-align: justify;
}

.inner-style .single-feature-box {
    padding: 56px 20px 33px;
}

.inner-style .feature-content h4 {
    font-size: 20px;
}

/*blog-grid*/
.blog-grid-area .single-blog-box {
    padding: 20px 5px 31px;
}

.blog-grid-area .blog-category a {
    left: 5px;
}

.blog-grid-area .blog-button i {
    top: 130px;
    right: 15px;
}

.blog-grid-area .blog-content {
    padding: 25px 9px 3px;
}

.blog-grid-area .blog-title a {
    font-size: 20px;
    line-height: 26px;
}
@-webkit-keyframes MOVE-BG {
  from {
    -webkit-transform: translateX(0);
    transform: translateX(0);
  }
  to {
    -webkit-transform: translateX(200px);
    transform: translateX(200px);
  }
}

/*Blog Details*/

.blog-details-content {
    padding: 27px 16px 20px;
}

.blog-details-area .meta-blog i {
    padding-right: 9px;
}

.blog-details-area .meta-blog span {
    margin-right: 9px;
}

h4.blog-details-title {
    font-size: 20px;
    line-height: 28px;
}

p.blog-details-


# -*- coding: utf-8 -*-
"""
    Cosserat class in SofaPython3.
"""

__authors__ = "Yinoussa"
__contact__ = "adagolodjo@protonmail.com"
__version__ = "1.0.0"
__copyright__ = "(c) 2021,Inria"
__date__ = "July, 20 2023"

from useful.header import addHeader
from cosserat.cosseratObject import Cosserat
from dataclasses import dataclass
from useful.params import Parameters, BeamGeometryParameters

# [@info] ================ Unit: N, m, Kg, Pa  ================

# @todo use this dataclass to create the cosserat object
@dataclass
class CableParameters:
    youngModulus: float = 1.205e11
    poissonRatio: float = 0.499
    radius: float = 0.004
    density: float = 7.850e3
    maxDisplacement: float = 0.3

    GI: float =1.5708
    GA: float =3.1416e4
    EI: float =0.7854
    EA: float =3.1416e4
    L:  float = 1.  # beam length in m
    Rb: float = 0.02/2. # beam radius in m

@dataclass
class CableGeometryParameters:
    init_pos: list[float]  # = [0., 0., 0.]
    tot_length: float = 1.
    nbSectionS: int = 5
    nbFramesF: int = 30
    buildCollisionModel: int = 0
    beamMass: float = 1.

YM = 1.0e8
PR = 0.38
rayleighStiffness = 1.e-3  # Nope
firstOrder = 1
EI = 1.e2
coeff = 1

# beam parameters
length = 1.  # in m
Rb = 0.02/2.  # beam radius in m

geoParams = CableGeometryParameters(init_pos=[0., 0., 0.], tot_length=length,
                                    nbSectionS=5, nbFramesF=30, buildCollisionModel=0, beamMass=1.)
# inertialParams = CableParameters(youngModulus=YM, poissonRatio=PR, radius=Rb, density=7.850e3, maxDisplacement=0.3, nbSections=20)
nonLinearConfig = {'init_pos': [0., 0., 0.], 'tot_length': length, 'nbSectionS': 5,
                   'nbFramesF': 30, 'buildCollisionModel': 0, 'beamMass': 1.}
inertialParams = {'GI': 1.5708, 'GA': 3.1416e4,
                  'EI': 0.7854, 'EA': 3.1416e4, 'L': length,  'Rb': Rb}

isCollisionModel = 0

Params = Parameters(beam_geo_params=BeamGeometryParameters(init_pos=[0, 0, 0], beamLength=length,
                                                           nbSection=5, nbFrames=30, buildCollisionModel=0))

def createScene(rootNode):
    addHeader(rootNode)

    node = rootNode.addChild('rootNode')
    node.gravity = [0., -9.81, 0.]
    node.addChild(
        Cosserat(parent=node, cosseratGeometry=nonLinearConfig, inertialParams=inertialParams, radius=Rb,
                 useCollisionModel=isCollisionModel, name="cosserat", youngModulus=YM, poissonRatio=PR,
                 rayleighStiffness=rayleighStiffness))


reorder:after,
.fad.fa-stream:after {
    content: "\f550\f550"
}

.fa-duotone.fa-baseball-ball:after,
.fa-duotone.fa-baseball:after,
.fad.fa-baseball-ball:after,
.fad.fa-baseball:after {
    content: "\f433\f433"
}

.fa-duotone.fa-baseball-bat-ball:after,
.fad.fa-baseball-bat-ball:after {
    content: "\f432\f432"
}

.fa-duotone.fa-basket-shopping:after,
.fa-duotone.fa-shopping-basket:after,
.fad.fa-basket-shopping:after,
.fad.fa-shopping-basket:after {
    content: "\f291\f291"
}

.fa-duotone.fa-basket-shopping-simple:after,
.fa-duotone.fa-shopping-basket-alt:after,
.fad.fa-basket-shopping-simple:after,
.fad.fa-shopping-basket-alt:after {
    content: "\e0af\e0af"
}

.fa-duotone.fa-basketball-ball:after,
.fa-duotone.fa-basketball:after,
.fad.fa-basketball-ball:after,
.fad.fa-basketball:after {
    content: "\f434\f434"
}

.fa-duotone.fa-basketball-hoop:after,
.fad.fa-basketball-hoop:after {
    content: "\f435\f435"
}

.fa-duotone.fa-bat:after,
.fad.fa-bat:after {
    content: "\f6b5\f6b5"
}

.fa-duotone.fa-bath:after,
.fa-duotone.fa-bathtub:after,
.fad.fa-bath:after,
.fad.fa-bathtub:after {
    content: "\f2cd\f2cd"
}

.fa-duotone.fa-battery-bolt:after,
.fad.fa-battery-bolt:after {
    content: "\f376\f376"
}

.fa-duotone.fa-battery-0:after,
.fa-duotone.fa-battery-empty:after,
.fad.fa-battery-0:after,
.fad.fa-battery-empty:after {
    content: "\f244\f244"
}

.fa-duotone.fa-battery-exclamation:after,
.fad.fa-battery-exclamation:after {
    content: "\e0b0\e0b0"
}

.fa-duotone.fa-battery-5:after,
.fa-duotone.fa-battery-full:after,
.fa-duotone.fa-battery:after,
.fad.fa-battery-5:after,
.fad.fa-battery-full:after,
.fad.fa-battery:after {
    content: "\f240\f240"
}

.fa-duotone.fa-battery-3:after,
.fa-duotone.fa-battery-half:after,
.fad.fa-battery-3:after,
.fad.fa-battery-half:after {
    content: "\f242\f242"
}

.fa-duotone.fa-battery-1:after,
.fa-duotone.fa-battery-low:after,
.fad.fa-battery-1:after,
.fad.fa-battery-low:after {
    content: "\e0b


,
          orgId,
          Optional.of(agentId),
          Optional.of(start),
          Optional.of(end),
          Optional.empty(),
          Optional.empty(),
          Optional.empty(),
          Optional.empty(),
          Optional.empty(),
          Optional.empty(),
          Optional.empty(),
          Optional.empty()
      );
    }
    // All events which start from now. expected: no.3 and no.4, but limit is 1, so just no. 3
    final List<ExtendedEventDto> events1 = schedulerDatabase.search(
        Optional.empty(),
        Optional.of(new Date(nowMillis)),
        Optional.empty(),
        Optional.empty(),
        Optional.empty(),
        Optional.of(1)
    );
    Assert.assertEquals(1, events1.size());
    Assert.assertTrue(events1.get(0).getMediaPackageId().equals(mpId + 2));
  }

  @Test
  public void testSearchCaptureAgent() throws Exception {
    // We create 4 events, each with a duration of 2 hours:
    // - Event no. 1 ends way before now                       <- agent 1
    // - Event no. 2 starts before the now and ends after now  <- agent 2
    // - Event no. 3 starts when no. 2 ends                    <- agent 1
    // - Event no. 4 starts two hours after no. 3 ends         <- agent 2
    // So we have:  [no.1][free][no.2][no.3][free][no.4]

    final long oneHourMillis = 3600_000;
    final long nowMillis = new Date().getTime();
    final String mpId = "mpId";
    final String[] agentIds = {"agent1", "agent2"};
    final String orgId = new DefaultOrganization().getId();
    final Date[] eventStartDates = {
        new Date(nowMillis - 4 * oneHourMillis),
        new Date(nowMillis - oneHourMillis),
        new Date(nowMillis + oneHourMillis),
        new Date(nowMillis + 5 * oneHourMillis),
    };
    final List<Integer> indeces = Arrays.asList(0, 1, 2, 3);
    Collections.shuffle(indeces); // we want to insert in random order to test if method under test sorts correctly.
    for (int i : indeces) {
      final Date start = eventStartDates[i];
      final Date end = new Date(start.getTime() + 2 * oneHourMillis);
      schedulerDatabase.storeEvent(
          mpId + i,
          orgId,
          Optional.of(agentIds[i % 2]),
          Optional.of(start),
          Optional.of(end),
          Optional.empty(),
          Optional.empty(),
          Optional.empty(),
          Optional.empty(),
          Optional.empty(),
          Optional.empty(),
          Optional.empty(),
          Optional.empty()
      );
    }
    // All events which start from now on agent 1. expected: no.3
    final List<ExtendedEventDto> events1 = schedulerDatabase.search(
        Optional.of(agentIds[0]),
        Optional.of(new Date(nowMillis)),
        Optional.empty(),
        Optional.empty(),
        Optional.empty(),
        Optional.empty()
    );
    Assert.assertEquals(1, events1.size());
    Assert.assertTrue(events1.get(0).getMediaPackageId().equals(mpId + 2));

    // All events which start from now on agent 2. expected: no.4
    final List<ExtendedEventDto> events2 = schedulerDatabase.search(
        Optional.of(agentIds[1]),
        Optional.of(new Date(nowMillis)),
        Optional.empty(),
        Optional.empty(),
        Optional.empty(),
        Optional.empty()
    );
    Assert.assertEquals(1, events2.size());
    Assert.assertTrue(events2.get(0).getMediaPackageId().equals(mpId + 3));

    // No start/end dates given. expected: all events of agent 1 are returned
    final List<ExtendedEventDto> ev


 icc.repo_id=oic.repo_id AND icc.actor_id=oic.actor_id
  FULL JOIN
  (${openPullRequestCount(table)}) AS opc
  ON icc.repo_id=opc.repo_id AND icc.actor_id=opc.actor_id
  FULL JOIN
  (${reviewCommentCount(table)}) AS rcc
  ON icc.repo_id=rcc.repo_id AND icc.actor_id=rcc.actor_id
  FULL JOIN
  (${mergePullCount(table)}) AS mpc
  ON icc.repo_id=mpc.repo_id AND icc.actor_id=mpc.actor_id
  FULL JOIN
  (${starCount(table)}) AS wc
  ON icc.repo_id=wc.repo_id AND icc.actor_id=wc.actor_id
  FULL JOIN
  (${forkCount(table)}) AS fc
  ON icc.repo_id=fc.repo_id AND icc.actor_id=fc.actor_id
  `;
}
export function getPeriodTable(startDate:Date,endDate:Date,conditions:string){
  let startYear=startDate.getFullYear();
  let endYear=endDate.getFullYear();
  let startDateFormat=dateFormat(startDate,'yyyy-mm-dd');
  let endDateFormat=dateFormat(endDate,'yyyy-mm-dd');
  if (startYear>endYear)return ``;
  if(startYear===endYear){
    return `
    (SELECT * FROM github_log.year${endYear}
    WHERE toDate(created_at)>='${startDateFormat}'
    AND toDate(created_at)<='${endDateFormat}'
    AND ${conditions}
    )
    `;
  }
  if(startYear+1===endYear){
    return `
    (SELECT * FROM github_log.year${startYear} WHERE toDate(created_at)>='${startDateFormat}' AND ${conditions}
    UNION ALL
    SELECT * FROM github_log.year${endYear} WHERE toDate(created_at)<='${endDateFormat}' AND ${conditions})
    `;
  }
  let baseTable=``;
  for (let year = startYear+1; year < endYear; year++) {
    baseTable+=`
    UNION ALL
    SELECT * FROM github_log.year${year} WHERE ${conditions}
    `;
  }
  return `
  (SELECT * FROM github_log.year${startYear} WHERE toDate(created_at)>='${startDateFormat}' AND ${conditions}
  `+baseTable+`
  UNION ALL
  SELECT * FROM github_log.year${endYear} WHERE toDate(created_at)<='${endDateFormat}' AND ${conditions})
  `;
}
export function periodRepoActivity(periodRepoActorActivity:string){
  return `
  SELECT anyHeavy(repo_name) AS repo_name,ROUND(SUM(score),2) AS activity,
  COUNT(DISTINCT actor_id) AS developer_count,
  SUM(issue_comment) AS issue_comment,SUM(open_issue) AS open_issue,
  SUM(open_pull) AS open_pull,SUM(pull_review_comment) AS pull_review_comment,
  SUM(merge_pull) AS merge_pull,SUM(commits) AS commits,SUM(additions) AS additions,SUM(deletions) AS deletions,
  SUM(star_count) AS star_count,SUM(fork_count) AS fork_count,
  MAX(repo_language) AS repo_language
  FROM (${periodRepoActorActivity})
  GROUP BY repo_id
  ORDER BY activity DESC
  `;
}import * as _ from 'lodash';

import { Adapter } from '../../../src/adapters';
import { Diaspora } from '../../../src/diaspora';
import { Model } from '../../../src/model';
import { EFieldType } from '../../../src';

import '../utils';

let testModel: Model<{foo?: string; baz?: string}>;
const MODEL_NAME = 'model-test';
const SOURCE = 'inMemory-model-test';
let dataAccessLayer: Adapter.DataAccessLayer;
let store: { ite