, 4);
					break;
			};
			switch (legend6.SelectedIndex)
			{
				case 1:
					drb.set_legend(DRB.Tornadus, 5);
					break;
				case 2:
					drb.set_legend(DRB.Thundurus, 5);
					break;
				case 3:
					drb.set_legend(DRB.Landorus, 5);
					break;
				case 4:
					drb.set_legend(DRB.Dialga, 5);
					break;
				case 5:
					drb.set_legend(DRB.Palkia, 5);
					break;
				case 6:
					drb.set_legend(DRB.Giratina, 5);
					break;
				case 7:
					drb.set_legend(DRB.HoOh, 5);
					break;
				case 8:
					drb.set_legend(DRB.Lugia, 5);
					break;
				default:
					drb.set_legend(0, 5);
					break;
			};
			switch (legend7.SelectedIndex)
			{
				case 1:
					drb.set_legend(DRB.Tornadus, 6);
					break;
				case 2:
					drb.set_legend(DRB.Thundurus, 6);
					break;
				case 3:
					drb.set_legend(DRB.Landorus, 6);
					break;
				case 4:
					drb.set_legend(DRB.Dialga, 6);
					break;
				case 5:
					drb.set_legend(DRB.Palkia, 6);
					break;
				case 6:
					drb.set_legend(DRB.Giratina, 6);
					break;
				case 7:
					drb.set_legend(DRB.HoOh, 6);
					break;
				case 8:
					drb.set_legend(DRB.Lugia, 6);
					break;
				default:
					drb.set_legend(0, 6);
					break;
			};
			switch (legend8.SelectedIndex)
			{
				case 1:
					drb.set_legend(DRB.Tornadus, 7);
					break;
				case 2:
					drb.set_legend(DRB.Thundurus, 7);
					break;
				case 3:
					drb.set_legend(DRB.Landorus, 7);
					break;
				case 4:
					drb.set_legend(DRB.Dialga, 7);
					break;
				case 5:
					drb.set_legend(DRB.Palkia, 7);
					break;
				case 6:
					drb.set_legend(DRB.Giratina, 7);
					break;
				case 7:
					drb.set_legend(DRB.HoOh, 7);
					break;
				case 8:
					drb.set_legend(DRB.Lugia, 7);
					break;
				default:
					drb.set_legend(0, 7);
					break;
			};
			if (legitmode.Checked == true)
			{
				drb.set_poke(drb.legit_pk_index[pkm1.SelectedIndex], pkmgnd1.SelectedIndex, 0);
				drb.set_poke(drb.legit_pk_index[pkm2.SelectedIndex], pkmgnd2.SelectedIndex, 1);
				drb.set_poke(drb.legit_pk_index[pkm3.SelectedIndex], pkmgnd3.SelectedIndex, 2);
				drb.set_poke(drb.legit_pk_index[pkm4.SelectedIndex], pkmgnd4.SelectedIndex, 3);
				drb.set_poke(drb.legit_pk_index[pkm5.SelectedIndex], pkmgnd5.SelectedIndex, 4);
				drb.set_poke(drb.legit_pk_index[pkm6.SelectedIndex], pkmgnd6.SelectedIndex, 5);

				drb.set_item((int)itemcnt1.Value, drb.legit_item_index[item1.SelectedIndex], 0);
				drb.set_item((int)itemcnt2.Value, drb.legit_item_index[item2.Selecte


param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
        public static global::OpenApiKiotaClientExample.GeneratedCode.Models.ToManyTodoItemInResponse CreateFromDiscriminatorValue(IParseNode parseNode)
        {
            _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
            return new global::OpenApiKiotaClientExample.GeneratedCode.Models.ToManyTodoItemInResponse();
        }

        /// <summary>
        /// The deserialization information for the current model
        /// </summary>
        /// <returns>A IDictionary<string, Action<IParseNode>></returns>
        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
        {
            return new Dictionary<string, Action<IParseNode>>
            {
                { "data", n => { Data = n.GetCollectionOfObjectValues<global::OpenApiKiotaClientExample.GeneratedCode.Models.TodoItemIdentifierInResponse>(global::OpenApiKiotaClientExample.GeneratedCode.Models.TodoItemIdentifierInResponse.CreateFromDiscriminatorValue)?.AsList(); } },
                { "links", n => { Links = n.GetObjectValue<global::OpenApiKiotaClientExample.GeneratedCode.Models.RelationshipLinks>(global::OpenApiKiotaClientExample.GeneratedCode.Models.RelationshipLinks.CreateFromDiscriminatorValue); } },
                { "meta", n => { Meta = n.GetObjectValue<global::OpenApiKiotaClientExample.GeneratedCode.Models.Meta>(global::OpenApiKiotaClientExample.GeneratedCode.Models.Meta.CreateFromDiscriminatorValue); } },
            };
        }

        /// <summary>
        /// Serializes information the current object
        /// </summary>
        /// <param name="writer">Serialization writer to use to serialize this model</param>
        public virtual void Serialize(ISerializationWriter writer)
        {
            _ = writer ?? throw new ArgumentNullException(nameof(writer));
            writer.WriteCollectionOfObjectValues<global::OpenApiKiotaClientExample.GeneratedCode.Models.TodoItemIdentifierInResponse>("data", Data);
            writer.WriteObjectValue<global::OpenApiKiotaClientExample.GeneratedCode.Models.RelationshipLinks>("links", Links);
            writer.WriteObjectValue<global::OpenApiKiotaClientExample.GeneratedCode.Models.Meta>("meta", Meta);
        }
    }
}
#pragma warning restore CS0618


;
  }

  @override
  void release(int marker) {}

  /// consume() ahead until p==_index; can't just set p=_index as we must
  /// update line and column. If we seek backwards, just set p
  @override
  void seek(int _index) {
    if (_index <= this._index) {
      this._index = _index; // just jump; don't update stream state (line,
      // ...)
      return;
    }
    // seek forward
    this._index = min(_index, size);
  }

  @override
  String getText(Interval interval) {
    final startIdx = min(interval.a, size);
    final len = min(interval.b - interval.a + 1, size - startIdx);
    return String.fromCharCodes(data, startIdx, startIdx + len);
  }

  @override
  String toString() {
    return String.fromCharCodes(data);
  }

  @override
  String get sourceName {
    // TODO: implement getSourceName
    return IntStream.UNKNOWN_SOURCE_NAME;
  }
}
/*
 * Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
 * Use of this file is governed by the BSD 3-clause license that
 * can be found in the LICENSE.txt file in the project root.
 */

import 'dart:developer';

import 'atn/atn.dart';
import 'error/error.dart';
import 'input_stream.dart';
import 'interval_set.dart';
import 'misc/misc.dart';
import 'recognizer.dart';
import 'token.dart';
import 'token_factory.dart';
import 'token_source.dart';
import 'util/utils.dart';

abstract class Lexer extends Recognizer<LexerATNSimulator>
    implements TokenSource {
  static final DEFAULT_MODE = 0;
  static final MORE = -2;
  static final SKIP = -3;

  static final DEFAULT_TOKEN_CHANNEL = Token.DEFAULT_CHANNEL;
  static final HIDDEN = Token.HIDDEN_CHANNEL;
  static final MIN_CHAR_VALUE = 0x0000;
  static final MAX_CHAR_VALUE = 0x10FFFF;

  CharStream _input;

  late Pair<TokenSource, CharStream?> _tokenFactorySourcePair;

  @override
  TokenFactory get tokenFactory {
    return _factory;
  }

  @override
  set tokenFactory(TokenFactory factory) {
    _factory = factory;
  }

  TokenFactory _factory = CommonTokenFactory.DEFAULT;

  /// The goal of all lexer rules/methods is to create a token object.
  /// this is an instance variable as multiple rules may collaborate to
  /// create a single token. nextToken will return this object after
  /// matching lexer rule(s). If you subclass to allow multiple token
  /// emissions, then set this to the last token to be matched or
  /// something nonnull so that the auto token emit mechanism will not
  /// emit another token.
  Token? _token;

  /// What character index in the stream did the current token start at?
  /// Needed, for example, to get the text for current token. Set at
  /// the start of nextToken.
  int tokenStartCharIndex = -1;

  /// The line on which the first character of the token resides
  int tokenStartLine = -1;

  /// The character position of first character within the line
  int tokenStartCharPositionInLine = -1;

  /// Once we see EOF on char stream, next token will be EOF.
  /// If you have DONE : EOF ; then you see DONE EOF.
  bool _hitEOF = false;

  /// The channel number for the current token
  int channel = Token.DEFAULT_CHANNEL;

  /// The token type for the current token
  int type = Token.INVALID_TYPE;

  final List<int> _modeStack = [];
  int mode_ = Lexer.DEFAULT_MODE;

  /// You can set the text for the current token to override what is in
  /// the input char buffer. Us


grid-header-cell {
    height: 100%;
    vertical-align: middle;

    [role="columnheader"] {
      position: relative;
    }
  }

  .ui-grid-header-cell:last-child {
    border-right: solid 1px #d4d4d4;

    .ui-grid-column-resizer.right {
      border-right: none;
    }
  }

  .ui-grid-cell.last-in-group:not(:last-child) {
    border-right-width: 3px;
  }

  .ui-grid-footer-cell:last-child {
    border-right: solid 1px #d4d4d4;
  }

  .ui-grid-footer-cell.last-in-group:not(:last-child) {
    border-right-width: 3px;
  }

  .ui-grid-pinned-container.ui-grid-pinned-container-left {
    .ui-grid-header-group:last-child {
      .ui-grid-header-group-name,
      .ui-grid-header-cell:last-child {
        border-right: solid 3px #aeaeae;
      }
    }

    .ui-grid-header-cell:last-child {
      border-right-color: #d4d4d4;
    }

    .ui-grid-cell:last-child {
      border-right-width: 3px;
    }

    .ui-grid-footer-cell:last-child {
      border-right: solid 3px #aeaeae;
    }
  }

  .ui-grid-pinned-container.ui-grid-pinned-container-right {
    .ui-grid-header-group:first-child {
      .ui-grid-header-group-name,
      .ui-grid-header-cell:first-child {
        border-left: solid 3px #aeaeae;
      }
    }

    .ui-grid-header-cell:first-child {
      border-left: none;
    }

    // Added again here in order to overcome specificity issues with the default UI Grid CSS
    .ui-grid-cell.last-in-group:not(:last-child) {
      border-right-width: 3px;
    }

    .ui-grid-cell:first-child {
      border-left-width: 3px;
    }

    .ui-grid-footer-cell:first-child {
      border-left: solid 3px #aeaeae;
    }
  }
}
.user-message {
  @apply text-neutrals-900 rounded-t-[32px] rounded-bl-[32px] py-3;
}

.message-stages {
  &-header {
    @apply body-1 text-neutrals-700;
    @apply gap-2 p-3 mb-3;

    &.default-header {
      @apply h4 text-neutrals-900;
    }

    &:hover {
      @apply text-neutrals-800 bg-neutrals-200 rounded-[20px];

      .message-stages-expand-icon {
        @apply text-hues-900;
      }
    }
  }

  &-title {
    @apply order-2;
  }

  &-expand-icon {
    @apply text-primary;
    @apply w-5 h-5 p-0;

    &.rotated {
      @apply rotate-[-90deg];
    }
  }
}

.message-stage {
  @apply ml-3;

  &-indicator {
    @apply w-5 h-5;
    @apply text-hues-200;
  }

  &-line {
    @apply left-[10px] top-2;
    @apply border-hues-200;
  }

  &-name {
    @apply body-1 text-neutrals-700;
  }

  &:last-child {
    .message-stage-line {
      @apply border-l-0;
    }
  }

  .loader:before {
    @apply w-6 h-6 bg-contain;
  }

  .prose {
    @apply body-3;

    p {
      @apply text-


FdeOffsetFromPc(pc, &fde_offset));
    EXPECT_EQ(0x5000 + i * 0x20, fde_offset);
    EXPECT_TRUE(this->eh_frame_->GetFdeOffsetFromPc(pc + 1, &fde_offset));
    EXPECT_EQ(0x5000 + i * 0x20, fde_offset);
    EXPECT_TRUE(this->eh_frame_->GetFdeOffsetFromPc(pc + 0xfff, &fde_offset));
    EXPECT_EQ(0x5000 + i * 0x20, fde_offset);
  }
}

TYPED_TEST_P(DwarfEhFrameWithHdrTest, GetFdeOffsetFromPc_index_fail) {
  this->eh_frame_->TestSetTableEntrySize(0x10);
  this->eh_frame_->TestSetFdeCount(10);

  uint64_t fde_offset;
  EXPECT_FALSE(this->eh_frame_->GetFdeOffsetFromPc(0x1000, &fde_offset));
}

TYPED_TEST_P(DwarfEhFrameWithHdrTest, GetFdeOffsetFromPc_fail_fde_count) {
  this->eh_frame_->TestSetFdeCount(0);

  uint64_t fde_offset;
  ASSERT_FALSE(this->eh_frame_->GetFdeOffsetFromPc(0x100, &fde_offset));
  ASSERT_EQ(DWARF_ERROR_NONE, this->eh_frame_->LastErrorCode());
}

TYPED_TEST_P(DwarfEhFrameWithHdrTest, GetFdeOffsetFromPc_search) {
  this->eh_frame_->TestSetTableEntrySize(16);
  this->eh_frame_->TestSetFdeCount(10);

  typename DwarfEhFrameWithHdr<TypeParam>::FdeInfo info;
  info.pc = 0x550;
  info.offset = 0x10500;
  this->eh_frame_->TestSetFdeInfo(5, info);
  info.pc = 0x750;
  info.offset = 0x10700;
  this->eh_frame_->TestSetFdeInfo(7, info);
  info.pc = 0x850;
  info.offset = 0x10800;
  this->eh_frame_->TestSetFdeInfo(8, info);

  uint64_t fde_offset;
  ASSERT_TRUE(this->eh_frame_->GetFdeOffsetFromPc(0x800, &fde_offset));
  EXPECT_EQ(0x10700U, fde_offset);
}

TYPED_TEST_P(DwarfEhFrameWithHdrTest, GetCieFde32) {
  // CIE 32 information.
  this->memory_.SetData32(0xf000, 0x100);
  this->memory_.SetData32(0xf004, 0);
  this->memory_.SetMemory(0xf008, std::vector<uint8_t>{1, '\0', 4, 8, 0x20});

  // FDE 32 information.
  this->memory_.SetData32(0x14000, 0x20);
  this->memory_.SetData32(0x14004, 0x5004);
  this->memory_.SetData32(0x14008, 0x9000);
  this->memory_.SetData32(0x1400c, 0x100);

  const DwarfFde* fde = this->eh_frame_->GetFdeFromOffset(0x14000);
  ASSERT_TRUE(fde != nullptr);
  EXPECT_EQ(0x14010U, fde->cfa_instructions_offset);
  EXPECT_EQ(0x14024U, fde->cfa_instructions_end);
  EXPECT_EQ(0x1d008U, fde->pc_start);
  EXPECT_EQ(0x1d108U, fde->pc_end);
  EXPECT_EQ(0xf000U, fde->cie_offset);
  EXPECT_EQ(0U, fde->lsda_address);

  ASSERT_TRUE(fde->cie != nullptr);
  EXPECT_EQ(1U, fde->cie->version);
  EXPECT_EQ(DW_EH_PE_sdata4, fde->cie->


',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	''},
{'1041430',	'',	'我们再休息一段时间吧？旋律这叠满了debuff的样子可不太适合去和碎星人交涉。',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'5001001',	'',	'',	'2',	'',	'女王蜂',	'Queenbee',	'[{"id":5001001,"pos":2,"enter":2}]',	'',	'2',	'',	'',	'',	'',	'',	'',	'',	'',	'1041431',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	''},
{'1041431',	'',	'我赞成。目前没有办法和前哨基地联络，我们就是孤军。要和不知善恶的碎星人交流，还是要展现出强悍的一面更合适。',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'3033001',	'',	'',	'2',	'',	'白鳍',	'Baiji',	'[{"id":3033001,"pos":2,"enter":2}]',	'',	'7',	'',	'',	'',	'',	'',	'',	'',	'',	'1041432',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	''},
{'1041432',	'',	'……是我拖累了大家，真的很对不起……',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'2008001',	'',	'',	'2',	'',	'旋律',	'Melody',	'[{"id":2008001,"pos":2,"enter":2}]',	'',	'3',	'',	'',	'',	'',	'',	'',	'',	'',	'1041433',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	''},
{'1041433',	'',	'白鳍拍了拍旋律的肩膀。',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'1',	'',	'',	'',	'[{"id":3033001,"pos":2,"enter":2}]',	'',	'2',	'',	'',	'',	'',	'',	'',	'',	'',	'1041434',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	''},
{'1041434',	'',	'不要一直道歉，责怪自己。我们都希望自己在所有情况下都是保持绝对理性的人，但人毕竟是无法彻底摒弃情感的生物。',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'3033001',	'',	'',	'2


1: '暮らし、生活', name2: '病院、診療所', name3: '小児歯科' },
    { code1: '04', code2: '0401', code3: '0401038', name1: '暮らし、生活', name2: '病院、診療所', name3: '血液内科' },
    { code1: '04', code2: '0401', code3: '0401039', name1: '暮らし、生活', name2: '病院、診療所', name3: '消化器外科' },
    { code1: '04', code2: '0401', code3: '0401040', name1: '暮らし、生活', name2: '病院、診療所', name3: '腎臓内科' },
    { code1: '04', code2: '0401', code3: '0401041', name1: '暮らし、生活', name2: '病院、診療所', name3: '肝臓科' },
    { code1: '04', code2: '0401', code3: '0401042', name1: '暮らし、生活', name2: '病院、診療所', name3: '内視鏡科' },
    { code1: '04', code2: '0401', code3: '0401043', name1: '暮らし、生活', name2: '病院、診療所', name3: '腹部外科' },
    { code1: '04', code2: '0401', code3: '0401044', name1: '暮らし、生活', name2: '病院、診療所', name3: '胸部外科' },
    { code1: '04', code2: '0401', code3: '0401045', name1: '暮らし、生活', name2: '病院、診療所', name3: '内分泌科' },
    { code1: '04', code2: '0401', code3: '0401046', name1: '暮らし、生活', name2: '病院、診療所', name3: '人工透析科 ' },
    { code1: '04', code2: '0401', code3: '0401047', name1: '暮らし、生活', name2: '病院、診療所', name3: '人間ドック施設' },
    { code1: '04', code2: '0401', code3: '0401048', name1: '暮らし、生活', name2: '病院、診療所', name3: '大学病院' },
    { code1: '04', code2: '0401', code3: '0401049', name1: '暮らし、生活', name2: '病院、診療所', name3: '総合病院' },
    { code1: '04', code2: '0402', code3: '0402001', name1: '暮らし、生活', name2: '薬局', name3: '薬局' },
    { code1: '04', code2: '0403', code3: '0403001', name1: '暮らし、生活', name2: 'マッサージ、整体、治療院', name3: '接骨、整骨、整復' },
    { code1: '04', code2: '0403', code3: '0403002', name1: '暮らし、生活', na


import os
import pandas as pd
from rdkit import Chem
from rdkit.Chem import AllChem, SDWriter
from rdkit.Chem import rdMolDescriptors
from rdkit.Chem import rdMolAlign
from tqdm import tqdm  # Import tqdm for progress bar
from multiprocessing import Pool, cpu_count  # 添加多核处理支持

# Function to read SDF and SMILES, create molecule object from SMILES
def smi_to_molecule(smiles):
    try:
        mol = Chem.MolFromSmiles(smiles)
        if mol is None:
            return None
        return mol
    except:
        return None

# Function to calculate RMSD between two molecules
def calculate_rmsd(mol1, mol2):
    try:
        # Generate 3D coordinates for both molecules if they don't have them
        mol1_3d = Chem.AddHs(mol1)
        mol2_3d = Chem.AddHs(mol2)

        AllChem.EmbedMolecule(mol1_3d, randomSeed=42)
        AllChem.EmbedMolecule(mol2_3d, randomSeed=42)

        # Perform alignment to minimize RMSD
        rmsd = rdMolAlign.GetBestRMS(mol1_3d, mol2_3d)
        return rmsd
    except:
        return float('inf')  # If the RMSD calculation fails, return a large value

# Function to align optimized molecule to reference molecule
def align_molecules(mol1, mol2):
    try:
        # Generate 3D coordinates if not present
        mol1_3d = Chem.AddHs(mol1)
        mol2_3d = Chem.AddHs(mol2)

        # Embed the molecules to generate 3D coordinates if not already available
        AllChem.EmbedMolecule(mol1_3d, randomSeed=42)
        AllChem.EmbedMolecule(mol2_3d, randomSeed=42)

        # Perform alignment based on 3D structures
        rmsd = rdMolAlign.GetBestRMS(mol2_3d, mol1_3d)
    except:
        return mol2_3d, float('inf')
    return mol2_3d, rmsd

# Function to generate SDF file from aligned molecule
def generate_sdf_from_molecule(output_file, molecule):
    writer = SDWriter(output_file)
    writer.write(molecule)
    writer.close()

# Function to find the best matching SDF file based on SDF File name
def find_matching_sdf_file(reference_dir, sdf_file_name):
    # Match the reference file by checking if the file starts with sdf_file_name and ends with .sdf
    for sdf_filename in os.listdir(reference_dir):
        if sdf_filename.startswith(sdf_file_name) and sdf_filename.endswith(".sdf"):
            return os.path.join(reference_dir, sdf_filename)
    return None

# 添加一个处理单个分子的函数，便于并行
def process_single_molecule(args):
    idx, row, reference_dir, output_dir = args
    # 在try块外部先初始化变量，防止异常处理中引用未定义变量
    sdf_file_name = "unknown"
    try:
        standardized_opt_smi = row['target_smiles']  # 使用target_smiles作为目标SMILES
        sdf_file_name = row['SDF File']
        file_prefix = '_'.join(sdf_file_name.split('_')[:8])

        # 获取属性变化信息
        property_changes = row.get('property_changes', '')

        reference_sdf_dir = reference_dir + '/' + file_prefix
        # Find the best matching SDF file based on SDF File column in CSV
        matching_sdf_path = find_matching_sdf_file(reference_sdf_dir, sdf_file_name)

        if not matching_sdf_path:
            return f"No matching SDF file found for {sdf_file_name}. Skipping."

        # Read the reference molecule from the matching SDF file
        suppl = Chem.SDMolSupplier(matching_sdf_path)
        reference_mol = None
        for mol in suppl:
            if mol is not None:
                reference_mol = mol
                break

        if reference_mol is None:
            return f"No valid molecule found in the file {matching_sdf_path}. Skipping."

        # Generate the target molecule from the standardized opt_smi
        target_mol = smi_to_molecule(standardized_opt_smi)
        if target_mol is None:
            return f"Invalid SMILES for {sdf_file_name}. Skipping."

        # Align the molecules
        aligned_mol, rmsd = align_molecules(reference_mol, target_mol)

        # 添加属性变化信息到分子对象
        if property_changes and not pd.isna(property_changes):
            aligned_mol.SetProp("PropertyChanges", property_changes)

        # Create output directory if it doesn't exist
        output_subdir = os.path.join(output_dir, file_prefix)
        os.makedirs(output_subdir, exist_ok=True)

        # Get unique file name
        existing_files = [f for f in os.listdir(output_subdir) if f.startswith(file_prefix)]
        file_index = len(existing_files) + 1
        output_path = os.path.join(output_subdir, f"{file_prefix}_generated_{file_index}.sdf")


= {
      mappings = {
        parameters = {
          group_name= "EffectEncoders2",
        },
        device = {
          group_name= "DialPush3",
        },
        param_prev = {
          group_name = "ControlButtonRow2",
          index = 1,
        },
        param_next = {
          group_name = "ControlButtonRow2",
          index = 2,
        },
      },
    },
    Transport = {
      mappings = {
        start_playback = {
          group_name = "DialPush2",
          index = 1,
        },
        stop_playback = {
          group_name = "DialPush2",
          index = 2,
        },
        loop_pattern = {
          group_name = "DialPush2",
          index = 3,
        },
        goto_previous = {
          group_name = "DialPush2",
          index = 4,
        },
        goto_next = {
          group_name = "DialPush2",
          index = 5,
        },
        edit_mode = {
          group_name = "DialPush2",
          index = 6,
        },
        follow_player = {
          group_name = "DialPush2",
          index = 7,
        },
        metronome_toggle = {
          group_name = "DialPush2",
          index = 8,
        },
      },
      options = {
      }
    },
    SwitchConfiguration = {
      mappings = {
        goto_previous = {
          group_name = "DialPush4",
          index = 7,
        },
        goto_next = {
          group_name = "DialPush4",
          index = 8,
        },
      }
    },
  }
}


oTeamColorPixelCount.put(tri, teamColorPixels);
					}
				}
			}
			int nShadedPixels = 0;
			int nDiffusePixels = 0;
			final BufferedImage bakedImg = new BufferedImage(bakingCells[0].length, bakingCells.length,
					BufferedImage.TYPE_INT_ARGB);
			for (int i = 0; i < bakingCells.length; i++) {
				for (int j = 0; j < bakingCells[i].length; j++) {
					// fake fragment shader thing, obviously will be very wrong in some cases if the
					// texture is used on multiple triangles in different places

					final Vector3f fragColorRGB = new Vector3f();

					final BakingCell bakingCell = bakingCells[i][j];

					final float teamColorNess = ((bakingCell.ormRGB >> 24) & 0xFF) / 255.0f;
					final float nonTeamColorNess = 1.0f - teamColorNess;

					final float baseRed = ((bakingCell.diffuseRGB >> 16) & 0xFF) / 255.0f;
					final float baseGreen = ((bakingCell.diffuseRGB >> 8) & 0xFF) / 255.0f;
					final float baseBlue = ((bakingCell.diffuseRGB >> 0) & 0xFF) / 255.0f;
					final Vector3f diffuse = new Vector3f(baseRed, baseGreen, baseBlue);
					diffuse.scale(nonTeamColorNess);
					if (bakingCell.tangentFragPos != null) {
						final float normalX = ((((bakingCell.normalRGB >> 16) & 0xFF) / 255.0f) * 2.0f) - 1.0f;
						final float normalY = ((((bakingCell.normalRGB >> 8) & 0xFF) / 255.0f) * 2.0f) - 1.0f;
						final Vector3f normal = new Vector3f(normalY, normalX,
								(float) Math.sqrt(1.0 - ((normalX * normalX) + (normalY * normalY))));
						final Vector3f lightDir = new Vector3f(0, 0, 1);// bakingCell.tangentViewPos;
						lightDir.set(bakingCell.tangentLightPos);
						lightDir.normalise();
						{
							final float cosTheta = (Vector3f.dot(lightDir, normal) * 0.5f) + 0.5f;
							final float lambertFactor = (float) Math.max(0.0, Math.min(1.0, cosTheta));

							diffuse.scale((float) Math.max(0.0, Math.min(1.0, lambertFactor)));
						}
						final Vector3f viewDir = new Vector3f();
						Vector3f.sub(bakingCell.tangentViewPos, bakingCell.tangentFragPos, viewDir);
						viewDir.normalise();
						final Vector3f reflectDir = new Vector3f();
						lightDir.scale(-1);
						MathUtils.reflect(lightDir, normal, reflectDir);
						lightDir.scale(-1);
						final Vector3f halfwayDir = new Vector3f();
						Vector3f.add(lightDir, viewDir, halfwayDir);
						halfwayDir.normalise();
						final float spec = (float) Math.pow(Math.max(Vector3f.dot(normal, halfwayDir), 0.0f), 32.0f);
						final float metalness = ((bakingCell.ormRGB >> 0) & 0xFF) / 255.0f;
						final float roughness = ((bakingCell.ormRGB >> 8) & 0xFF) / 255.0f;
//						"			vec3 specular = vec3(max(-ormTexel.g+0.5


-null
/// Example of:
///
/// - A constructor initializing fields in the body "the long way"
/// - A named constructor with initializers, and a print statement in the body.
///
// #docregion idiomatic-constructor
class Point {
  // Instance variables to hold the coordinates of the point.
  double x;
  double y;

  // Generative constructor with initializing formal parameters:
  Point(this.x, this.y);
  // #enddocregion idiomatic-constructor

  // #docregion initializer-list
  // Initializer list sets instance variables before
  // the constructor body runs.
  // #docregion initializer-list-no-comment
  Point.fromJson(Map<String, double> json) : x = json['x']!, y = json['y']! {
    print('In Point.fromJson(): ($x, $y)');
  }
  // #enddocregion initializer-list-no-comment
  // #enddocregion initializer-list

  // #docregion initializer-list-with-assert
  Point.withAssert(this.x, this.y) : assert(x >= 0) {
    print('In Point.withAssert(): ($x, $y)');
  }
  // #enddocregion initializer-list-with-assert

  // #docregion idiomatic-constructor
}
// #enddocregion idiomatic-constructor

// #docregion initialize-declaration
class PointA {
  double x = 1.0;
  double y = 2.0;

  // The implicit default constructor sets these variables to (1.0,2.0)
  // PointA();

  @override
  String toString() {
    return 'PointA($x,$y)';
  }
}
// #enddocregion initialize-declaration

// #docregion initialize-formal
class PointB {
  final double x;
  final double y;

  // Sets the x and y instance variables
  // before the constructor body runs.
  PointB(this.x, this.y);

  // Initializing formal parameters can also be optional.
  PointB.optional([this.x = 0.0, this.y = 0.0]);
}
// #enddocregion initialize-formal

// #docregion initialize-named
class PointC {
  double x; // must be set in constructor
  double y; // must be set in constructor

  // Generative constructor with initializing formal parameters
  // with default values
  PointC.named({this.x = 1.0, this.y = 1.0});

  @override
  String toString() {
    return 'PointC.named($x,$y)';
  }
}

// Constructor using named variables.
final pointC = PointC.named(x: 2.0, y: 2.0);
// #enddocregion initialize-named

// #docregion initialize-null
class PointD {
  double? x; // null if not set in constructor
  double? y; // null if not set in constructor

  // Generative constructor with initializing formal parameters
  PointD(this.x, this.y);

  @override
  String toString() {
    return 'PointD($x,$y)';
  }
}

// #enddocregion initialize-null
final class Candidate {
  String name = '';
  int yearsExperience = 0;

  void interview() {}
}

void miscDeclAnalyzedButNotTested() {
  final candidates = <Candidate>[];

  {
    // #docregion collection
    for (var candidate in candidates) {
      candidate.interview();
    }
    // #enddocregion collection
  }

  {
    // #docregion collection-for-pattern
    for (final Candidate(:name, :yearsExperience) in candidates) {
      print('$name has $yearsExperience of experience.');
    }
    // #enddocregion collection-for-pattern


lue} =    Get Property    ${elem} >> option    value\n
\n
Comment >>
", "shortdoc": "Returns a reference to Playwright [https://playwright.dev/docs/api/class-locator|Locator] for all matched elements by ``selector``.", "tags": ["Getter", "PageContent"], "source": "/Users/tatuaalto/workspace/robotframework-playwright/Browser/keywords/getters.py", "lineno": 870}, {"name": "Get Page Errors", "args": [{"name": "assertion_operator", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "AssertionOperator", "typedoc": "AssertionOperator", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "assertion_operator: AssertionOperator | None = None"}, {"name": "assertion_expected", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "Any", "typedoc": "Any", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "assertion_expected: Any | None = None"}, {"name": "message", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "message: str | None = None"}, {"name": "", "type": null, "defaultValue": null, "kind": "NAMED_ONLY_MARKER", "required": false, "repr": "*"}, {"name": "full", "type": {"name": "bool", "typedoc": "boolean", "nested": [], "union": false}, "defaultValue": "False", "kind": "NAMED_ONLY", "required": false, "repr": "full: bool = False"}, {"name": "last", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "int", "typedoc": "integer", "nested": [], "union": false}, {"name": "timedelta", "typedoc": "timedelta", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "NAMED_ONLY", "required": false, "repr": "last: int | timedelta | None = None"}], "returnType": {"name": "dict", "typedoc": "dictionary", "nested": [], "union": false}, "doc": "
Returns the page errors of the active page.
\n
If assertions are used and fail, this keyword will fail immediately without retrying.
\n
\n
\nArguments	\nDescription	\n
\n
\nassertion_operator	\nOptional assertion operator. See Assertions for more information.	\n
\n
\nassertion_expected	\nOptional expected value. See Assertions for more information.	\n
\n
\nmessage	\nOptional custom message to use on failure. See Assertions for more information


")]
        public ulong SteamId { get; set; }

        [JsonProperty("gameName")]
        public string GameName { get; set; }

        [JsonProperty("achievements")]
        public IList<PlayerAchievement> Achievements { get; set; }

        [JsonProperty("success")]
        public bool Success { get; set; }

        [JsonProperty("error")]
        public string ErrorMessage { get; set; }
    }

    internal class PlayerAchievementResultContainer
    {
        [JsonProperty("playerstats")]
        public PlayerAchievementResult Result { get; set; }
    }
}


           SystemFlag.BLOODSTAIN: self.blood_system,
            SystemFlag.CONTROLLER: self.controller_system,
            SystemFlag.ANIMATIONSTATE: self.state_system,
            SystemFlag.MOVEMENT: self.movement_system,
            SystemFlag.GRAPHICS: self.graphics_system,
            SystemFlag.COLLISION: self.collision_system,
            SystemFlag.LOGIC: self.logic_system,
        }

        for flag, system in systems.items():
            if flag in entity.flags:
                system.append(entity)

    def destroy_entites(self):
        systems = {
            SystemFlag.AICONTROLLER: self.ai_controller_system,
            SystemFlag.AUDIO: self.audio_system,
            SystemFlag.BLOODSTAIN: self.blood_system,
            SystemFlag.CONTROLLER: self.controller_system,
            SystemFlag.ANIMATIONSTATE: self.state_system,
            SystemFlag.MOVEMENT: self.movement_system,
            SystemFlag.GRAPHICS: self.graphics_system,
            SystemFlag.COLLISION: self.collision_system,
            SystemFlag.LOGIC: self.logic_system,
        }
        entities = [e for e in state_system if e.state.value == State.destroy]
        for entity in entities:
            for flag, system in systems.items():
                if flag in entity.flags:
                    system.remove(entity)


  Future<List<EnqueueOneshotResult>> enqueueOneshot(
    List<String> trackNumbersList,
  ) async {
    final resultList = <EnqueueOneshotResult>[];
    final filteredList = <TrackNumberService>[];
    for (final trackNumber in trackNumbersList) {
      final state = await _trackingLimiter.check(trackNumber);
      await state.when(
        allowed: (trackNumber) async {
          final res = await _trackRepo.getTrackNumberServices(trackNumber);
          res.when(
            (trackServiceList) {
              filteredList.addAll(trackServiceList);
              resultList.add(EnqueueOneshotResult.success(
                trackNumber: trackNumber,
              ));
            },
            error: (e) {
              resultList.add(EnqueueOneshotResult.error(
                trackNumber: trackNumber,
                error: EnqueueOneshotError.storage(e),
              ));
            },
          );
        },
        dissalowed: (trackNumber, remainingTime) {
          resultList.add(EnqueueOneshotResult.dissalowed(
            trackNumber: trackNumber,
            remainingLimitTime: remainingTime,
          ));
        },
        error: (trackNumber, error) {
          resultList.add(EnqueueOneshotResult.error(
            trackNumber: trackNumber,
            error: EnqueueOneshotError.limiter(error),
          ));
        },
      );
    }

    if (filteredList.isNotEmpty) {
      _workerManager.tracking(trackNumberServiceList: filteredList);
    }
    if (await _pref.autoTracking) {
      _workerManager.trackingPeriodic(
        initialDelay: (await _pref.autoTrackingFreq).toDuration(),
      );
    }

    return resultList;
  }

  @override
  Future<void> enqueueOneshotAll() async {
    _workerManager.trackingAll();

    if (await _pref.autoTracking) {
      _workerManager.trackingPeriodic(
        initialDelay: (await _pref.autoTrackingFreq).toDuration(),
      );
    }
  }

  @override
  Future<void> reenqueueAll() async {
    if (await _pref.autoTracking) {
      _workerManager.trackingPeriodic(replaceIfEnqueued: true);
    }
  }
}
// Copyright (C) 2021-2024 Yaroslav Pronin <proninyaroslav@mail.ru>
// Copyright (C) 2021 Insurgo Inc. <insurgo@riseup.net>
//
// This file is part of LibreTrack.
//
// LibreTrack is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// LibreTrack is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with LibreTrack.  If not, see <http://www.gnu.org/licenses/>.

import 'package:enum_to_string/enum_to_string.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:freezed_annotation/freezed_annotation.dart';
import 'package:libretrack/core/crash_report/crash_report_manager.dart';
import 'package:libretrack/core/date_time_provider.dart';
import 'package:libretrack/core/entity/entity.dart';
import 'package:libretrack/core/platform_info.dart';
import 'package:libretrack/core/s


/ No downsampling.
        /// </summary>
        [pbr::OriginalName("DOWNSAMPLE_NONE")] DownsampleNone = 1,
        /// <summary>
        /// Downsizes the input frame such that frame_size == downsampling_size,
        /// where frame_size := max(width, height).
        /// </summary>
        [pbr::OriginalName("DOWNSAMPLE_TO_MAX_SIZE")] DownsampleToMaxSize = 2,
        /// <summary>
        /// Downsizes frame by pre-defined factor, downsample_factor below.
        /// </summary>
        [pbr::OriginalName("DOWNSAMPLE_BY_FACTOR")] DownsampleByFactor = 3,
        /// <summary>
        /// Downsampling based on downsampling schedule, see DownsampleSchedule below
        /// for details.
        /// </summary>
        [pbr::OriginalName("DOWNSAMPLE_BY_SCHEDULE")] DownsampleBySchedule = 4,
        /// <summary>
        /// Downsizes the input frame such that frame_size == downsampling_size,
        /// where frame_size := min(width, height).
        /// </summary>
        [pbr::OriginalName("DOWNSAMPLE_TO_MIN_SIZE")] DownsampleToMinSize = 5,
        /// <summary>
        /// Input frame is assumed to be already downsampled by the factor specified
        /// by downsample_factor below. For example if the original frame is 720p,
        /// and downsample_factor is set to 2.0, then we expect as input 360p.
        /// </summary>
        [pbr::OriginalName("DOWNSAMPLE_TO_INPUT_SIZE")] DownsampleToInputSize = 6,
      }

      public enum GainCorrectMode {
        /// <summary>
        /// Uses default or user supplied bounds,
        /// </summary>
        [pbr::OriginalName("GAIN_CORRECT_DEFAULT_USER")] GainCorrectDefaultUser = 1,
        /// <summary>
        /// i.e. gain_bias_bounds is left untouched.
        /// </summary>
        [pbr::OriginalName("GAIN_CORRECT_VIDEO")] GainCorrectVideo = 2,
        /// <summary>
        /// Uses most relaxed settings to track
        /// </summary>
        [pbr::OriginalName("GAIN_CORRECT_HDR")] GainCorrectHdr = 3,
        /// <summary>
        /// across HDR frames, taken at different
        /// exposures.
        /// </summary>
        [pbr::OriginalName("GAIN_CORRECT_PHOTO_BURST")] GainCorrectPhotoBurst = 4,
      }

      /// <summary>
      /// Supported image formats. All images are converted to grayscale
      /// before processing. These image formats only concern AddImage.
      /// IMPORTANT: All the Retrieve* methods expect RGB when the descriptors
      /// are computed.
      /// </summary>
      public enum ImageFormat {
        [pbr::OriginalName("FORMAT_GRAYSCALE")] FormatGrayscale = 1,
        [pbr::OriginalName("FORMAT_RGB")] FormatRgb = 2,
        [pbr::OriginalName("FORMAT_RGBA")] FormatRgba = 3,
        [pbr::OriginalName("FORMAT_BGR")] FormatBgr = 4,
        [pbr::OriginalName("FORMAT_BGRA")] FormatBgra = 5,
      }

      public enum DescriptorExtractorType {
        /// <summary>
        /// http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.370.4395&rep=rep1&type=pdf
        /// </summary>
        [pbr::OriginalName("ORB")] Orb = 0,
      }

      /// <summary>
      /// Downsampling schedule. Frame sizes up to which a particular downsampling
      /// factor is applied. Factor chosen by comparing actual frame area against
      /// standard area (standard_width * standard_height), where standard_width =
      /// 16/9 X standard_height.
      /// </summary>
      public sealed partial class DownSampleSchedule : pb::IMessage<DownSampleSchedule>
      #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
          , pb::IBufferMessage
      #endif
      {
        private static readonly pb::MessageParser<DownSampleSchedule> _parser = new pb::MessageParser<DownSampleSchedule>(()


atomic.StoreUint64(&d.Allocated, uint64(allocatedSize))
	//  unallocated = math.Max(0, total - allocatedSize)
	unallocated := total - allocatedSize
	if unallocated < 0 {
		unallocated = 0
	}
	if d.Available <= 0 {
		d.RejectWrite = true
	} else {
		d.RejectWrite = false
	}
	d.Unallocated = uint64(unallocated)

	log.LogDebugf("action[computeUsage] disk(%v) all(%v) available(%v) used(%v)", d.Path, d.Total, d.Available, d.Used)

	return
}

func (d *Disk) repairAllocSize() int {
	allocSize := 0
	for _, dp := range d.partitionMap {
		if dp.DataPartitionCreateType == proto.NormalCreateDataPartition || dp.leaderSize <= dp.used {
			continue
		}

		allocSize += dp.leaderSize - dp.used
	}

	return allocSize
}

func (d *Disk) incReadErrCnt() {
	atomic.AddUint64(&d.ReadErrCnt, 1)
}

func (d *Disk) getReadErrCnt() uint64 {
	return atomic.LoadUint64(&d.ReadErrCnt)
}

func (d *Disk) incWriteErrCnt() {
	atomic.AddUint64(&d.WriteErrCnt, 1)
}

func (d *Disk) getWriteErrCnt() uint64 {
	return atomic.LoadUint64(&d.WriteErrCnt)
}

func (d *Disk) getTotalErrCnt() uint64 {
	return d.getReadErrCnt() + d.getWriteErrCnt()
}

func (d *Disk) startScheduleToUpdateSpaceInfo() {
	go func() {
		updateSpaceInfoTicker := time.NewTicker(5 * time.Second)
		checkStatusTicker := time.NewTicker(time.Minute * 2)
		defer func() {
			updateSpaceInfoTicker.Stop()
			checkStatusTicker.Stop()
		}()
		for {
			select {
			case <-updateSpaceInfoTicker.C:
				d.computeUsage()
				d.updateSpaceInfo()
			case <-checkStatusTicker.C:
				d.checkDiskStatus()
			}
		}
	}()
}

func (d *Disk) doBackendTask() {
	for {
		partitions := make([]*DataPartition, 0)
		d.RLock()
		for _, dp := range d.partitionMap {
			partitions = append(partitions, dp)
		}
		d.RUnlock()
		for _, dp := range partitions {
			dp.extentStore.BackendTask()
		}
		time.Sleep(time.Minute)
	}
}

const (
	DiskStatusFile = ".diskStatus"
)

func (d *Disk) checkDiskStatus() {
	if d.Status == proto.Unavailable {
		log.LogInfof("[checkDiskStatus] disk status is unavailable, no need to check, disk path(%v)", d.Path)
		return
	}
	path := path.Join(d.Path, DiskStatusFile)
	fp, err := os.OpenFile(path, os.O_TRUNC|os.O_RDWR, 0o755)
	if err != nil {
		d.CheckDiskError(err, ReadFlag)
		return
	}
	defer fp.Close()
	data := []byte(DiskStatusFile)
	_, err = fp.WriteAt(data, 0)
	if err != nil {
		d.CheckDiskError(err, WriteFlag)
		return
	}
	if err = fp.Sync(); err != nil {
		d.CheckDiskError(err, WriteFlag)
		return
	}
	if _, err = fp.ReadAt(data, 0); err != nil {
		d.CheckDiskError(err, ReadFlag)
		return
	}
}

const DiskErrNotAssociatedWithPartition uint64 = 0 // use 0 for disk error without any data partition


 '../item';
import { LootGen } from '../lootgen';

export class Or implements Token {

    constructor(
        private tokens: Token[],
        private chances: number[]
    ) {}

    public gen(item: Item, masculine: boolean, plural: boolean, vowel: boolean, p: Price): string {
        // choose one at random
        return this.tokens[LootGen.randomIndexWithChancesArray(this.chances)].gen(item, masculine, plural, vowel, p);
    }

}
import {Listener} from '../../modules/Listener'
import {Writable} from 'stream'
import {ParsedError, parseError} from '../../utils/parseError'

export interface Logger4InterfaceV2 {
  debug: (log: string, ...params: any[]) => void
  info: (log: string, ...params: any[]) => void
  custom: (tag: string, log: string, ...params: any[]) => void
  error: (error: Error, ...params: any[]) => void
  warn: (log: string, ...params: any[]) => void
  success: (log: string, ...params: any[]) => void
  track: (...params: any[]) => void
  onStream: (tag: string, stream: Writable) => void
  print: (tag: string, log: string) => void
}

type Streams = Record<string, {
  id: number
  streams: Record<string, Writable>
}>

export type Logger4V2Constructor = {
  log?: (code: ParsedError, tag: string, log: string, ...params: any[]) => string
  error?: (code: ParsedError, error: ParsedError, ...params: any[]) => string
}

export class Logger4V2 extends Listener implements Logger4InterfaceV2 {
  streams: Streams = {}
  params = {
    log: (code: ParsedError, tag: string, log: string, ...params: any[]) => {
      return `${new Date().toISOString()};${tag};${code.stack[1]};${log}${params.length > 0 ? ';' + JSON.stringify({params}) : ''}`
    },
    error: (code: ParsedError, error: ParsedError, ...params: any[]) => {
      return `${new Date().toISOString()};error;${code.stack[1]};${error.message};${JSON.stringify({
        stack: error.stack,
        params: error.params
      })}${params.length > 0 ? ';' + JSON.stringify({params}) : ''}`
    },
  }

  constructor(params: Logger4V2Constructor = {}) {
    super()
    if (params.log) {
      this.params.log = params.log
    }
    if (params.error) {
      this.params.error = params.error
    }
  }

  private push(tag: string, log: string) {
    if (this.streams[tag]) {
      for (const [id, writable] of Object.entries(this.streams[tag].streams)) {
        writable.write(log)
      }
    }
  }

  private log(code: ParsedError, tag: string, log: string, ...params: any[]) {
    this.push(tag, this.params.log(code, tag, log, ...params))
    try {
      this.callListener(`onLog_${tag}`, [code, tag, log, ...params])
    } catch (e) {
      console.error(this.params.error(code, e))
    }
  }

  track(...params: any) {
    return this.push('track', `${new Date().toISOString()};${JSON.stringify(parseError(new Error('')).stack.slice(1,3))};${params.length > 0 ? JSON.stringify(params) : ''}`)
  }

  debug(log: string, ...params: any[]) {
    return this.log(parseError(new Error('')), 'debug', log, ...params)
  }

  info(log: string, ...params: any[]) {
    return this.log(parseError(new Error('')), 'info', log, ...params)
  }

  custom(tag: string, log:


on)
          elif "photo" == x["type"]:
                photo = x["photo"]
                caption = x["caption"]
                return await message.reply_photo(photo=photo, caption=caption)
          elif "document" == x["type"]:
                document = x["document"]
                caption = x["caption"]
                return await message.reply_document(document=document, caption=caption)
          elif "text" == x["type"]:
                text = x["text"]
                return await message.reply_text(text=text)
          elif "voice" == x["type"]:
                voice = x["voice"]
                caption = x["caption"]
                return await message.reply_voice(voice=voice)
          elif "sticker" == x["type"]:
                sticker = x["sticker"]
                return await message.reply_sticker(sticker=sticker)
          else: return await message.reply_text("can't send this Note  >`{}`<".format(note_name))
     else: return


Value>;

      #[allow(unreachable_patterns)]
      fn $fn(self) -> Result<Value> {
        use Value::*;
        match self {
          $($value $(if $guard)? => Ok($result),)*
          value => Err(Error::InvalidOperand {
            op: OpCode::$op,
            value: value.clone()
          }),
        }
      }
    }

    impl_ops!($($tail)*);
  };

  (
    impl $trait:ident $fn:ident $op:ident {
      $(
        $left:pat, $right:pat => $result:expr
      ),* $(,)?
    }

    $($tail:tt)*
  ) => {
    impl std::ops::$trait for Value {
      type Output = Result<Value>;

      fn $fn(self, other: Value) -> Result<Value> {
        use Value::*;
        match (self, other) {
          $(($left, $right) => Ok($result),)*
          (left, right) => Err(Error::InvalidOperands {
            op: OpCode::$op,
            left,
            right,
          })
        }
      }
    }

    impl_ops!($($tail)*);
  }
}

impl_ops! {
  impl Neg neg Neg {
    Integer(v) => Integer(-v),
    Float(v) => Float(-v),
  }

  impl Add add Add {
    Integer(a), Integer(b) => Integer(a + b),
    Integer(ref a), Float(b) => Float((*a as FloatType) + b),
    Float(a), Integer(ref b) => Float(a + (*b as FloatType)),
    Float(a), Float(b) => Float(a + b),
    String(ref a), String(ref b) => String(concat(a, b)),
    String(ref a), b => String(concat(a, &b.to_string())),
    a, String(ref b) => String(concat(&a.to_string(), b)),
  }

  impl Sub sub Sub {
    Integer(a), Integer(b) => Integer(a - b),
    Integer(ref a), Float(b) => Float((*a as FloatType) - b),
    Float(a), Integer(ref b) => Float(a - (*b as FloatType)),
    Float(a), Float(b) => Float(a - b),
  }

  impl Mul mul Mul {
    Integer(a), Integer(b) => Integer(a * b),
    Integer(ref a), Float(b) => Float((*a as FloatType) * b),
    Float(a), Integer(ref b) => Float(a * (*b as FloatType)),
    Float(a), Float(b) => Float(a * b),
  }

  impl Div div Div {
    Integer(a), Integer(b) => Integer(a / b),
    Integer(ref a), Float(b) => Float((*a as FloatType) / b),
    Float(a), Integer(ref b) => Float(a / (*b as FloatType)),
    Float(a), Float(b) => Float(a / b),
  }

  impl Rem rem Mod {
    Integer(a), Integer(b) => Integer(a % b),
    Integer(ref a), Float(b) => Float((*a as FloatType) % b),
    Float(a), Integer(ref b) => Float(a % (*b as FloatType)),
    Float(a), Float(b) => Float(a % b),
  }

  impl BitAnd bitand And {
    Integer(a), Integer(b) => Integer(a & b),
  }

  impl BitOr bitor Or {
    Integer(a), Integer(b) => Integer(a | b),
  }

  impl BitXor bitxor Xor {
    Integer(a), Integer(b) => Integer(a ^ b),
  }

  impl Shl shl Shl {
    Integer(a), Integer(b) => Integer(a << b),
  }

  impl Shr shr Shr {
    Integer(a), Integer(b) => Integer(a >> b),
  }

  impl Not not Not {
    Nil | Boolean(false) | Integer(0) => Boolean(true),
    Float(ref v) if *v


1){var o=a[i];X(o)?n.push(this.canonicalizeTileURL(o,r)):n.push(o)}return n},Z.prototype._makeAPIURL=function(t,e){var r="See https://www.mapbox.com/api-documentation/#access-tokens-and-token-scopes",n=J(j.API_URL);if(t.protocol=n.protocol,t.authority=n.authority,"http"===t.protocol){var i=t.params.indexOf("secure");i>=0&&t.params.splice(i,1)}if("/"!==n.path&&(t.path=""+n.path+t.path),!j.REQUIRE_ACCESS_TOKEN)return K(t);if(!(e=e||j.ACCESS_TOKEN))throw new Error("An API access token is required to use Mapbox GL. "+r);if("s"===e[0])throw new Error("Use a public access token (pk.*) with Mapbox GL, not a secret access token (sk.*). "+r);return t.params=t.params.filter((function(t){return-1===t.indexOf("access_token")})),t.params.push("access_token="+e),K(t)};var Y=/^((https?:)?\/\/)?([^\/]+\.)?mapbox\.c(n|om)(\/|\?|$)/i;function X(t){return Y.test(t)}var $=/^(\w+):\/\/([^/?]*)(\/[^?]+)?\??(.+)?/;function J(t){var e=t.match($);if(!e)throw new Error("Unable to parse URL object");return{protocol:e[1],authority:e[2],path:e[3]||"/",params:e[4]?e[4].split("&"):[]}}function K(t){var e=t.params.length?"?"+t.params.join("&"):"";return t.protocol+"://"+t.authority+t.path+e}var Q="mapbox.eventData";function tt(t){if(!t)return null;var e,r=t.split(".");if(!r||3!==r.length)return null;try{return JSON.parse((e=r[1],decodeURIComponent(s.atob(e).split("").map((function(t){return"%"+("00"+t.charCodeAt(0).toString(16)).slice(-2)})).join(""))))}catch(t){return null}}var et=function(t){this.type=t,this.anonId=null,this.eventData={},this.queue=[],this.pendingRequest=null};et.prototype.getStorageKey=function(t){var e,r,n=tt(j.ACCESS_TOKEN);return e=n&&n.u?(r=n.u,s.btoa(encodeURIComponent(r).replace(/%([0-9A-F]{2})/g,(function(t,e){return String.fromCharCode(Number("0x"+e))})))):j.ACCESS_TOKEN||"",t?Q+"."+t+":"+e:Q+":"+e},et.prototype.fetchEventData=function(){var t=I("localStorage"),e=this.getStorageKey(),r=this.getStorageKey("uuid");if(t)try{var n=s.localStorage.getItem(e);n&&(this.eventData=JSON.parse(n));var i=s.localStorage.getItem(r);i&&(this.anonId=i)}catch(t){k("Unable to read from LocalStorage")}},et.prototype.saveEventData=function(){var t=I("localStorage"),e=this.getStorageKey(),r=this.getStorageKey("uuid");if(t)try{s.localStorage.setItem(r,this.anonId),Object.keys(this.eventData).length>=1&&s.localStorage.setItem(e,JSON.stringify(this.eventData))}catch(t){k("Unable to write to LocalStorage")}},et.prototype.processRequests=function(t){},et.protot


FFF
  //         |
}

template <class _AlgPolicy, class _Predicate, class _BidirectionalIterator>
_LIBCPP_HIDE_FROM_ABI _BidirectionalIterator __stable_partition_impl(
    _BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, bidirectional_iterator_tag) {
  typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
  typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
  const difference_type __alloc_limit = 4; // might want to make this a function of trivial assignment
  // Either prove all true and return __first or point to first false
  while (true) {
    if (__first == __last)
      return __first;
    if (!__pred(*__first))
      break;
    ++__first;
  }
  // __first points to first false, everything prior to __first is already set.
  // Either prove [__first, __last) is all false and return __first, or point __last to last true
  do {
    if (__first == --__last)
      return __first;
  } while (!__pred(*__last));
  // We now have a reduced range [__first, __last]
  // *__first is known to be false
  // *__last is known to be true
  // __len >= 2
  difference_type __len = _IterOps<_AlgPolicy>::distance(__first, __last) + 1;
  pair<value_type*, ptrdiff_t> __p(0, 0);
  unique_ptr<value_type, __return_temporary_buffer> __h;
  if (__len >= __alloc_limit) {
    // TODO: Remove the use of std::get_temporary_buffer
    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
    __p = std::get_temporary_buffer<value_type>(__len);
    _LIBCPP_SUPPRESS_DEPRECATED_POP
    __h.reset(__p.first);
  }
  return std::__stable_partition_impl<_AlgPolicy, _Predicate&>(
      std::move(__first), std::move(__last), __pred, __len, __p, bidirectional_iterator_tag());
}

template <class _AlgPolicy, class _Predicate, class _ForwardIterator, class _IterCategory>
_LIBCPP_HIDE_FROM_ABI _ForwardIterator __stable_partition(
    _ForwardIterator __first, _ForwardIterator __last, _Predicate&& __pred, _IterCategory __iter_category) {
  return std::__stable_partition_impl<_AlgPolicy, __remove_cvref_t<_Predicate>&>(
      std::move(__first), std::move(__last), __pred, __iter_category);
}

template <class _ForwardIterator, class _Predicate>
inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator
stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
  using _IterCategory = typename iterator_traits<_ForwardIterator>::iterator_category;
  return std::__stable_partition<_ClassicAlgPolicy, _Predicate&>(
      std::move(__first), std::move(__last), __pred, _IterCategory());
}

_LIBCPP_END_NAMESPACE_STD

_LIBCPP_POP_MACROS

#endif // _LIBCPP___ALGORITHM_STABLE_PARTITION_H


import reflex as rx
from bharteeai.utils.jdoodle import execute_code

class InterviewState(rx.State):
    code: str = ""
    language: str = "python3"
    output: str = ""

    def execute_code(self):
        result = execute_code(self.code, self.language)
        self.output = result.get("output", "Error executing code")

def interview():
    return rx.vstack(
        rx.heading("Coding Interview"),
        rx.select(
            ["python3", "java", "cpp", "javascript"],
            placeholder="Select language",
            on_change=InterviewState.set_language
        ),
        rx.text_area(
            placeholder="Write your code here",
            on_change=InterviewState.set_code,
            height="200px"
        ),
        rx.button("Run Code", on_click=InterviewState.execute_code),
        rx.text_area(
            InterviewState.output,
            placeholder="Output will appear here",
            is_read_only=True,
            height="100px"
        ),
        width="100%",
        padding="20px",
    )


_manual_wheelchair_facing_right_tone4"]::before {
  background-image: url("https://cdn.jsdelivr.net/gh/jdecked/twemoji@latest/assets/svg/1f468-1f3fe-200d-1f9bd-200d-27a1-fe0f.svg");
}
em[data-emoji=":man_in_manual_wheelchair_facing_right_tone5:"]::before,
em[data-emoji="man_in_manual_wheelchair_facing_right_tone5"]::before {
  background-image: url("https://cdn.jsdelivr.net/gh/jdecked/twemoji@latest/assets/svg/1f468-1f3ff-200d-1f9bd-200d-27a1-fe0f.svg");
}
em[data-emoji=":woman_in_manual_wheelchair_facing_right:"]::before,
em[data-emoji="woman_in_manual_wheelchair_facing_right"]::before {
  background-image: url("https://cdn.jsdelivr.net/gh/jdecked/twemoji@latest/assets/svg/1f469-200d-1f9bd-200d-27a1-fe0f.svg");
}
em[data-emoji=":woman_in_manual_wheelchair_facing_right_tone1:"]::before,
em[data-emoji="woman_in_manual_wheelchair_facing_right_tone1"]::before {
  background-image: url("https://cdn.jsdelivr.net/gh/jdecked/twemoji@latest/assets/svg/1f469-1f3fb-200d-1f9bd-200d-27a1-fe0f.svg");
}
em[data-emoji=":woman_in_manual_wheelchair_facing_right_tone2:"]::before,
em[data-emoji="woman_in_manual_wheelchair_facing_right_tone2"]::before {
  background-image: url("https://cdn.jsdelivr.net/gh/jdecked/twemoji@latest/assets/svg/1f469-1f3fc-200d-1f9bd-200d-27a1-fe0f.svg");
}
em[data-emoji=":woman_in_manual_wheelchair_facing_right_tone3:"]::before,
em[data-emoji="woman_in_manual_wheelchair_facing_right_tone3"]::before {
  background-image: url("https://cdn.jsdelivr.net/gh/jdecked/twemoji@latest/assets/svg/1f469-1f3fd-200d-1f9bd-200d-27a1-fe0f.svg");
}
em[data-emoji=":woman_in_manual_wheelchair_facing_right_tone4:"]::before,
em[data-emoji="woman_in_manual_wheelchair_facing_right_tone4"]::before {
  background-image: url("https://cdn.jsdelivr.net/gh/jdecked/twemoji@latest/assets/svg/1f469-1f3fe-200d-1f9bd-200d-27a1-fe0f.svg");
}
em[data-emoji=":woman_in_manual_wheelchair_facing_right_tone5:"]::before,
em[data-emoji="woman_in_manual_wheelchair_facing_right_tone5"]::before {
  background-image: url("https://cdn.jsdelivr.net/gh/jdecked/twemoji@latest/assets/svg/1f469-1f3ff-200d-1f9bd-200d-27a1-fe0f.svg");
}
em[data-emoji=":person_in_motorized_wheelchair:"]::before,
em[data-emoji="person_in_motorized_wheelchair"]::before {
  background-image: url("https://cdn.jsdeliv


DigitalWrite(MosiPin, data & (1 << bit));
    fastDigitalWrite(SckPin,
                     MODE_CPHA(Mode) ? MODE_CPOL(Mode) : !MODE_CPOL(Mode));
    nop;
    nop;
    if (!MODE_CPHA(Mode)) {
      fastDigitalWrite(SckPin, MODE_CPOL(Mode));
    }
  }
  //----------------------------------------------------------------------------
  inline __attribute__((always_inline))
  void transferBit(uint8_t bit, uint8_t* rxData, uint8_t txData) {
    if (MODE_CPHA(Mode)) {
      fastDigitalWrite(SckPin, !MODE_CPOL(Mode));
    }
    fastDigitalWrite(MosiPin, txData & (1 << bit));
    fastDigitalWrite(SckPin,
                     MODE_CPHA(Mode) ? MODE_CPOL(Mode) : !MODE_CPOL(Mode));
    if (fastDigitalRead(MisoPin)) {
      *rxData |= 1 << bit;
    }
    if (!MODE_CPHA(Mode)) {
      fastDigitalWrite(SckPin, MODE_CPOL(Mode));
    }
  }
  //----------------------------------------------------------------------------
};
#endif  // SoftSPI_h
/** @} */


href="../../../Number.html">Number, rotation:Number):Matrix

	  Utility function to create a rotated gradient matrix.
	ProgrammaticSkin

updateDisplayList(unscaledWidth:Number, unscaledHeight:Number):void

	  Programmatically draws the graphics for this skin.
	ProgrammaticSkin

verticalGradientMatrix(x:Number, y:Number, width:Number, height:Number):Matrix

	  Utility function to create a vertical gradient matrix.
	ProgrammaticSkin

Events

Click for more information on events

 Hide Inherited Events

 Show Inherited Events

 	Event	 Summary 	Defined By

<a href="../../../flash/events/EventDispatcher.html#event:activate#event:activate" class="signatureLink


85c, 0x65ca8943, 0xf6f1ff0e,
    0xedc79354, 0x09122436, 0xbb6bd6bd, 0x264c98d4,
    0x831b362d, 0xebcb8b40, 0x6fdea17f, 0x811f3e21,
    0x04081018, 0x6ad4b561, 0x43861197, 0x01020406,
    0x172e5c72, 0xe1dfa37c, 0x87132635, 0xf5f7f304,
    0x8d070e09, 0xe3dbab70, 0x23468cca, 0x801d3a27,
    0x44880d85, 0x162c5874, 0x66cc8549, 0x214284c6,
    0xfee1df3e, 0xd5b773c4, 0x3162c4a6, 0xd9af43ec,
    0x356ad4be, 0x18306050, 0x0204080c, 0x64c88d45,
    0xf2f9ef16, 0xf1ffe31c, 0x56ac45e9, 0xcd871394,
    0x8219322b, 0xc88d078a, 0xba69d2bb, 0xf0fde71a,
    0xefc39b58, 0xe9cf834c, 0xe8cd874a, 0xfde7d334,
    0x890f1e11, 0xd7b37bc8, 0xc7933ba8, 0xb577ee99,
    0xa455aaff, 0x2f5ebce2, 0x95376e59, 0x13264c6a,
    0x0b162c3a, 0xf3fbeb10, 0xe0dda77a, 0x376edcb2,
};

var T1 = [256]uint32{
    0x53a7f5a6, 0xbbd3d06b, 0xd1e66ebf, 0xe2713bd9,
    0xbdd0da67, 0x45accf8a, 0x9a4db329, 0xf2790bf9,
    0x743a9ce8, 0x8fc98c03, 0x3f91417e, 0xe5fc32d7,
    0x3c1e4478, 0x8e478f01, 0xa854e54d, 0x67bda9ce,
    0x058c0f0a, 0x57a5f9ae, 0xf47a01f5, 0xebfb20cb,
    0xc6635791, 0x6db8b7da, 0xa7ddf453, 0xb5d4c277,
    0xd7e564b3, 0x7bb38df6, 0x97c5a433, 0x61bea3c2,
    0x4fa9d19e, 0x0d88171a, 0x180c2830, 0x59a2ebb2,
    0x723996e4, 0xa3dff85b, 0x5229f6a4, 0xa9dae64f,
    0x562bfaac, 0x4da8d79a, 0x8bcb800b, 0x984cb52d,
    0x964ba731, 0x4422cc88, 0x49aadb92, 0x4824d890,
    0x82419b19, 0xe0703ddd, 0x51a6f3a2, 0xeff92cc3,
    0xb45ac175, 0xd9e276af, 0x7db087fa, 0x6c36b4d8,
    0xfa7d13e9, 0xd5e462b7, 0x6633aacc, 0xe3ff38db,
    0xc0605d9d, 0x4020c080, 0x10083020, 0x0b8b1d16,
    0xbc5ed965, 0


本**: 0.1.0
**Rust 版本**: 1.90
**Edition**: 2024
**Resolver**: 3
**报告日期**: 2025年1月

## 🎯 推进目标

### 主要目标

1. **充分利用 Rust 1.90 新特性**: 确保项目使用最新的语言特性
2. **提升代码质量**: 改进代码的可读性、可维护性和性能
3. **增强功能完整性**: 完善进程管理、IPC通信和同步原语功能
4. **优化用户体验**: 提供更好的API设计和错误处理

## ✅ 已完成任务

### 阶段 1: 基础特性更新 ✅

#### ✅ Rust 1.90 特性分析

- [x] 完成全面的特性使用情况分析
- [x] 创建详细的特性分析报告
- [x] 评估特性使用完整性

#### ✅ 新特性实现

- [x] 创建 `rust_190_features.rs` 模块
- [x] 实现异步闭包支持
- [x] 实现改进的模式匹配
- [x] 实现现代迭代器方法
- [x] 实现改进的错误处理
- [x] 实现改进的类型推断
- [x] 实现改进的宏系统
- [x] 集成标准库新特性

#### ✅ 演示程序

- [x] 创建 `rust_190_features_demo.rs` 演示程序
- [x] 展示所有 Rust 1.90 新特性
- [x] 提供完整的使用示例

#### ✅ 文档更新

- [x] 创建详细的特性分析报告
- [x] 制定项目推进计划
- [x] 更新 README 文档

### 阶段 2: 功能完善 ✅

#### ✅ 异步功能完善

- [x] 创建 `enhanced.rs` 异步运行时模块
- [x] 实现完整的异步进程管理
- [x] 实现异步闭包支持
- [x] 实现性能监控
- [x] 实现错误恢复机制
- [x] 实现资源限制和连接池
- [x] 创建 `enhanced_async_demo.rs` 演示程序

#### ✅ IPC通信优化

- [x] 创建 `enhanced.rs` IPC通信模块
- [x] 实现零拷贝数据传输
- [x] 实现高性能消息队列
- [x] 实现共享内存通信
- [x] 实现性能监控和统计
- [x] 实现智能错误恢复
- [x] 创建 `enhanced_ipc_demo.rs` 演示程序

## 🔄 进行中任务

### 阶段 3: 同步原语增强 (进行中)

#### 🔄 当前任务

- [ ] 增强同步原


DNSSec.

This is similar, but different than Andreas Steffen's pkix
implementation. I've based this work on Neil Dunbar's openssl-pkix patch
for FreeSWAN 1.1. I've updated it to run on FreeSWAN 1.5 correctly, and
added support for ID_DER_ASN1_DN ID packet support. It will do LDAP
certificate lookups no problem, as well as local flatfile, directory, or
DB lookup for testing or speed.

IE: It's a full CA-compatible client, capable of looking up, checking the
CRL for expiry and such. It will not only do the classic PSK and RSASIG
freeswan methods just fine, but also does PKIX's RSASIG, PKE and
RPKE. I've spent a lot of time adding RoadWarrior support for these last
IKE exchange methods.

The patch can be found as:
  ftp://ftp.netwinder.org/users/f/firesoul/freeswan-1.5-pkix_13.patch
There are also freeswan-1.5 - kernel 2.4 patches for those who need them.

Let me know. Feedback is appreciated.

 Older patches:

Neil Dunbar's patches for
 certificate  support, using code from
Open SSL.

patches
 to add Blowfish, IDEA and CAST-128 to FreeS/WAN

patches for aggressive  mode support

 These patches are for older versions of FreeS/WAN and will likely
not work with the current version.  Older versions of FreeS/WAN may be
available on some of the distribution sites
, but we recommend using the current release.

VPN masquerade patches

 Finally, there are some patches to other code that may be useful with
FreeS/WAN:

a
patch to make IPSEC, PPTP and SSH VPNs work through a Linux
firewall with IP masquerade.

Linux VPN Masquerade HOWTO

 Note that this is not required if the same machine does IPSEC and
masquerading, only if you want a to locate your IPSEC gateway on a
masqueraded network. See our firewalls document for
discussion of why this is problematic.

 At last report, this patch could not co-exist with FreeS/WAN on the
same machine.

Distributions including FreeS/WAN

The introductory section of our document set lists several
Linux distributions which include FreeS/WAN.

Things FreeS/WAN uses or could use

/dev/random support page,
 discussion of and code for the Linux


Load, SDep::Barrier);
            Dep.setLatency(1);
            SU.addPred(Dep);
            continue;
          }
          MachineMemOperand *MMO1 = *LdMI.memoperands_begin();
          MachineMemOperand *MMO2 = *MI.memoperands_begin();
          if (!MMO1->getValue() || !MMO2->getValue()) {
            SDep Dep(Load, SDep::Barrier);
            Dep.setLatency(1);
            SU.addPred(Dep);
            continue;
          }
          if (MMO1->getValue() == MMO2->getValue() &&
              MMO1->getOffset() <= MMO2->getOffset()) {
            SDep Dep(Load, SDep::Barrier);
            Dep.setLatency(1);
            SU.addPred(Dep);
            continue;
          }
          if (!AA->isNoAlias(
                  MemoryLocation::getAfter(MMO1->getValue(), MMO1->getAAInfo()),
                  MemoryLocation::getAfter(MMO2->getValue(),
                                           MMO2->getAAInfo()))) {
            SDep Dep(Load, SDep::Barrier);
            Dep.setLatency(1);
            SU.addPred(Dep);
          }
        }
      }
    }
  }
}

/// Update the phi dependences to the DAG because ScheduleDAGInstrs no longer
/// processes dependences for PHIs. This function adds true dependences
/// from a PHI to a use, and a loop carried dependence from the use to the
/// PHI. The loop carried dependence is represented as an anti dependence
/// edge. This function also removes chain dependences between unrelated
/// PHIs.
void SwingSchedulerDAG::updatePhiDependences() {
  SmallVector<SDep, 4> RemoveDeps;
  const TargetSubtargetInfo &ST = MF.getSubtarget<TargetSubtargetInfo>();

  // Iterate over each DAG node.
  for (SUnit &I : SUnits) {
    RemoveDeps.clear();
    // Set to true if the instruction has an operand defined by a Phi.
    unsigned HasPhiUse = 0;
    unsigned HasPhiDef = 0;
    MachineInstr *MI = I.getInstr();
    // Iterate over each operand, and we process the definitions.
    for (const MachineOperand &MO : MI->operands()) {
      if (!MO.isReg())
        continue;
      Register Reg = MO.getReg();
      if (MO.isDef()) {
        // If the register is used by a Phi, then create an anti dependence.
        for (MachineRegisterInfo::use_instr_iterator
                 UI = MRI.use_instr_begin(Reg),
                 UE = MRI.use_instr_end();
             UI != UE; ++UI) {
          MachineInstr *UseMI = &*UI;
          SUnit *SU = getSUnit(UseMI);
          if (SU != nullptr && UseMI->isPHI()) {
            if (!MI->isPHI()) {
              SDep Dep(SU, SDep::Anti, Reg);
              Dep.setLatency(1);
              I.addPred(Dep);
            } else {
              HasPhiDef = Reg;
              // Add a chain edge to a dependent Phi that isn't an existing
              // predecessor.
              if (SU->NodeNum < I.NodeNum && !I.isPred(SU))
                I.addPred(SDep(SU, SDep::Barrier));
            }
          }
        }
      } else if (MO.isUse()) {
        // If the register is defined by a Phi, then create a true dependence.
        MachineInstr *DefMI = MRI.getUniqueVRegDef(Reg);
        if (DefMI == nullptr)
          continue;
        SUnit *SU = getSUnit(DefMI);
        if (SU != nullptr && DefMI->isPHI()) {
          if (!MI->isPHI()) {
            SDep Dep(SU, SDep::Data, Reg);


 2 }
		local c = { 3 }

		local d = concatDeep(a, b, c)

		expect(#d).to.equal(3)
		expect(d[1]).to.equal(1)
		expect(d[2]).to.equal(2)
		expect(d[3]).to.equal(3)
	end)

	it("should accept zero tables", function()
		expect(concatDeep()).to.be.a("table")
	end)

	it("should accept holes in arguments", function()
		local a = { 1 }
		local b = { 2 }

		local c = concatDeep(a, nil, b)

		expect(#c).to.equal(2)
		expect(c[1]).to.equal(1)
		expect(c[2]).to.equal(2)

		local d = concatDeep(nil, a, b)

		expect(#d).to.equal(2)
		expect(d[1]).to.equal(1)
		expect(d[2]).to.equal(2)
	end)

	it("should join tables and copy subtables", function()
		local a = {
			"foo-a",
			{
				"bar-a",
				{
					"baz-a"
				}
			}
		}

		local b = {
			"foo-b",
			{
				"bar-b",
				{
					"baz-b"
				}
			}
		}

		local c = concatDeep(a, b)

		expect(c[1]).to.equal(a[1])
		expect(c[2]).never.to.equal(a[2])
		expect(c[3]).to.equal(b[1])
		expect(c[4]).never.to.equal(b[2])

		expect(c[2][1]).to.equal(a[2][1])
		expect(c[2][2]).never.to.equal(a[2][2])
		expect(c[4][1]).to.equal(b[2][1])
		expect(c[4][2]).never.to.equal(b[2][2])

		expect(c[2][2][1]).to.equal(a[2][2][1])
		expect(c[4][2][1]).to.equal(b[2][2][1])
	end)
end


parse('mm/dd/yyyy').value;
      expect(date, isParseSuccess('06/11/1980', result: DateTime(1980, 6, 11)));
      expect(date, isParseSuccess('08/24/1982', result: DateTime(1982, 8, 24)));
      expect(date, isParseFailure('Hello', message: 'digit expected'));
    });
  });
  test('stackoverflow.com/questions/64670722', () {
    final delimited = any().callCC<String>((continuation, context) {
      final delimiter = continuation(context).value.toParser();
      final parser = [
        delimiter,
        delimiter.neg().star().flatten(),
        delimiter,
      ].toSequenceParser().pick(1);
      return parser.parseOn(context);
    });
    expect(delimited, isParseSuccess('"hello"', result: 'hello'));
    expect(delimited, isParseSuccess('/hello/', result: 'hello'));
    expect(delimited, isParseSuccess(',hello,', result: 'hello'));
    expect(delimited, isParseSuccess('xhellox', result: 'hello'));
    expect(
      delimited,
      isParseFailure('abc', position: 3, message: '"a" expected'),
    );
  });
  test('function evaluator', () {
    final builder = ExpressionBuilder<Evaluator>();
    builder
      ..primitive(
        digit()
            .plus()
            .seq(char('.').seq(digit().plus()).optional())
            .flatten()
            .trim()
            .map((a) {
              final number = num.parse(a);
              return (num value) => number;
            }),
      )
      ..primitive(
        char('x').trim().map(
          (_) =>
              (value) => value,
        ),
      );
    builder.group().wrapper(char('(').trim(), char(')').trim(), (_, a, _) => a);
    // negation is a prefix operator
    builder.group().prefix(
      char('-').trim(),
      (_, a) =>
          (num value) => -a(value),
    );
    // power is right-associative
    builder.group().right(
      char('^').trim(),
      (a, _, b) =>
          (num value) => pow(a(value), b(value)),
    );
    // multiplication and addition are left-associative
    builder.group()
      ..left(
        char('*').trim(),
        (a, _, b) =>
            (num value) => a(value) * b(value),
      )
      ..left(
        char('/').trim(),
        (a, _, b) =>
            (num value) => a(value) / b(value),
      );
    builder.group()
      ..left(
        char('+').trim(),
        (a, _, b) =>
            (num value) => a(value) + b(value),
      )
      ..left(
        char('-').trim(),
        (a, _, b) =>
            (num value) => a(value) - b(value),
      );
    final parser = builder.build().end();

    final expression = parser.parse('5 * x ^ 3 - 2').value;
    expect(expression(-2), -42);
    expect(expression(-1), -7);
    expect(expression(0), -2);
    expect(expression(1), 3);
    expect(expression(2), 38);
  });
  test('stackoverflow.com/q/67617000/82303', () {
    expect(nestedParser, isParseSuccess('()', result: '()'));
    expect(nestedParser, isParseSuccess('(a)', result: '(a)'));
    expect(nestedParser, isParseSuccess('(a()b)', result: '(a()b)'));
    expect(nestedParser, isParseSuccess('(a(b)c)', result: '(a(b)c)'));
    expect(nestedParser, isParseSuccess('(a()b(cd))', result: '(a()b(cd))'));
  });
  group('github.com/petitparser/dart-petitparser/issues/109', () {
    // The digit defines how many characters ar


org/luci/analysis/proto/v1;analysispbb\x06proto3"

var (
	file_go_chromium_org_luci_analysis_proto_v1_test_variants_proto_rawDescOnce sync.Once
	file_go_chromium_org_luci_analysis_proto_v1_test_variants_proto_rawDescData []byte
)

func file_go_chromium_org_luci_analysis_proto_v1_test_variants_proto_rawDescGZIP() []byte {
	file_go_chromium_org_luci_analysis_proto_v1_test_variants_proto_rawDescOnce.Do(func() {
		file_go_chromium_org_luci_analysis_proto_v1_test_variants_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_go_chromium_org_luci_analysis_proto_v1_test_variants_proto_rawDesc), len(file_go_chromium_org_luci_analysis_proto_v1_test_variants_proto_rawDesc)))
	})
	return file_go_chromium_org_luci_analysis_proto_v1_test_variants_proto_rawDescData
}

var file_go_chromium_org_luci_analysis_proto_v1_test_variants_proto_msgTypes = make([]protoimpl.MessageInfo, 19)
var file_go_chromium_org_luci_analysis_proto_v1_test_variants_proto_goTypes = []any{
	(*QueryTestVariantFailureRateRequest)(nil),                     // 0: luci.analysis.v1.QueryTestVariantFailureRateRequest
	(*QueryTestVariantFailureRateResponse)(nil),                    // 1: luci.analysis.v1.QueryTestVariantFailureRateResponse
	(*TestVariantFailureRateAnalysis)(nil),                         // 2: luci.analysis.v1.TestVariantFailureRateAnalysis
	(*QueryTestVariantStabilityRequest)(nil),                       // 3: luci.analysis.v1.QueryTestVariantStabilityRequest
	(*QueryTestVariantStabilityResponse)(nil),                      // 4: luci.analysis.v1.QueryTestVariantStabilityResponse
	(*TestStabilityCriteria)(nil),                                  // 5: luci.analysis.v1.TestStabilityCriteria
	(*TestVariantStabilityAnalysis)(nil),                           // 6: luci.analysis.v1.TestVariantStabilityAnalysis
	(*QueryTestVariantFailureRateRequest_TestVariant)(nil),         // 7: luci.analysis.v1.QueryTestVariantFailureRateRequest.TestVariant
	(*QueryTestVariantFailureRateResponse_Interval)(nil),           // 8: luci.analysis.v1.QueryTestVariantFailureRateResponse.Interval
	(*TestVariantFailureRateAnalysis_IntervalStats)(nil),           // 9: luci.analysis.v1.TestVariantFailureRateAnalysis.IntervalStats
	(*TestVariantFailureRateAnalysis_VerdictExample)(nil),          // 10: luci.analysis.v1.TestVariantFailureRateAnalysis.VerdictExample
	(*TestVariantFailureRateAnalysis_RecentVerdict)(nil),


join(ws_dir, 'src')
            os.mkdir(src_dir)
            sys.argv = ['catkin_make_isolated', '-C', ws_dir]
            environ['CMAKE_PREFIX_PATH'] = os.path.join(ws_dir, 'install')
            main()
        except Exception as e:
            error_msg = str(e)
        finally:
            shutil.rmtree(ws_dir)
            sys.argv = argv
            os.environ = environ
            assert error_msg is None, error_msg

    def test_symlinked_src(self):
        argv = sys.argv
        environ = os.environ
        cwd = os.getcwd()
        error_msg = None
        try:
            base_dir = tempfile.mkdtemp()
            ws_dir = os.path.join(base_dir, 'ws')
            os.mkdir(ws_dir)
            other_dir = os.path.join(base_dir, 'other')
            os.mkdir(other_dir)
            src_dir = os.path.join(ws_dir, 'src')
            os.symlink(other_dir, src_dir)

            cmi = os.path.join(os.path.dirname(__file__), '..', '..', 'bin', 'catkin_make_isolated')
            environ['CMAKE_PREFIX_PATH'] = os.path.join(ws_dir, 'install')
            environ['PWD'] = src_dir
            subprocess.check_output(' '.join([sys.executable, cmi, '-C', '..']), cwd=src_dir, env=environ, shell=True)
        except Exception as e:
            error_msg = str(e)
        finally:
            shutil.rmtree(ws_dir)
            sys.argv = argv
            os.environ = environ
            os.chdir(cwd)
            assert error_msg is None, error_msg


о и то же приложение Discord для разработки и продакшена. Вы также можете рассмотреть [Mocking the Provider](https://github.com/trpc/trpc/blob/next/examples/next-prisma-starter-websockets/src/pages/api/auth/%5B...nextauth%5D.ts) во время разработки.

## Полезные ресурсы

| Ресурс                            | Ссылка                                  |
| --------------------------------- | --------------------------------------- |
| Документация NextAuth.js          | https://next-auth.js.org/               |
| NextAuth.js GitHub                | https://github.com/nextauthjs/next-auth |
| tRPC Kitchen Sink - with NextAuth | https://kitchen-sink.trpc.io/next-auth  |
---
title: Next.js
description: Utilisation de Next.js
layout: ../../../layouts/docs.astro
lang: fr
---

Next.js est un framework backend pour vos applications React.

Découvrez [Theo's Next.js Conf talk](https://www.youtube.com/watch?v=W4UhNo3HAMw) pour mieux comprendre ce qu'est Next.js et son fonctionnement.

## Pourquoi devrais-je l'utiliser ?

Nous aimons React. Il a rendu le développement des interfaces utilisateur accessible d'une manière que nous n'aurions jamais imaginée auparavant. Cela peut également conduire les développeurs sur des chemins difficiles. Next.js offre une approche légèrement opiniâtre et fortement optimisée pour créer des applications à l'aide de React. Du routage aux définitions d'API en passant par le rendu d'image, nous faisons confiance à Next.js pour guider les développeurs vers de bonnes décisions.

L'association de Next.js avec [Vercel](https://vercel.com/) facilite plus que jamais le développement et le déploiement d'applications Web. Leur offre gratuite est extrêmement généreuse et leurs interfaces sont super intuitives, fournissant une solution pointer-cliquer pour déployer votre site (Nous ❤ Vercel)

## Get Static/Server Props

Une des caractéristique clé de Next.js sont ses capacités de récupération de données. Nous vous recommandons vivement de lire la [documentation officielle](https://nextjs.org/docs/basic-features/data-fetching) pour comprendre comment utiliser chaque méthode et en quoi elles diffèrent. `getServerSideProps` est généralement déconseillé à moins qu'il n'y ait une bonne raison, car il s'agit d'un appel bloquant qui ralentira votre site. [Incremental Static Regeneration](https://nextjs.org/docs/basic-features/data-fetching/incremental


ل قول تکی چپ",rsquo:"علامت نقل قول تکی راست",ldquo:"علامت نقل قول دوتایی چپ",rdquo:"علامت نقل قول دوتایی راست",ndash:"خط تیره En",mdash:"خط تیره Em",iexcl:"علامت تعجب وارونه",cent:"نشان سنت",pound:"نشان پوند",curren:"نشان ارز",yen:"نشان ین",brvbar:"نوار شکسته",sect:"نشان بخش",uml:"نشان سواگیری",copy:"نشان کپی رایت",ordf:"شاخص ترتیبی مونث",laquo:"اشاره چپ مکرر برای زاویه علامت نقل قول",not:"نشان ثبت نشده",reg:"نشان ثبت شده",
macr:"نشان خط بالای حرف",deg:"نشان درجه",sup2:"بالانویس دو",sup3:"بالانویس سه",acute:"لهجه غلیظ",micro:"نشان مایکرو",para:"نشان محل بند",middot:"نقطه میانی",cedil:"سدیل",sup1:"بالانویس 1",ordm:"شاخص ترتیبی مذکر",raquo:"نشان زاویه‌دار دوتایی نقل قول راست چین",frac14:"واحد عامیانه 1/4",frac12:"واحد عامینه نصف",frac34:"واحد عامیانه 3/4",iquest:"علامت سوال معکوس",Agrave:"حرف A بزرگ لاتین با تلفظ غلیظ",Aacute:"حرف A بزرگ لاتین با تلفظ شدید",Acirc:"حرف A بزرگ لاتین با دور",Atilde:"حرف A بزرگ لاتین با صدای کامی",
Auml:"حرف A بزرگ لاتین با نشان سواگیری",Aring:"حرف A بزرگ لاتین با حلقه بالا",AElig:"حرف Æ بزرگ لاتین",Ccedil:"حرف C بزرگ لاتین با نشان سواگیری",Egrave:"حرف E بزرگ لاتین با تلفظ درشت",Eacute:"حرف E بزرگ لاتین با تلفظ زیر",Ecirc:"حرف E بزرگ لاتین با خمان",Euml:"حرف E بزرگ لاتین با نشان سواگیری",Igrave:"حرف I بزرگ لاتین با تلفظ درشت",Iacute:"حرف I بزرگ لاتین با تلفظ ریز",Icirc:"حرف I بزرگ لاتین با خمان",Iuml:"حرف I بزرگ لاتین با نشان سواگیری",ETH:"حرف لاتین بزرگ واکه ترتیبی",Ntilde:"حرف N بزرگ لاتین با مد",
Ograve:"حرف O بزرگ لاتین با تلفظ درشت",Oa


�立",
    ["𢘯"] = "宀匕心",
    ["𢘰"] = "土刀心",
    ["𢘱"] = "戊心",
    ["𢘲"] = "大心",
    ["𢘳"] = "禾心",
    ["𢘴"] = "卪心",
    ["𢘵"] = "夕卪心",
    ["𢘶"] = "忄聿",
    ["𢘷"] = "忄虫",
    ["𢘸"] = "忄夂㐄",
    ["𢘹"] = "忄㐅朩",
    ["𢘺"] = "忄米",
    ["𢘻"] = "米心",
    ["𢘼"] = "册心",
    ["𢘽"] = "忄曰㇂丿",
    ["𢘾"] = "忄女口",
    ["𢘿"] = "心",
    ["𢙀"] = "忄木冂",
    ["𢙁"] = "氵二ㄅ心",
    ["𢙂"] = "一皿心",
    ["𢙃"] = "忄日匕",
    ["𢙄"] = "龷八心",
    ["𢙅"] = "亼口心",
    ["𢙆"] = "忄自",
    ["𢙇"] = "忄衣",
    ["𢙈"] = "心口口",
    ["𢙉"] = "忄巛山",
    ["𢙊"] = "忄二欠",
    ["𢙋"] = "忄十",
    ["𢙌"] = "屮王心",
    ["𢙍"] = "囗口心",
    ["𢙎"] = "了又又心",
    ["𢙏"] = "子小心",
    ["𢙐"] = "忄冖",
    ["𢙑"] = "忄乛⺀大",
    ["𢙒"] = "忄一儿",
    ["𢙓"] = "忄人云",
    ["𢙔"] = "忄礻乚",
    ["𢙕"] = "忄亠",
    ["𢙖"] = "忄一囗人",
    ["𢙗"] = "忄亡女",
    ["𢙘"] = "忄耳",
    ["𢙙"] = "忄山一儿",
    ["𢙚"] = "忄⺈巴",
    ["𢙛"] = "忄夕口",
    ["𢙜"] = "忄⺇一巾",
    ["𢙝"] = "忄⺧儿",
    ["𢙞"] = "臣心",
    ["𢙟"] = "口刀丶心",
    ["𢙠"] = "亻丿心",
    ["𢙡"] = "行心",
    ["𢙢"] = "工口心",
    ["𢙣"] = "覀心",
    ["𢙤"] = "⺊一小心",
    ["𢙥"] = "丿囗人心",
    ["𢙦"] = "丿囗乂心",
    ["𢙧"] = "忄丨土儿",
    ["𢙨"] = "忄𠂇丨子",
    ["𢙩"] = "忄耒",
    ["𢙪"] = "忄文寸",
    ["𢙫"] =


/**
 * \file            lwesp_http_server_fs.h
 * \brief           Function declaration for file system
 */

/*
 * Copyright (c) 2024 Tilen MAJERLE
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * This file is part of LwESP - Lightweight ESP-AT parser library.
 *
 * Author:          Tilen MAJERLE <tilen@majerle.eu>
 * Version:         v1.1.2-dev
 */
#ifndef LWESP_HTTP_SERVER_FS_HDR_H
#define LWESP_HTTP_SERVER_FS_HDR_H

#include "lwesp/apps/lwesp_http_server.h"
#include "lwesp/lwesp.h"

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/**
 * \ingroup         LWESP_APP_HTTP_SERVER
 * \defgroup        LWESP_APP_HTTP_SERVER_FS_FAT FAT File System
 * \brief           FATFS file system implementation for dynamic files
 * \{
 */

uint8_t http_fs_open(http_fs_file_t* file, const char* path);
uint32_t http_fs_read(http_fs_file_t* file, void* buff, size_t btr);
uint8_t http_fs_close(http_fs_file_t* file);

/**
 * \}
 */

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* LWESP_HTTP_SERVER_HDR_H */


getAbsolutePath() + File.separator + "histogram." + name.toLowerCase());
        if (file.exists() == false) file = new File(file.getAbsolutePath() + ".gz");
        return (file);
    }

    public static Histogram<String> collapseAirportFlights(Map<String, ObjectHistogram<String>> m) {
        ObjectHistogram<String> h = new ObjectHistogram<String>();
        for (String depart : m.keySet()) {
            ObjectHistogram<String> depart_h = m.get(depart);
            for (String arrive : depart_h.values()) {
                String key = depart + "-" + arrive;
                h.put(key, depart_h.get(arrive));
            } // FOR (arrival airport)
        } // FOR (depart airport)
        return (h);
    }

    /**
     * Returns the Flights Per Airport Histogram
     * @param data_path
     * @return
     * @throws Exception
     */
    public static synchronized Map<String, Histogram<String>> loadAirportFlights(File data_path) throws Exception {
        if (cached_AirportFlights != null) return (cached_AirportFlights);

        File file = getHistogramFile(data_path, SEATSConstants.HISTOGRAM_FLIGHTS_PER_AIRPORT);
        ObjectHistogram<String> h = new ObjectHistogram<String>();
        h.load(file);

        Map<String, Histogram<String>> m = new TreeMap<String, Histogram<String>>();
        Pattern pattern = Pattern.compile("-");
        Collection<String> values = h.values();
        for (String value : values) {
            String split[] = pattern.split(value);
            Histogram<String> src_h = m.get(split[0]);
            if (src_h == null) {
                src_h = new ObjectHistogram<String>();
                m.put(split[0], src_h);
            }
            src_h.put(split[1], h.get(value));
        } // FOR

        cached_AirportFlights = m;
        return (m);
    }

    /**
     * Construct a histogram from an airline-benchmark data file
     * @param name
     * @param data_path
     * @param has_header
     * @return
     * @throws Exception
     */
    public static synchronized Histogram<String> loadHistogram(String name, File data_path, boolean has_header) throws Exception {
        File file = getHistogramFile(data_path, name);
        ObjectHistogram<String> histogram = (ObjectHistogram<String>)cached_Histograms.get(file);
        if (histogram == null) {
            histogram = new ObjectHistogram<String>();
            histogram.load(file);
            cached_Histograms.put(file, histogram);
        }
        if (LOG.isDebugEnabled())
            LOG.debug(String.format("Histogram %s\n%s", name, histogram.toString()));

        return (histogram);
    }

    public static File findDataDir() {
        File dataDir = null;
        try {
            File dir = FileUtil.findDirectory("src");
            assert(dir != null);
            assert(dir.exists()) : "Missing " + dir.getAbsolutePath();
            dataDir = new File(dir.getAbsolutePath() +
                               "/benchmarks/" +
                               SEATSClient.class.getPackage().getName().replace(".", "/") +
                               "/data");
            assert(dataDir.exists()) : "Missing " + dataDir.getAbsolutePath();
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
        return (dataDir);
    }
}
/*********************************************


] = "Coges el paquete y limpias la delgada capa de polvo y mugre que lo cubría. Está dirigido a una tal Emma Piedra Mácula de Ventormenta y parece que fue escrito apresuradamente. El envío está datado hace más de cuatro años.$B$BAunque no está claro si Emma Piedra Mácula sigue siquiera con vida, todo el mundo sabe que el Ayuntamiento de Ventormenta guarda un registro de la población de la ciudad. Se encargan de él los agentes reales del Censo de Ventormenta.",
    ["O"] = "Consulta con los agentes reales de Ventormenta para averiguar el paradero de una tal Emma Piedra Mácula. Suele haber un oficial del censo en el Ayuntamiento.",
    ["T"] = "Más vale tarde que nunca",
  },
  [5023] = {
    ["D"] = "Coges el paquete y limpias la delgada capa de polvo y mugre que lo cubría. Está dirigido a un tal Jeremiah Piedra Mácula de Lordaeron y parece que fue escrito apresuradamente. El envío está datado hace más de cuatro años.$B$BAunque no está claro si Jeremiah Piedra Mácula sigue siquiera con vida, todo el mundo sabe que Entrañas, antes conocido como Lordaeron, guarda un registro de la población de la ciudad. Se encargan de él los supervisores reales del Censo de Entrañas.",
    ["O"] = "Consulta con los supervisores reales de Entrañas para averiguar el paradero de Jeremiah Piedra Mácula. Suele haber un oficial del censo junto a la oficina de registro de hermandades y tabardos.",
    ["T"] = "Más vale tarde que nunca",
  },
  [5041] = {
    ["D"] = "Esa caravana que han asaltado transportaba suministros que necesitábamos desesperadamente.$B$BHasta ahora has demostrado el valor necesario para enfrentarte a la tribu Crines de Acero así que te pido que lo hagas una vez más, solo que esta vez tendrás que abrir bien los ojos por si ves nuestros suministros perdidos. Probablemente los encuentres por todos sus campamentos, los jabaespines estarán poniéndose las botas gracias a sus actos deshonestos.$B$BEl pueblo de El Cruce estará en deuda contigo.",
    ["O"] = "Encuentra los cajones de suministros de El Cruce y devuélveselos a Thork en Los Baldíos.",
    ["T"] = "Suministros para El Cruce",
  },
  [5042] = {
    ["D"] = "",
    ["O"] = "",
    ["T"] = "La fuerza de Agamaggan",
  },
  [5043] = {
    ["D"] = "",
    ["O"] = "",
    ["T"] = "La agilidad de Agamaggan",
  },
  [5044] = {
    ["D"] = "",
    ["O"] = "",
    ["T"] = "La sabiduría de Agamaggan",
  },
  [5045] = {
    ["D"] = "",
    ["O"] = "",
    ["T"] = "Fortaleza de espíritu",
  },
  [5046] = {
    ["D"] = "",
    ["O"] = "",
    ["T"] = "Cerropiel",
  },
  [5047] = {
    ["D"] = "“Encontrarás a Malyfous Martilloscuro en Vista Eterna, $c. Dile que “”Finkle está muy contento”” y que el traje funciona de perlas.$B$BEntonces entrégale esto:$B$B<Finkle te tiende un trozo de carne brillante.>$B$BEs un pedazo de las entrañ


{
    --tw-skew-y: -6deg;
  }

  .xl\:focus\:-skew-y-3:focus {
    --tw-skew-y: -3deg;
  }

  .xl\:focus\:-skew-y-2:focus {
    --tw-skew-y: -2deg;
  }

  .xl\:focus\:-skew-y-1:focus {
    --tw-skew-y: -1deg;
  }

  .xl\:transition-none {
    transition-property: none;
  }

  .xl\:transition-all {
    transition-property: all;
    transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
    transition-duration: 150ms;
  }

  .xl\:transition {
    transition-property: background-color, border-color, color, fill, stroke, opacity, box-shadow, transform;
    transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
    transition-duration: 150ms;
  }

  .xl\:transition-colors {
    transition-property: background-color, border-color, color, fill, stroke;
    transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
    transition-duration: 150ms;
  }

  .xl\:transition-opacity {
    transition-property: opacity;
    transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
    transition-duration: 150ms;
  }

  .xl\:transition-shadow {
    transition-property: box-shadow;
    transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
    transition-duration: 150ms;
  }

  .xl\:transition-transform {
    transition-property: transform;
    transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
    transition-duration: 150ms;
  }

  .xl\:ease-linear {
    transition-timing-function: linear;
  }

  .xl\:ease-in {
    transition-timing-function: cubic-bezier(0.4, 0, 1, 1);
  }

  .xl\:ease-out {
    transition-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }

  .xl\:ease-in-out {
    transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }

  .xl\:duration-75 {
    transition-duration: 75ms;
  }

  .xl\:duration-100 {
    transition-duration: 100ms;
  }

  .xl\:duration-150 {
    transition-duration: 150ms;
  }

  .xl\:duration-200 {
    transition-duration: 200ms;
  }

  .xl\:duration-300 {
    transition-duration: 300ms;
  }

  .xl\:duration-500 {
    transition-duration: 500ms;
  }

  .xl\:duration-700 {
    transition-duration: 700ms;
  }

  .


k" d="M77.946 52.946l-5.892 -5.892L54.167 64.942V25h-8.333v39.942l-17.888 -17.888l-5.892 5.892L50 80.892z"></path></svg>')
}

body:not(.minimal-icons-off) svg.down-chevron-glyph {
	-webkit-mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 100 100"><path fill="black" d="M67.888 38.721L50 56.608L32.113 38.721l-5.892 5.892L50 68.392l23.779 -23.779z"></path></svg>')
}

body:not(.minimal-icons-off) svg.enter {
	transform: translate(-2px);
	-webkit-mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 100 100"><path fill="black" d="M54.167 66.667l20.833 -16.667l-20.833 -16.667v12.5H16.667v8.333h37.5z"/><path fill="black" d="M83.333 12.5h-37.5c-4.596 0 -8.333 3.738 -8.333 8.333v16.667h8.333V20.833h37.5v58.333h-37.5v-16.667H37.5v16.667c0 4.596 3.738 8.333 8.333 8.333h37.5c4.596 0 8.333 -3.738 8.333 -8.333V20.833c0 -4.596 -3.738 -8.333 -8.333 -8.333z"></path></svg>')
}

body:not(.minimal-icons-off) svg.excalidraw-icon {
	-webkit-mask-image: url('data:image/svg+xml;utf8,<svg  xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24"><g  stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"%3E%3Cpath d="M12 19l7-7l3 3l-7 7l-3-3z"/%3E%3Cpath d="M18 13l-1.5-7.5L2 2l3.5 14.5L13 18l5-5z"/%3E%3Cpath d="M2 2l7.586 7.586"/%3E%3Ccircle cx="11" cy="11" r="2"/%3E%3C/g%3E%3C/svg%3E%0A')
}

body:not(.minimal-icons-off) svg.exit-fullscreen {
	-webkit-mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 100 100"><path fill="black" d="M41.667 16.667H33.333v16.667H16.667v8.333h25zM33.333 83.333h8.333v-25H16.667v8.333h16.667zm50 -25h-25v25h8.333v-16.667h16.667zm0 -25h-16.667V16.667h-8.333v25h25z"></path></svg>')
}

body:not(.minimal-icons-off) svg.expand-vertically {
	-webkit-mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 100 100"><path fill="black


now that the task's */
                         /* entire context is saved. Note the core id in r0 is the argument. */

//krestsp 0              /* unnecessary since KSP is already set and the SP */
                         /* is being restored next from the current TCB. */

.globl _freertos_restore_ctx
_freertos_restore_ctx:

  ldw    r0,     r5[r6]  /* get this core's current TCB pointer into r0 */
  ldw    r0,     r0[0x0] /* Get the top of the stack from the current TCB... */
  set    sp,     r0      /* into the stack pointer register. */

  /* Restore the current task's context */
#if 1
  /* Restore VPU regs */
  ldaw   r11,    sp[37]
 {vldc   r11[0]
  ldaw   r11,    sp[29]}
 {vldd   r11[0]
  ldaw   r11,    sp[21]}
  vldr   r11[0]
  /* Restore VPU status and headroom */


[start][end][ur.childState]
								&& iScore[start][end][ur.childState] > Double.NEGATIVE_INFINITY) {
							oScore[start][end][ur.childState] = tot;
						}
					}
				}
				// do binaries
				for (int s = 0; s < numStates; s++) {
					BinaryRule[] rules = grammar.splitRulesWithP(s);
					for (int r = 0; r < rules.length; r++) {
						BinaryRule br = rules[r];
						double oS = oScore[start][end][br.parentState];
						if (Double.isInfinite(oS)) {
							continue;
						}
						int min1 = narrowRExtent[start][br.leftChildState];
						if (end < min1) {
							continue;
						}
						int max1 = narrowLExtent[end][br.rightChildState];
						if (max1 < min1) {
							continue;
						}
						int min = min1;
						int max = max1;
						if (max - min > 2) {
							int min2 = wideLExtent[end][br.rightChildState];
							min = (min1 > min2 ? min1 : min2);
							if (max1 < min) {
								continue;
							}
							int max2 = wideRExtent[start][br.leftChildState];
							max = (max1 < max2 ? max1 : max2);
							if (max < min) {
								continue;
							}
						}
						double pS = br.getScore(0, 0, 0);
						for (int split = min; split <= max; split++) {
							double lS = iScore[start][split][br.leftChildState];
							if (Double.isInfinite(lS)) {
								continue;
							}
							double rS = iScore[split][end][br.rightChildState];
							if (Double.isInfinite(rS)) {
								continue;
							}
							double totL = pS + rS + oS;
							touchedRules++;
							if (totL > oScore[start][split][br.leftChildState]) {
								oScore[start][split][br.leftChildState] = totL;
							}
							double totR = pS + lS + oS;
							if (totR > oScore[split][end][br.rightChildState]) {
								oScore[split][end][br.rightChildState] = totR;
							}
						}
					}
				}
				/*
				 * for (int s = 0; s < numStates; s++) { int max1 =
				 * narrowLExtent[end][s]; if (max1 < start) { continue; }
				 * BinaryRule[] rules = grammar.splitRulesWithRC(s); for (int r
				 * = 0; r < rules.length; r++) { BinaryRule br = rules[r];
				 * double oS = oScore[start][end][br.parentState]; if
				 * (Double.isInfinite(oS)) { continue; } int min1 =
				 * narrowRExtent[start][br.leftChildState]; if (max1 < min1) {
				 * continue; } int min = min1; int max = max1; if (max - min >
				 * 2) { int min2 = wideLExtent[end][br.rightChildState]; min =
				 * (min1 > min2 ? min1 : min2); if (max1 < min) { continue; }
				 * int max2 = wideRExtent[start][br.leftChildState]; max = (max1
				 * < max2 ? max1 : max2); if (max < min) { continue; } } double
				 * pS = br.getScore(0, 0, 0); for (int split = min; split <=
				 * max; split++) { double lS =
				 * iScore[start][split][br.leftChildState]; if
				 * (Double.isInfinite(lS)) { continue; } double rS =
				 * iScore[split][end][br.rightChildState]; if
				 * (Double.isInfinite(rS)) { continue; } double totL = pS + rS +
				 * oS; if (totL > oScore[start][split][br.leftChildState]) {


 -4
    PTR_SLLI  T0,     T0,     3 /* ((m & -4) - 4) */
    PTR_ADD   CC,     T0,     C /* c + ((m & -4) - 4)*/
    PTR_SLLI  T1,     KK,     5
    PTR_MUL   AA,     T0,     K
    PTR_ADD   AA,     AA,     A
    PTR_ADD   A0,     AA,     T1 /* a + ((m & -4) - 4) * k + 4 * kk */
    PTR_SLLI  T0,     KK,     3
    PTR_ADD   B0,     B,      T0 /* b + kk */
    PTR_SUB   L,      K,      KK
    GADD , d, C0, CC, ZERO
    dgemm_dsolve_4x1
    PTR_ADDI  KK,     KK,     -4
.L_N1_M8:
    andi    I,      M,      8
    beqz    I,      .L_N1_M16
    PTR_SRLI  T0,     M,      3
    PTR_SLLI  T0,     T0,     3
    PTR_ADDI  T0,     T0,     -8
    PTR_SLLI  T0,     T0,     3 /* ((m & -8) - 8) */
    PTR_ADD   CC,     T0,     C /* c + ((m & -8) - 8)*/
    PTR_SLLI  T1,     KK,     6
    PTR_MUL   AA,     T0,     K
    PTR_ADD   AA,     AA,     A
    PTR_ADD   A0,     AA,     T1 /* a + ((m & -8) - 8) * k + 8 * kk */
    PTR_SLLI  T0,     KK,     3
    PTR_ADD   B0,     B,      T0 /* b +  kk */
    PTR_SUB   L,      K,      KK
    GADD , d, C0, CC, ZERO
    dgemm_dsolve_8x1
    PTR_ADDI  KK,     KK,     -8
.L_N1_M16:
    PTR_SRAI   I,     M,     4     /* I = bm >> 4 */
    beq      ZERO,  I,     .L_N1_M0

    PTR_SRLI   T0,    M,      4
    PTR_SLLI   T0,    T0,     4
    PTR_ADDI   T0,    T0,     -16 /* ((M & -16)) - 16) */
    PTR_SLLI   T0,    T0,     3
    PTR_MUL    AA,    T0,     K
    PTR_ADD    AA,    A,      AA
    PTR_ADD    CC,    C,      T0
.align 5
.L_N1_I1:
    PTR_SLLI   T0,    KK,     3
    PTR_ADD    B0,    B,      T0
    PTR_SUB    L,     K,      KK
    GADD , d, C0, CC, ZERO
    PTR_SLLI   T0,    KK,     7
    PTR_ADD    A0,    AA,     T0
    dgemm_dsolve_16x1
    PTR_ADDI   I,     I,      -1
    PTR_ADDI   KK,    KK,     -16
    PTR_ADDI   CC,    CC,     -(16 * 8)
    PTR_SLLI   T0,    K,      7
    PTR_SUB    AA,    AA,     T0
    blt      ZERO,  I,      .L_N1_I1
.L_N1_M0:
.L_N0:
    pop_if_used 9, 8
    jirl    $r0, $r1, 0x0
    EPILOGUE