ink.api.MavMessage
import com.divpundir.mavlink.serialization.MavDataDecoder
import com.divpundir.mavlink.serialization.MavDataEncoder
import com.divpundir.mavlink.serialization.encodeBitmaskValue
import com.divpundir.mavlink.serialization.encodeEnumValue
import com.divpundir.mavlink.serialization.encodeFloat
import com.divpundir.mavlink.serialization.encodeUInt32
import com.divpundir.mavlink.serialization.safeDecodeBitmaskValue
import com.divpundir.mavlink.serialization.safeDecodeEnumValue
import com.divpundir.mavlink.serialization.safeDecodeFloat
import com.divpundir.mavlink.serialization.safeDecodeUInt32
import com.divpundir.mavlink.serialization.truncateZeros
import kotlin.Byte
import kotlin.ByteArray
import kotlin.Float
import kotlin.Int
import kotlin.UInt
import kotlin.Unit

/**
 * Reports the current commanded vehicle position, velocity, and acceleration as specified by the
 * autopilot. This should match the commands sent in SET_POSITION_TARGET_LOCAL_NED if the vehicle is
 * being controlled this way.
 *
 * @param timeBootMs Timestamp (time since system boot).
 * units = ms
 * @param coordinateFrame Valid options are: MAV_FRAME_LOCAL_NED = 1, MAV_FRAME_LOCAL_OFFSET_NED =
 * 7, MAV_FRAME_BODY_NED = 8, MAV_FRAME_BODY_OFFSET_NED = 9
 * @param typeMask Bitmap to indicate which dimensions should be ignored by the vehicle.
 * @param x X Position in NED frame
 * units = m
 * @param y Y Position in NED frame
 * units = m
 * @param z Z Position in NED frame (note, altitude is negative in NED)
 * units = m
 * @param vx X velocity in NED frame
 * units = m/s
 * @param vy Y velocity in NED frame
 * units = m/s
 * @param vz Z velocity in NED frame
 * units = m/s
 * @param afx X acceleration or force (if bit 10 of type_mask is set) in NED frame in meter / s^2 or
 * N
 * units = m/s/s
 * @param afy Y acceleration or force (if bit 10 of type_mask is set) in NED frame in meter / s^2 or
 * N
 * units = m/s/s
 * @param afz Z acceleration or force (if bit 10 of type_mask is set) in NED frame in meter / s^2 or
 * N
 * units = m/s/s
 * @param yaw yaw setpoint
 * units = rad
 * @param yawRate yaw rate setpoint
 * units = rad/s
 */
@GeneratedMavMessage(
  id = 85u,
  crcExtra = -116,
)
public data class PositionTargetLocalNed(
  /**
   * Timestamp (time since system boot).
   * units = ms
   */
  @GeneratedMavField(type = "uint32_t")
  public val timeBootMs: UInt = 0u,
  /**
   * Valid options are: MAV_FRAME_LOCAL_NED = 1, MAV_FRAME_LOCAL_OFFSET_NED = 7, MAV_FRAME_BODY_NED
   * = 8, MAV_FRAME_BODY_OFFSET_NED = 9
   */
  @GeneratedMavField(type = "uint8_t")
  public val coordinateFrame: MavEnumValue<MavFrame> = MavEnumValue.fromValue(0u),
  /**
   * Bitmap to indicate which dimensions should be ignored by the vehicle.
   */


ional_warning

class AddSmoking : OsmFilterQuestType<SmokingAllowed>(), AndroidQuest {
    /*
        - some places are eligible as we assume they probably have seating (unless
          they are explicitly marked as having no seating at all):
          (like bar, cafe, restaurant...)
        - some places are eligible as their definition includes seating even if they
          don't have any other explicit tags (like outdoor_seating)
        - some places are eligible even if they don't have any seating (like nightclub)
        - some places are eligible only if they are explicitly marked to have seating
          as otherwise we assume they don't provide seating (like bakery, wine shop...)
     */
    override val elementFilter = """
         nodes, ways with
         (
             amenity ~ bar|cafe|biergarten|restaurant|food_court and (indoor_seating != no or outdoor_seating != no)
             or leisure = outdoor_seating
             or amenity ~ nightclub|stripclub|pub
             or (
                 (amenity ~ fast_food|ice_cream or shop ~ ice_cream|deli|bakery|coffee|tea|wine)
                 and (
                     (outdoor_seating and outdoor_seating != no)
                     or (indoor_seating and indoor_seating != no)
                 )
             )
         )
         and takeaway != only
         and (!smoking or smoking older today -8 years)
    """
    override val changesetComment = "Survey whether smoking is allowed or prohibited"
    override val wikiLink = "Key:smoking"
    override val icon = R.drawable.ic_quest_smoking
    override val isReplacePlaceEnabled = true
    override val achievements = listOf(CITIZEN)
    override val defaultDisabledMessage = Res.string.default_disabled_msg_go_inside_regional_warning

    override fun getTitle(tags: Map<String, String>) = R.string.quest_smoking_title2

    override fun getHighlightedElements(element: Element, getMapData: () -> MapDataWithGeometry) =
        getMapData().asSequence().filter { it.isPlaceOrDisusedPlace() }

    override fun createForm() = SmokingAllowedForm()

    override fun applyAnswerTo(answer: SmokingAllowed, tags: Tags, geometry: ElementGeometry, timestampEdited: Long) {
        tags.updateWithCheckDate("smoking", answer.osmValue)
    }
}
package de.westnordost.streetcomplete.quests.bus_stop_lit

import de.westnordost.streetcomplete.R
import de.westnordost.streetcomplete.data.osm.geometry.ElementGeometry
import de.westnordost.streetcomplete.data.osm.osmquests.OsmFilterQuestType
import de.westnordost.streetcomplete.data.quest.AndroidQuest
import de.westnordost.streetcomplete.data.user.achievements.EditTypeAchievement.PEDESTRIAN
import de.westnordost.streetcomplete.osm.Tags
import de.westnordost.streetcomplete.osm.updateWithCheckDate
import de.westnordost.streetcomplete.quests.YesNoQuestForm
import de.westnordost.streetcomplete.util.ktx.toYesNo

class AddBusStopLit : OsmFilterQuestType<Boolean>(), AndroidQuest {

    override val elementFilter = """
        nodes, ways, relations with
        (
          public_transport = platform
          or (highway = bus_stop and public_transport != stop_position)
        )
        and physically_present != no and naptan:BusStopType != HAR
        and access !~ no|private
        and location !~ underground|indoor
        and


询问："任务规划看起来合理吗？如果同意的话，我们可以开始逐个实现了"

**示例格式:**

```markdown
# 实施计划

- [ ] 1. 设置项目结构和核心接口
  - 为模型、服务、仓库和API组件创建目录结构
  - 定义建立系统边界的接口
  - _需求: 1.1_

- [ ] 2. 实现数据模型和验证
- [ ] 2.1 创建核心数据模型接口和类型
  - 为所有数据模型编写TypeScript接口
  - 实现数据完整性验证函数
  - _需求: 2.1, 3.3, 1.2_

- [ ] 2.2 实现带验证的User模型
  - 编写带验证方法的User类
  - 为User模型验证创建单元测试
  - _需求: 1.2_

[其他编码任务继续...]
```

**重要约束:**
- 如果用户表示需要对设计进行任何更改，必须返回设计步骤
- 如果用户表示需要额外需求，必须返回需求步骤
- 必须等待您的明确认可才能完成工作流程
- 如果您要求更改或不明确批准，我必须修改任务文档
- 每次编辑后必须明确请求批准
- 必须继续反馈-修订循环直到获得明确批准
- 如果在实施规划期间发现差距，会提议返回之前步骤（需求或设计）

**完成标志:** 您明确同意任务规划

## 第四阶段：代码实现

**触发条件:**
- 任务清单已完成并获得您的认可
- 或您指定要实现某个具体任务

**我的工作:**
1. **实施前准备:**
   - 必须完全了解项目代码，了解项目规范和具体实现，收集足够完善的上下文，再开始工作
   - 在执行任何任务之前，始终确保已阅读`.claude/specs/{功能名}/`下的规格requirements.md、design.md和tasks.md文件
   - 在没有需求或设计的情况下执行任务将导致不准确的实现

2. **任务执行策略:**
   - 查看任务清单中的任务详情
   - 如果请求的任务有子任务，总是从子任务开始
   - **严格一次只专注一个任务** - 不实现其他任务的功能
   - 根据任务或其


/*  -SIGN(X)*2 IN SGL FMT */
	fdiv.x		fp0,fp1		/*  -SIGN(X)2 / [EXP(Y)+1 ] */

	move.l		SGN(a6),d1
	ori.l		#0x3F800000,d1		/*  SGN */
	fmove.s		d1,fp0		/*  SGN IN SGL FMT */

	fmove.l		d0,fpcr		/*  restore users round prec,mode */
	move.b		#FADD_OP,d1		/*  last inst is ADD */
	fadd.x		fp1,fp0
	bra.l		t_inx2

TANHSM:
	fmove.l		d0,fpcr		/*  restore users round prec,mode */
	move.b		#FMOV_OP,d1		/*  last inst is MOVE */
	fmove.x		X(


def mostrar_elemento(eleccion: int) -> str:
    """
    Esta funcion recibe la eleccion del jugador (1 para piedra, 2 para papel, 3 para tijera)
    y lo devuelve de forma legible como cadena de caracteres.
    Args:
        eleccion (int): Número de elección (1 para Piedra, 2 para Papel, 3 para Tijera).
    Returns:
        str: "Piedra" cuando su elección == 1 | "Papel" cuando su elección == 2. | "Tijera" cuando su  elección == 3.
    """
    #variable para cambiar sus valores segun sea el caso y tener un unico retorno.
    casos = None

    #condicional para determinar donde va la eleccion del usuario.
    match eleccion:
        case 1:
            casos = "Piedra"
        case 2:
            casos = "Papel"
        case 3:
            casos = "Tijera"

    return casos


dates, curr = prev.next;
    for (; curr!=null; prev=curr, curr=prev.next) {
      if (curr.item.status === vg.scene.EXIT) curr.remove = true;
    }
    t.callback = callback;
    d3.timer(function(elapsed) { return step.call(t, elapsed); });
  };

  function step(elapsed) {
    var list = this.updates, prev = list, curr = prev.next,
        duration = this.duration,
        item, delay, f, e, i, n, stop = true;

    for (; curr!=null; prev=curr, curr=prev.next) {
      item = curr.item;
      delay = item.delay || 0;

      f = (elapsed - delay) / duration;
      if (f < 0) { stop = false; continue; }
      if (f > 1) f = 1;
      e = curr.ease(f);

      for (i=0, n=curr.length; i<n; ++i) {
        item[curr[i].property] = curr[i](e);
      }
      item.touch();
      vg.scene.bounds.item(item);

      if (f === 1) {
        if (curr.remove) item.remove();
        prev.next = curr.next;
        curr = prev;
      } else {
        stop = false;
      }
    }

    this.callback();
    return stop;
  };

  return trans;

})();

vg.scene.transition = function(dur, ease) {
  return new vg.scene.Transition(dur, ease);
};vg.scene.axis = function() {
  var scale,
      orient = vg.config.axis.orient,
      offset = 0,
      titleOffset = vg.config.axis.titleOffset,
      axisDef = null,
      layer = "front",
      grid = false,
      title = null,
      tickMajorSize = vg.config.axis.tickSize,
      tickMinorSize = vg.config.axis.tickSize,
      tickEndSize = vg.config.axis.tickSize,
      tickPadding = vg.config.axis.padding,
      tickValues = null,
      tickFormatString = null,
      tickSubdivide = 0,
      tickCount = vg.config.axis.ticks,
      gridLineStyle = {},
      tickLabelStyle = {},
      majorTickStyle = {},
      minorTickStyle = {},
      titleStyle = {},
      domainStyle = {};

  var axis = {};

  function reset() {
    axisDef = null;
  }

  function getTickFormatString() {
    return tickFormatString || (scale.type === 'log' ? ".1s" : null);
  }

  function buildTickFormat() {
    var fmtStr = getTickFormatString();
    if (scale.tickFormat) {
      return scale.tickFormat(tickCount, fmtStr);
    } else if (fmtStr) {
      return ((scale.type === 'time')
        ? d3.time.format(fmtStr)
        : d3.format(fmtStr));
    } else {
      return String;
    }
  }

  function buildTicks(fmt) {
    var ticks = {
      major: tickValues,
      minor: null
    };

    if (ticks.major == null) {
      ticks.major = scale.ticks
        ? scale.ticks(tickCount)
        : scale.domain();
    }

    ticks.minor = vg_axisSubdivide(scale, ticks.major, tickSubdivide)
      .map(vg.data.ingest);

    ticks.major = ticks.major.map(function(d) {
      return (d = vg.data.ingest(d), d.label = fmt(d.data), d);
    });

    return ticks;
  }

  axis.def = function() {
    var def = axisDef ? axisDef : (axisDef = axis_def(scale));
    var fmt = buildTickFormat();
    var ticks = buildTicks(fmt);
    var tdata = title ? [title].map(vg.data.ingest)


es unrolled loop, see below
	adc	eax, 4(esi)
	adc	eax, 8(esi)
	adc	eax, 12(esi)
	adc	eax, 16(esi)
	adc	eax, 20(esi)
	adc	eax, 0
	add	esi, 24
add6test:
	sub	edi, 24
	jae	add6
	add	edi, 24

	jmp	add1test
	.align	16
add1:	add	eax, (esi)		! while ((edi -= 4) >= 0)
	adc	eax, 0			!	eax += *esi++;
	add	esi, 4			! edi += 4;
add1test:
	sub	edi, 4
	jae	add1
	add	edi, 4

	jz	done			! Are there extra bytes?
	mov	edx, (esi)		! Load extra bytes in a full dword
	and	edx, mask-4(edi*4)	! Mask off excess
	add	eax, edx		! Add in the last bits
	adc	eax, 0
done:	rol	eax, cl			! Undo the rotation at the beginning
	mov	edx, eax
	shr	eax, 16
  o16	add	ax, dx			! Add the two words in eax to form
  o16	adc	ax, 0			! a 16 bit sum
	pop	edi
	pop	esi
	pop	ebp
	ret

.sect .rom
	.align	4
mask:	.data4	0x000000FF, 0x0000FFFF, 0x00FFFFFF

!
! $PchId: oneC_sum.ack.s,v 1.2 1996/03/12 19:33:51 philip Exp $


tests.dart';

/// Readable description of the [expected] grapheme clusters.
///
/// The list of strings is the expected grapheme cluster separation
/// of the concatenation of those strings.
///
/// The description converts each code unit to a 4-digit hex number,
/// puts ` × ` between the code units of the same grapheme cluster
/// and ` ÷ ` before, after and between the grapheme clusters.
/// (This is the format of the original Unicode test data, so it
/// can be compared to the original tests.)
String testDescription(List<String> expected) {
  var expectedString = expected
      .map(
        (s) =>
            s.runes.map((x) => x.toRadixString(16).padLeft(4, '0')).join(' × '),
      )
      .join(' ÷ ');
  return '÷ $expectedString ÷';
}

int categoryOf(int codePoint) {
  if (codePoint < 0x10000) return low(codePoint);
  var nonBmpOffset = codePoint - 0x10000;
  return high(nonBmpOffset >> 10, nonBmpOffset & 0x3ff);
}

String partCategories(List<String> parts) {
  var index = 0;
  int posOf(int rune) {
    var result = index;
    index += rune >= 0xFFFF ? 2 : 1;
    return result;
  }

  return parts.map((part) {
    return part.runes
        .map((n) => '#${posOf(n)}:${categoryLongNames[categoryOf(n)]}')
        .join(' × ');
  }).join(' ÷ ');
}
// Copyright (c) 2018, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

/// Unicode Grapheme Breaking Algorithm Character Categories.
/// (Order is irrelevant to correctness, so it is chosen
/// to minimize the size of the generated table strings
/// by avoiding many bytes that need escapes).
const int categoryCR = 0;
const int categoryControl = 1;
const int categoryOther = 2; // Any character not in any other category.
const int categoryExtend = 3;
const int categorySpacingMark = 4;
const int categoryRegionalIndicator = 5;
const int categoryPictographic = 6;
const int categoryLF = 7;
const int categoryPrepend = 8;
const int categoryL = 9;
const int categoryV = 10;
const int categoryT = 11;
const int categoryLV = 12;
const int categoryLVT = 13;
const int categoryOtherIndicConsonant = 14; // Other + InCB=Consonant.
const int categoryZWJ = 15; // Is also InCB=Extend.
const int categoryExtendIndicExtend = 16; // Extend + InCB=Extend.
const int categoryExtendIndicLinked = 17; // Extend + InCB=Linked.
const int categoryEoT = 18; // End of Text (synthetic input)

const int categoryCount = categoryEoT + 1;
const int inputCategoryCount = categoryEoT;

const int regionalIndicatorStart = 0x1F1E6; // A
const int regionalIndicatorEnd = 0x1F1FF; // Z

// Automaton states for forwards automaton.

/// Bit flag or'ed to the automaton output if there should not be a break
/// before the most recent input character.
const int flagNoBreak = 0;
const int flagBreak = 1;
const int maskBreak = 1;

/// Extra bit used to trigger or modify the effect of lookahead/lookbehind.
///
/// Requires [automatonRowLength] to be a multiple of 4.
/// It is currently 20.
const int flagLookahead = 2;
const int maskLookahead = 2;

/// Mask of entry in automatons without low flag bits.
const int maskFlags = maskLookahead | maskBreak;
const int maskState = ~maskFlags;

// For complex lookahead (Indic Ext/Lnk+Con, ZWJ+PI


 }

    return GCWOpenFile(
        title: title,
        supportedFileTypes: fileTypes,
        onLoaded: (GCWFile? value) {
          if (value == null) {
            showSnackBar(i18n(context, 'common_loadfile_exception_notloaded'), context);
            return;
          } else if (isImage(value.bytes)) {
            puzzle.board.importImage(value.bytes);
            _currentEncryptStep = _EncryptWizardStep.DRAW_LOADED_IMAGE;
          } else {
            _importJsonFile(value.bytes, puzzle);
            _currentEncryptStep = _EncryptWizardStep.DRAW_LOADED_JSON;
          }
          setState(() {});
        });
  }

  Widget _openFileButtonDecrypt(PuzzleWidgetValues puzzle) {
    return GCWOpenFile(
      title: 'JSON/TXT',
      supportedFileTypes: const [FileType.TXT, FileType.JSON],
      onLoaded: (GCWFile? value) {
        if (value == null) {
          showSnackBar(i18n(context, 'common_loadfile_exception_notloaded'), context);
          return;
        }
        _importJsonFile(value.bytes, puzzle);
        setState(() {
          _currentDecryptStep = _DecryptWizardStep.SHOW_RESULT_FILE;
        });
      },
    );
  }

  Widget _buildSizeSelection(PuzzleWidgetValues puzzle) {
    return Column(children: <Widget>[
      GCWIntegerSpinner(
          title: i18n(context, 'common_row_count'),
          controller: puzzle.rowCountController,
          flexValues: const [1, 1],
          value: puzzle.rowCount,
          min: 1,
          onChanged: (value) {
            setState(() {
              puzzle.rowCount = value;
            });
          }),
      GCWIntegerSpinner(
          title: i18n(context, 'common_column_count'),
          controller: puzzle.columnCountController,
          flexValues: const [1, 1],
          value: puzzle.columnCount,
          min: 1,
          onChanged: (value) {
            setState(() {
              puzzle.columnCount = value;
            });
          }),
      GCWButton(
          text: i18n(context, 'common_next'),
          onPressed: () {
            setState(() {
              puzzle.scale = 1.0;
              var tmpPuzzle = puzzle.board;
              puzzle.board = Puzzle.generate(puzzle.rowCount, puzzle.columnCount);
              puzzle.board.importHints(tmpPuzzle);

              if (puzzle.encryptVersion) {
                _currentEncryptStep = _currentEncryptStep == _EncryptWizardStep.DEFINE_SIZE_IMAGE
                    ? _EncryptWizardStep.LOAD_IMAGE
                    : _EncryptWizardStep.DRAW_MANUALLY;
              } else {
                puzzle.clearRowHints();
                puzzle.clearColumnHints();
                _currentDecryptStep = _DecryptWizardStep.SET_ROW_VALUES;
              }
            });
          }),
    ]);
  }

  Widget _buildRowHints(PuzzleWidgetValues puzzle) {
    var list = <Widget>[];

    for (var i = 0; i < puzzle.rowCount; i++) {
      var controller = puzzle.getRowController(i);
      var row = Row(children: <Widget>[
        Expanded(flex: 2, child: GCWText(text: i18n(context, 'common_row') + ' ' + (i + 1).toString())),
        Expanded(flex: 3, child: GCWTextField(controller: controller, onChanged: (text) {}))
      ]);
      list.add(row);
    }

    list.add(GCWButton(
        text: i18n(context, 'common_next'),
        onPressed: () {
          setState(() {
            setState(() {
              for (var i = 0; i < puzzle.rowCount; i++) {
                var _encryptList = textToIntList(puzzle.getRowController(i).text, allowNegativeValues: true);
                var dataBackup = _encryptList.sublist(0);
                var data = Puzzle.cleanHints(_encryptList, puzzle.board.width);
                if (!listEquals(data, dataBackup)) {
                  showSnackBar(i18n(


  "iPhone5,4", //iPhone 5C (Global)
  "iPhone6,1", //iPhone 5S (GSM)
  "iPhone6,2", //iPhone 5S (Global)
  "iPhone7,1", //iPhone 6 Plus
  "iPhone7,2", //iPhone 6
  "iPhone8,1", // iPhone 6s
  "iPhone8,2", // iPhone 6s Plus
  "iPhone8,4", // iPhone SE (GSM)
  "iPhone9,1", // iPhone 7
  "iPhone9,2", // iPhone 7 Plus
  "iPhone9,3", // iPhone 7
  "iPhone9,4", // iPhone 7 Plus
  "iPhone10,1", // iPhone 8
  "iPhone10,2", // iPhone 8 Plus
  "iPhone10,3", // iPhone X Global
  "iPhone10,4", // iPhone 8
  "iPhone10,5", //  iPhone 8
};

Future<bool> isLowSpecDevice() async {
  try {
    if (Platform.isIOS) {
      final IosDeviceInfo iosInfo = await deviceInfoPlugin.iosInfo;
      debugPrint("ios utc name ${iosInfo.utsname.machine}");
      return iOSLowEndMachineCodes.contains(iosInfo.utsname.machine);
    }
  } catch (e) {
    Logger("device_info").severe("deviceSpec check failed", e);
  }
  return false;
}

Future<bool> isGrapheneOS() async {
  if (Platform.isAndroid) {
    final androidInfo = await deviceInfoPlugin.androidInfo;
    return androidInfo.host.toLowerCase() == "grapheneos";
  }
  return false;
}

Future<bool> isAndroidSDKVersionLowerThan(int inputSDK) async {
  if (Platform.isAndroid) {
    final AndroidDeviceInfo androidInfo = await deviceInfoPlugin.androidInfo;
    return androidInfo.version.sdkInt < inputSDK;
  } else {
    return false;
  }
}
import "dart:async";
import 'dart:io';

import 'package:flutter/material.dart';
import 'package:flutter_easyloading/flutter_easyloading.dart';
import 'package:fluttertoast/fluttertoast.dart';
import 'package:photos/ente_theme_data.dart';

void showToast(
  BuildContext context,
  String message, {
  toastLength = Toast.LENGTH_LONG,
  int iosLongToastLengthInSec = 2,
}) async {
  if (Platform.isAndroid) {
    await Fluttertoast.cancel();
    unawaited(
      Fluttertoast.showToast(
        msg: message,
        toastLength: toastLength,
        gravity: ToastGravity.BOTTOM,
        timeInSecForIosWeb: 1,
        backgroundColor: Theme.of(context).colorScheme.toastBackgroundColor,
        textColor: Theme.of(context).colorScheme.toastTextColor,
        fontSize: 16.0,
      ),
    );
  } else {
    EasyLoading.instance
      ..backgroundColor = Theme.of(context).colorScheme.toastBackgroundColor
      ..indicatorColor = Theme.of(context).colorScheme.toastBackgroundColor
      ..textColor = Theme.of(context).colorScheme.toastTextColor
      ..userInteractions = true
      ..loadingStyle = EasyLoadingStyle.custom;
    unawaited(
      EasyLoading.showToast(
        message,
        duration: Duration(
          seconds:
              (toastLength == Toast.LENGTH_LONG ? iosLongToastLengthInSec : 1),
        ),
        toastPosition: EasyLoadingToastPosition.bottom,
        dismissOnTap: false,
      ),
    );
  }
}

void showShortToast(context, String message) {
  showToast(context, message, toastLength: Toast.LENGTH_SHORT);
}
import 'dart:async';
import 'dart:io';

import 'package:path/path.dart';
import 'package:path_provider/path_provider.dart';
import 'package:photos/models/public_key.dart';
import 'package:sqflite/sqflite.dart';

class PublicKeysDB {
  static const _databaseName = "ente.public_keys.db"


:1.3125em}form div.is-success,form span.is-success{font-size:.75em;color:#20bc71}form div.is-error,form span.is-error{font-size:.75em;color:#ee2455}form div.is-warning,form span.is-warning{font-size:.75em;color:#ff6951}form span.is-error,form span.is-success,form span.is-warning{margin-left:2px}form .is-desc{font-size:.75rem;color:rgba(17,17,19,.5)}form span.is-desc{margin-left:4px}form div.is-desc{margin-top:4px;margin-bottom:-4px}form .is-req{position:relative;top:1px;font-size:1rem;font-weight:700;color:#ee2455}.form-item{margin-bottom:16px}fieldset>.form-item:last-child{margin-bottom:0}.form-checkboxes label.is-checkbox{display:inline-block;margin-right:16px}.form-item.is-inline,.form-item.is-inline-offset{padding-left:150px}.form-item.is-inline label:not(.is-checkbox){float:left;margin-left:-150px}.form-item.is-bar input,.form-item.is-bar select,.form-item.is-bar textarea{display:inline-block;width:auto}.breadcrumb,.form-item.is-buttons,.is-append,.is-prepend{display:flex}.form-item.is-buttons .button,.form-item.is-buttons button{margin-right:8px}.form-item.is-buttons button+.button.is-tertiary{margin-left:8px}.form-item.is-buttons .button.is-push-right,.form-item.is-buttons .button.is-tertiary.is-push-right,.form-item.is-buttons button.is-push-right{margin-left:auto;margin-right:0}.is-append input,.is-prepend input{flex:1}.is-append .button,.is-append a,.is-append span,.is-prepend .button,.is-prepend a,.is-prepend span{flex-shrink:0}.is-append a,.is-append span,.is-prepend a,.is-prepend span{display:flex;flex-direction:column;justify-content:center;padding:0 16px;border:1px solid rgba(17,17,19,.1);background-color:#fff;white-space:nowrap}.is-append span,.is-prepend span{font-size:.875em;font-weight:400;text-transform:none;color:rgba(17,17,19,.5)}.is-append a,.is-prepend a{font-size:.875em;color:#158df7;text-decoration:none}.is-append a:hover,.is-prepend a:hover{text-decoration:underline}.is-append a.icon,.is-append a[class*=" icon-kube-"],.is-append a[class^=icon-kube-],.is-prepend a.icon,.is-prepend a[class*=" icon-kube-"],.is-prepend a[class^=icon-kube-]{font-size:1rem;color:rgba(17,17,19,.6)}.breadcrumb,.pager{font-size:.875em;font-weight:400;text-transform:none}.breadcrumb a,.breadcrumb span,.is-append a.icon:hover,.is-append a[class*=" icon-kube-"]:hover,.is-append a[class^=icon-kube-]:hover,.is-prepend a.icon:hover,.is-prepend a[class*=" icon-kube-"]:hover,.is-prepend a[class^=icon-kube-]:hover{color:#111113;text-decoration:none}.is-prepend input{border-radius:0 4px 4px 0}.is-prepend .button{margin-right:-1px;border-radius:4px 0 0 4px!important}.is-prepend a,.is-prepend span{bord


Pos[0] + direction[0], currPos[1] - 1), direction)

            if possible:
                moveDoubleVert(grid, (currPos[0] + direction[0], currPos[1]), direction)
                grid[currPos[0] + direction[0]][currPos[1]] = grid[currPos[0]][currPos[1]]
                grid[currPos[0]][currPos[1]] = "."

                currPos[0] += direction[0]
                currPos[1] += direction[1]

def moveDoubleVert(grid, currPos, direction):
    if grid[currPos[0]][currPos[1]] == "." or grid[currPos[0]][currPos[1]] == "#":
        return

    if grid[currPos[0]][currPos[1]] == "]":
        moveDoubleVert(grid, (currPos[0], currPos[1] - 1), direction)
        return

    if grid[currPos[0] + direction[0]][currPos[1]] == "[":
        moveDoubleVert(grid, (currPos[0] + direction[0], currPos[1]), direction)

        grid[currPos[0] + direction[0]][currPos[1]] = grid[currPos[0]][currPos[1]]
        grid[currPos[0] + direction[0]][currPos[1] + 1] = grid[currPos[0]][currPos[1] + 1]
        grid[currPos[0]][currPos[1]] = "."
        grid[currPos[0]][currPos[1] + 1] = "."
        return

    if grid[currPos[0] + direction[0]][currPos[1]] == "]":
        moveDoubleVert(grid, (currPos[0] + direction[0], currPos[1] - 1), direction)

    if grid[currPos[0] + direction[0]][currPos[1] + 1] == "[":
        moveDoubleVert(grid, (currPos[0] + direction[0], currPos[1] + 1), direction)

    grid[currPos[0] + direction[0]][currPos[1]] = grid[currPos[0]][currPos[1]]
    grid[currPos[0] + direction[0]][currPos[1] + 1] = grid[currPos[0]][currPos[1] + 1]
    grid[currPos[0]][currPos[1]] = "."
    grid[currPos[0]][currPos[1] + 1] = "."


 is free software: you can redistribute it and/or modify
 *     it under the terms of the GNU General Public License as published by
 *     the Free Software Foundation, version 3 of the License.
 *
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU General Public License for more details.
 *
 *     You should have received a copy of the GNU General Public License
 *     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

package analysis.opt

import analysis.opt.inliner.Inlinee.*
import analysis.opt.inliner.Inlinee.Companion.isSurelyInside
import analysis.opt.inliner.InliningCalculator
import analysis.opt.intervals.Intervals
import config.Config
import config.ConfigScope
import org.junit.jupiter.api.Assertions.*
import org.junit.jupiter.api.Test
import utils.*
import vc.data.*

class InliningCalculatorTest : TACBuilderAuxiliaries() {

    private fun TACProgramBuilder.BuiltTACProgram.checkQuery(vararg pairs: Pair<String, TACSymbol?>) {
        val calculator = InliningCalculator(code)
        calculator.go()
        for ((query, sym) in pairs) {
            assertEquals(sym?.let { Term(it) } ?: None, calculator.lhsVal(ptr(query)))
        }
    }

    private fun TACProgramBuilder.BuiltTACProgram.checkMap(base: Term, vararg pairs: Pair<Int, Term>) {
        val calculator = InliningCalculator(code)
        calculator.go()
//        calculator.debugPrinter().print(code)
        assertEquals(
            Mapping(
                buildTreapMap {
                    for ((key, value) in pairs) {
                        this[base + key] = value
                    }
                }),
            calculator.lhsVal(ptr("query"))
        )
    }

    @Test
    fun writeRead() {
        val prog = TACProgramBuilder {
            bMap1[32] assign a
            label("query")
            b assign bMap1[32]
            assert(False)
        }
        prog.checkQuery("query" to a)
    }

    @Test
    fun write2read2() {
        val prog = TACProgramBuilder {
            c assign 32
            bMap1[c] assign a
            f assign Add(cS, 40.asTACExpr)
            bMap1[f] assign b
            label("1")
            d assign bMap1[32]
            label("2")
            e assign bMap1[72]
            assert(False)
        }
        prog.checkQuery("1" to a, "2" to b)
    }

    @Test
    fun writeOverlap() {
        val prog = TACProgramBuilder {
            b assign Add(aS, 10.asTACExpr)
            bMap1[b] assign 1

            c assign Add(bS, 40.asTACExpr)
            bMap1[c] assign 2

            d assign Add(aS, 100.asTACExpr)
            bMap1[d] assign 3

            f assign Add(aS, 30.asTACExpr)
            bMap1[f] assign 8

            e assign Sub(cS, 20.asTACExpr)
            label("query")
            bMap1[e] assign 4

            assert(False)
        }
        ConfigScope(Config.exactByteMaps, true).use {
            prog.checkMap(
                Term(a),
                100 to Term(3),
                30 to Term(4)
            )
        }
        ConfigScope(Config.exactByteMaps, false).use {
            prog.checkMap(
                Term(a),
                10 to Term(1),
                50 to Term(2),
                100 to Term(3),
                30 to Term(4)
            )
        }
    }

    @Test
    fun overwrite() {
        val prog = TACProgramBuilder {


import win32gui, win32ui, win32con, win32api
import numpy as np
import time

def window_capture(filename):
  hwnd = 0 # 窗口的编号，0号表示当前活跃窗口
  # 根据窗口句柄获取窗口的设备上下文DC（Divice Context）
  hwndDC = win32gui.GetWindowDC(hwnd)
  # 根据窗口的DC获取mfcDC
  mfcDC = win32ui.CreateDCFromHandle(hwndDC)
  # mfcDC创建可兼容的DC
  saveDC = mfcDC.CreateCompatibleDC()
  # 创建bigmap准备保存图片
  saveBitMap = win32ui.CreateBitmap()
  # 获取监控器信息
  MoniterDev = win32api.EnumDisplayMonitors(None, None)
  w = MoniterDev[0][2][2]
  h = MoniterDev[0][2][3]
  # print w,h　　　#图片大小
  # 为bitmap开辟空间
  saveBitMap.CreateCompatibleBitmap(mfcDC, w, h)
  # 高度saveDC，将截图保存到saveBitmap中
  saveDC.SelectObject(saveBitMap)
  # 截取从左上角（0，0）长宽为（w，h）的图片
  saveDC.BitBlt((0, 0), (w, h), mfcDC, (0, 0), win32con.SRCCOPY)
  saveBitMap.SaveBitmapFile(saveDC, filename)

def get_screen_arry(size):
    width=size[2]-size[0]
    height=size[3]-size[1]

    hwnd = win32gui.GetDesktopWindow()
    hdc = win32gui.GetWindowDC(hwnd)
    dc = win32ui.CreateDCFromHandle(hdc)
    memdc = dc.CreateCompatibleDC()
    bitmap = win32ui.CreateBitmap()
    bitmap.CreateCompatibleBitmap(dc, width, height)
    oldbmp = memdc.SelectObject(bitmap)
    memdc.BitBlt((0,0), (width,height), dc, (size[0],size[1]), win32con.SRCCOPY)
    bits = bitmap.GetBitmapBits(False)
    memdc.SelectObject(oldbmp)
    win32gui.DeleteObject(bitmap.GetHandle())
    memdc.DeleteDC()
    win32gui.ReleaseDC(hwnd, hdc)

    array=np.zeros((width,height)).tolist()
    for y in range(height):
        for x in range(width):
            p = (y * width + x) * 4
            blu=bits[p+0]&255
            grn=bits[p+1]&255
            red=bits[p+2]&255
            array[x][y]=[red,grn,blu]

    return array

if __name__=="__main__":
  window_capture('test5.jpg')


erify = 0x9d,
    OpNumNotEqual = 0x9e,
    OpLessThan = 0x9f,
    OpGreaterThan = 0xa0,
    OpLessThanOrEqual = 0xa1,
    OpGreaterThanOrEqual = 0xa2,
    OpMin = 0xa3,
    OpMax = 0xa4,

    OpWithin = 0xa5,

    // crypto
    OpRipemd160 = 0xa6,
    OpSha1 = 0xa7,
    OpSha256 = 0xa8,
    OpHash160 = 0xa9,
    OpHash256 = 0xaa,
    OpCodeSeparator = 0xab,
    OpCheckSig = 0xac,
    OpCheckSigverify = 0xad,
    OpCheckMultisig = 0xae,
    OpCheckMultisigVerify = 0xaf,

    // expansion
    OpNop1 = 0xb0,
    OpCheckLocktimeVerify = 0xb1,
    OpCheckSequenceVerify = 0xb2,
    OpNop4 = 0xb3,
    OpNop5 = 0xb4,
    OpNop6 = 0xb5,
    OpNop7 = 0xb6,
    OpNop8 = 0xb7,
    OpNop9 = 0xb8,
    OpNop10 = 0xb9,

    OpInvalidOpcode,
}

/// Custom Types
/// Bitcoin Raw Block Header type

#[derive(Encode, Decode, Copy, Clone)]
pub struct RawBlockHeader([u8; 80]);

impl TryFrom<Vec<u8>> for RawBlockHeader {
    type Error = Error;

    fn try_from(v: Vec<u8>) -> Result<Self, Self::Error> {
        RawBlockHeader::from_bytes(v)
    }
}

impl RawBlockHeader {
    /// Returns a raw block header from a bytes slice
    ///
    /// # Arguments
    ///
    /// * `bytes` - A slice containing the header
    pub fn from_bytes<B: AsRef<[u8]>>(bytes: B) -> Result<RawBlockHeader, Error> {
        let slice = bytes.as_ref();
        if slice.len() != 80 {
            return Err(Error::InvalidHeaderSize);
        }
        let mut result = [0u8; 80];
        result.copy_from_slice(slice);
        Ok(RawBlockHeader(result))
    }

    /// Returns a raw block header from a bytes slice
    ///
    /// # Arguments
    ///
    /// * `bytes` - A slice containing the header
    pub fn from_hex<T: AsRef<[u8]>>(hex_string: T) -> Result<RawBlockHeader, Error> {
        let bytes = hex::decode(hex_string).map_err(|_e| Error::MalformedHeader)?;
        Self::from_bytes(&bytes)
    }

    /// Returns the hash of the block header using Bitcoin's double sha256
    pub fn hash(&self) -> H256Le {
        sha256d_le(self.as_bytes())
    }

    /// Returns the block header as a slice
    pub fn as_bytes(&self) -> &[u8] {
        &self.0
    }
}

impl PartialEq for RawBlockHeader {
    fn eq(&self, other: &Self) -> bool {
        let self_bytes = &self.0[..];
        let other_bytes = &other.0[..];
        self_bytes == other_bytes
    }
}

impl sp_std::fmt::Debug for RawBlockHeader {
    fn fmt(&self, f: &mut sp_


n, state == GLUT_DOWN);
}

#ifdef __FREEGLUT_EXT_H__
void ImGui_ImplGLUT_MouseWheelFunc(int button, int dir, int x, int y)
{
    ImGuiIO& io = ImGui::GetIO();
    io.AddMousePosEvent((float)x, (float)y);
    if (dir != 0)
        io.AddMouseWheelEvent(0.0f, dir > 0 ? 1.0f : -1.0f);
    (void)button; // Unused
}
#endif

void ImGui_ImplGLUT_ReshapeFunc(int w, int h)
{
    ImGuiIO& io = ImGui::GetIO();
    io.DisplaySize = ImVec2((float)w, (float)h);
}

void ImGui_ImplGLUT_MotionFunc(int x, int y)
{
    ImGuiIO& io = ImGui::GetIO();
    io.AddMousePosEvent((float)x, (float)y);
}

//-----------------------------------------------------------------------------

#endif // #ifndef IMGUI_DISABLE
/* { dg-do compile { target x86_64-*-* } } */

#include <stdint.h>
#include "libgccjit++.h"

#include "harness.h"

/**********************************************************************
 Support fns for creating code.
 **********************************************************************/

/* Make a "void FUNC_NAME (void)" function with a single block, returning
   that block.  */

static gccjit::block
make_single_block_func (gccjit::context ctxt, const char *func_name)
{
  gccjit::type void_type = ctxt.get_type (GCC_JIT_TYPE_VOID);
  std::vector<gccjit::param> params;
  gccjit::function func
    = ctxt.new_function (GCC_JIT_FUNCTION_EXPORTED,
			 void_type,
			 func_name, params, 0);
  return func.new_block ("initial");
}

/**********************************************************************
 Support fns for verifying code.
 **********************************************************************/

typedef void (*void_void_fn) (void);

static void_void_fn
get_test_fn (gcc_jit_result *result, const char *func_name)
{
  return (void_void_fn)gcc_jit_result_get_code (result, func_name);
}

/**********************************************************************
 test_i386_basic_asm_1: simple example of asm
 **********************************************************************/

/* Create the equivalent of:

     int src;
     int dst;

     void test_i386_basic_asm_1 (void)
     {
       // Quote from here in docs/cp/topics/asm.rst: example 1: C
       asm ("mov %1, %0\n\t"
            "add $1, %0"
            : "=r" (dst)
            : "r" (src));
       // Quote up to here in docs/cp/topics/asm.rst: example 1: C
     }

     i.e. copy src to dst and add 1 to dst.  */

static void
create_test_i386_basic_asm_1 (gcc_jit_context *c_ctxt)
{
  gccjit::context ctxt (c_ctxt);
  gccjit::type int_type = ctxt.get_type (GCC_JIT_TYPE_INT);
  gccjit::lvalue dst
    = ctxt.new_global (GCC_JIT_GLOBAL_EXPORTED, int_type, "dst");
  gccjit::lvalue src
    = ctxt.new_global (GCC_JIT_GLOBAL_EXPORTED, int_type, "src");

  gccjit::block


="sandpackTheme"
  :files="buttonExampleFiles"
  :customSetup='{
    dependencies: {
      "lucide-react": "latest"
    }
  }'
  :options="{
    editorHeight: 320,
    editorWidthPercentage: 60,
  }"
/>
---
title: Illustrator Template Guide
---

# Illustrator Template Guide

This Guide explains how to properly use the Adobe Illustrator Template for Lucide.

>Attention: Even though it is unlikely the template can be outdated or not 100% correct. Please check the Icon Design Guide before you start working with the template to ensure integrity with the Lucide icon pack.

## General Workflow

The Illustrator template is created following guidelines from the [Icon Design Guide](icon-design-guide.md).

**Workflow:**

1. Download and open the [Illustrator template](https://github.com/lucide-icons/lucide/blob/main/docs/public/templates/illustrator_template.ai).

2. You can now remove the content from the example logo layer ("Draw") and start creating.

3. Verify that you follow the [Icon Design Guidelines](icon-design-guide.md).

4. Before you export the file as an SVG make sure to check that you followed the guidelines and remove all unnecessary layers (especially "Padding" and "Grid").

5. Export the file with the export menu under: `Export > Export As..` then save the file as SVG. Select the following options in the SVG Options dialog:

![SVG export options in Illustrator](../../images/illustrator-svg-options.png?raw=true "Setting Page Size")

After that, double check that the [code conventions and SVG global attributes](icon-design-guide.md#code-conventions) are correct.

7. Minify paths with [SVGOMG](https://jakearchibald.github.io/svgomg/).
# KeychainAccess
[![CI Status](http://img.shields.io/travis/kishikawakatsumi/KeychainAccess.svg)](https://travis-ci.org/kishikawakatsumi/KeychainAccess)
[![codecov](https://codecov.io/gh/kishikawakatsumi/KeychainAccess/branch/master/graph/badge.svg)](https://codecov.io/gh/kishikawakatsumi/KeychainAccess)
[![Carthage compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage)
[![Version](https://img.shields.io/cocoapods/v/KeychainAccess.svg)](http://cocoadocs.org/docsets/KeychainAccess)
[![Platform](https://img.shields.io/cocoapods/p/KeychainAccess.svg)](http://cocoadocs.org/docsets/KeychainAccess)
[![Swift 3.x](https://img.shields.io/badge/Swift-3.x-orange.svg?style=flat)](https://swift.org/)
[![Swift 4.0](https://img.shields.io/badge/Swift-4.0-orange.svg?style=flat)](https://swift.org/)
[![Swift 4.1](https://img.shields.io/badge/Swift-4.1-orange.svg?style=flat)](https://swift.org/)
[![Swift 4.2](https://img.shields.io/badge/Swift-4.2-orange.svg?style=flat)](https://swift.org/)

KeychainAccess is a simple Swift wrapper for Keychain that works on iOS and OS X. Makes using Keychain APIs extremely easy and much more palatable to use in Swift.

<img src="https://raw.githubusercon


s.banner = banner;
        return this;
    }

    addArgument<Key extends keyof ArgResults>(name: Key, aliases: string[], help: string, required: boolean, type: ArgType): SimpleArgParser<ArgResults> {
        if (type === "trailing") {
            if (this.watchedArgs.some((arg) => arg.type === "trailing")) {
                throw new Error(`Can't add arg with name: ${name}, since another trailing arg already exists`);
            }
        }

        const allAliases = [`--${name}`, `-${name}`, ...aliases];
        for (const arg of allAliases) {
            const argExists = this.watchedArgs.some((argInfo) => argInfo.allAliases.indexOf(arg as string) !== -1);
            if (argExists) {
                throw new Error(`Can't add arg with name ${arg}, since it already was added.`);
            }
        }

        this.watchedArgs.push({
            name: name as string,
            allAliases: allAliases as string[],
            help: help,
            required: required,
            type: type
        });

        return this;
    }

    parse<ArgResults>(argv: string[]): ArgResults {
        const trimmedArgv = argv.slice(2); // Remove the name + path.
        // TODO: Support a fancy help file.

        const requiredArgs = this.watchedArgs.filter((argInfo) => argInfo.required);
        for (const requiredArgInfo of requiredArgs) {
            if (!requiredArgInfo.allAliases.some((argName) => trimmedArgv.indexOf(argName) !== -1)) {
                throw new Error(`Missing required arg with name ${requiredArgInfo.name}, or aliases: ${requiredArgInfo.allAliases.splice(1)}`);
            }
        }

        const argResults: { [name: string]: any } = {};
        for (const argInfo of this.watchedArgs) {
            if (argInfo.type === "boolean") {
                argResults[argInfo.name] = this.extractBoolean(argInfo.allAliases, trimmedArgv);
            } else if (argInfo.type === "string") {
                const result = this.extractString(argInfo.allAliases, trimmedArgv);
                if (result !== null) {
                    argResults[argInfo.name] = result;
                }
            } else if (argInfo.type === "trailing") {
                const result = this.extractTrailing(trimmedArgv);
                if (result !== null) {
                    argResults[argInfo.name] = result;
                }
            }
        }

        return argResults as ArgResults;
    }

    private extractBoolean(names: string[], argv: string[]): boolean {
        for (let i = 0; i < argv.length; i++) {
            if (names.indexOf(argv[i]) !== -1) {
                const nextValue = argv[i + 1];
                const isExplicitlyFalse = typeof nextValue === "string" && nextValue.toLowerCase() === "false";

                return !isExplicitlyFalse;
            }
        }

        return false;
    }

    private extractString(names: string[], argv: string[]): string | null {
        for (let i = 0; i < argv.length; i++) {
            if (names.indexOf(argv[i]) !== -1) {
                const nextValue = argv[i + 1];
                if (i === argv.length - 1) {
                    throw


_melspectrogram(pred_spec.T)
        return figures, {"audio": audio}

    def train_log(
        self, batch: dict, outputs: dict, logger: "Logger", assets: dict, steps: int
    ) -> None:  # pylint: disable=no-self-use
        """Log training progress."""
        figures, audios = self._create_logs(batch, outputs, self.ap)
        logger.train_figures(steps, figures)
        logger.train_audios(steps, audios, self.ap.sample_rate)

    def eval_step(self, batch: dict, criterion: nn.Module):
        return self.train_step(batch, criterion)

    def eval_log(self, batch: dict, outputs: dict, logger: "Logger", assets: dict, steps: int) -> None:
        figures, audios = self._create_logs(batch, outputs, self.ap)
        logger.eval_figures(steps, figures)
        logger.eval_audios(steps, audios, self.ap.sample_rate)

    @staticmethod
    def init_from_config(config: "Tacotron2Config", samples: Union[List[List], List[Dict]] = None):
        """Initiate model from config

        Args:
            config (Tacotron2Config): Model config.
            samples (Union[List[List], List[Dict]]): Training samples to parse speaker ids for training.
                Defaults to None.
        """
        from TTS.utils.audio import AudioProcessor

        ap = AudioProcessor.init_from_config(config)
        tokenizer, new_config = TTSTokenizer.init_from_config(config)
        speaker_manager = SpeakerManager.init_from_config(new_config, samples)
        return Tacotron2(new_config, ap, tokenizer, speaker_manager)


	rdi, 64
	add	rcx, 2
	jne	.LBB1_453
	jmp	.LBB1_678
.LBB1_454:
	mov	esi, r10d
	and	esi, -32
	vmovd	xmm0, eax
	vpbroadcastd	ymm0, xmm0
	lea	rcx, [rsi - 32]
	mov	r9, rcx
	shr	r9, 5
	add	r9, 1
	test	rcx, rcx
	je	.LBB1_685
# %bb.455:
	mov	rcx, r9
	and	rcx, -2
	neg	rcx
	xor	edi, edi
.LBB1_456:                              # =>This Inner Loop Header: Depth=1
	vmovdqu	ymm1, ymmword ptr [rdx + 4*rdi]
	vmovdqu	ymm2, ymmword ptr [rdx + 4*rdi + 32]
	vmovdqu	ymm3, ymmword ptr [rdx + 4*rdi + 64]
	vmovdqu	ymm4, ymmword ptr [rdx + 4*rdi + 96]
	vpsubd	ymm1, ymm1, ymm0
	vpsubd	ymm2, ymm2, ymm0
	vpsubd	ymm3, ymm3, ymm0
	vpsubd	ymm4, ymm4, ymm0
	vmovdqu	ymmword ptr [r8 + 4*rdi], ymm1
	vmovdqu	ymmword ptr [r8 + 4*rdi + 32], ymm2
	vmovdqu	ymmword ptr [r8 + 4*rdi + 64], ymm3
	vmovdqu	ymmword ptr [r8 + 4*rdi + 96], ymm4
	vmovdqu	ymm1, ymmword ptr [rdx + 4*rdi + 128]
	vmovdqu	ymm2, ymmword ptr [rdx + 4*rdi + 160]
	vmovdqu	ymm3, ymmword ptr [rdx + 4*rdi + 192]
	vmovdqu	ymm4, ymmword ptr [rdx + 4*rdi + 224]
	vpsubd	ymm1, ymm1, ymm0
	vpsubd	ymm2, ymm2, ymm0
	vpsubd	ymm3, ymm3, ymm0
	vpsubd	ymm4, ymm4, ymm0
	vmovdqu	ymmword ptr [r8 + 4*rdi + 128], ymm1
	vmovdqu	ymmword ptr [r8 + 4*rdi + 160], ymm2
	vmovdqu	ymmword ptr [r8 + 4*rdi + 192], ymm3
	vmovdqu	ymmword ptr [r8 + 4*rdi + 224], ymm4
	add	rdi, 64
	add	rcx, 2
	jne	.LBB1_456
	jmp	.LBB1_686
.LBB1_457:
	mov	esi, r10d
	and	esi, -32
	vmovd	xmm0, eax
	vpbroadcastd	ymm0, xmm0
	lea	rcx, [rsi - 32]
	mov	r9, rcx
	shr	r9, 5
	add	r9, 1
	test	rcx, rcx
	je	.LBB1_693
# %bb.458:
	mov	rcx, r9
	and	rcx, -2
	neg	rcx
	xor	edi, edi
.LBB1_459:                              # =>This Inner Loop Header: Depth=1
	vpaddd	ymm1, ymm0, ymmword ptr [rdx + 4*rdi]
	vpaddd	ymm2, ymm0, ymmword ptr [rdx + 4*rdi + 32]
	vpaddd


 != BiomeGenBase.coldTaiga.biomeID && k1 != BiomeGenBase.coldTaiga.biomeID && l != BiomeGenBase.icePlains.biomeID && i1 != BiomeGenBase.icePlains.biomeID && j1 != BiomeGenBase.icePlains.biomeID && k1 != BiomeGenBase.icePlains.biomeID)
                        {
                            if (l != BiomeGenBase.jungle.biomeID && k1 != BiomeGenBase.jungle.biomeID && i1 != BiomeGenBase.jungle.biomeID && j1 != BiomeGenBase.jungle.biomeID)
                            {
                                aint1[j + i * areaWidth] = k;
                            }
                            else
                            {
                                aint1[j + i * areaWidth] = BiomeGenBase.jungleEdge.biomeID;
                            }
                        }
                        else
                        {
                            aint1[j + i * areaWidth] = BiomeGenBase.plains.biomeID;
                        }
                    }
                    else
                    {
                        aint1[j + i * areaWidth] = k;
                    }
                }
            }
        }

        return aint1;
    }

    /**
     * Creates a border around a biome if necessary, e.g. A transition from hot to cold climates would otherwise occur.
     */
    private boolean replaceBiomeEdgeIfNecessary(int[] p_151636_1_, int[] p_151636_2_, int p_151636_3_, int p_151636_4_, int p_151636_5_, int p_151636_6_, int p_151636_7_, int p_151636_8_)
    {
        if (!biomesEqualOrMesaPlateau(p_151636_6_, p_151636_7_))
        {
            return false;
        }
        else
        {
            int i = p_151636_1_[p_151636_3_ + 1 + (p_151636_4_ + 1 - 1) * (p_151636_5_ + 2)];
            int j = p_151636_1_[p_151636_3_ + 1 + 1 + (p_151636_4_ + 1) * (p_151636_5_ + 2)];
            int k = p_151636_1_[p_151636_3_ + 1 - 1 + (p_151636_4_ + 1) * (p_151636_5_ + 2)];
            int l = p_151636_1_[p_151636_3_ + 1 + (p_151636_4_ + 1 + 1) * (p_151636_5_ + 2)];

            if (this.canBiomesBeNeighbors(i, p_151636_7_) && this.canBiomesBeNeighbors(j, p_151636_7_) && this.canBiomesBeNeighbors(k, p_151636_7_) && this.canBiomesBeNeighbors(l, p_151636_7_))
            {
                p_151636_2_[p_151636_3_ + p_151636_4_ * p_151636_5_] = p_151636_6_;
            }
            else
            {
                p_151636_2_[p_151636_3_ + p_151636_4_ * p_151636_5_] = p_151636_8_;
            }

            return true;
        }
    }

    /**
     * Creates a border around a biome.
     */
    private boolean replaceBiomeEdge(int[] p_151635_1_, int[] p_151635_2_, int p_151635_3_, int p_151635_4_, int p_151635_5_, int p_151635_6_, int p_151635_7_, int p_151635_8_)
    {
        if (p_1516


@media only screen and (max-width: 960px){#branding-pin{display:none}}#branding-menu{position:absolute;top:50%;left:20px;left:1.42857rem;margin-top:-8px;margin-top:-0.57143rem;display:inline-block;font-size:16px;font-size:1.14286rem;cursor:pointer}#branding-menu:hover{color:#fff}@media only screen and (max-width: 960px){#branding-menu{display:none}}#user-tools{display:none}#user-tools.initialized{display:block}.user-tools ul{position:absolute;top:11px;top:0.78571rem;right:20px;right:1.42857rem;border:1px solid #dce0e6;border:0.07143rem solid #dce0e6;border-radius:4px;border-radius:0.28571rem;font-size:12px;font-size:0.85714rem;margin:0;padding:0;list-style:none;display:inline-block;width:175px;width:12.5rem;z-index:4}@media only screen and (max-width: 960px){.user-tools ul{position:fixed;top:0;right:0;width:auto;max-width:200px;max-width:14.28571rem;color:#C2B8E0;border:0;border-left:1px solid #4d3b73;border-left:0.07143rem solid #4d3b73;border-radius:0;-webkit-transform:none;transform:none;transition:-webkit-transform .3s;transition:transform .3s;transition:transform .3s, -webkit-transform .3s}body.scroll-to-bottom .user-tools ul{-webkit-transform:translate3d(0, -100%, 0);transform:translate3d(0, -100%, 0)}.user-tools ul.sidebar-opened{-webkit-transform:translate3d(100%, 0, 0);transform:translate3d(100%, 0, 0)}}.user-tools ul.opened{background-color:#5e4d99;border-color:transparent;color:#fff}@media only screen and (max-width: 960px){.user-tools ul.opened{border-radius:0 0 0 4px;border-radius:0 0 0 0.28571rem;border:0}}.user-tools ul li{display:block;list-style-type:none;margin:0;padding:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.user-tools ul li.user-tools-welcome-msg{font-weight:bold;padding:0 10px 0 14px;padding:0 0.71429rem 0 1rem;line-height:30px;line-height:2.14286rem}@media only screen and (max-width: 960px){.user-tools ul li.user-tools-welcome-msg{padding-left:18px;padding-left:1.28571rem;line-height:44px;line-height:3.14286rem}}.user-tools ul li.user-tools-welcome-msg:before{font-family:'jet-icons';speak:none;font-style:normal;font-weight:normal;font-variant:normal;text-transform:none;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;display:inline-block;content:"";font-weight:normal;float:right;color:#47bac1;font-size:24px;font-size:1.71429rem;vertical-align:middle;line-height:30px;line-height:2.14286rem;transition:color .3s;margin-left:5px;margin-left:0.35714rem}@media only screen and (max-width: 960px){.user-tools ul li.user-tools-welcome-msg:before{line-height:44px;line-height:3.14286rem;font-size:20px;font-size:1.4285


age.
  add REG_JIT_SCRATCH, REG_JIT_ADDR, #1
  and REG_JIT_SCRATCH, REG_JIT_SCRATCH, #0xFF
  ldrb REG_JIT_SCRATCH_32, [REG_MEM_READ, REG_JIT_SCRATCH]
  ldrb REG_JIT_ADDR_32, [REG_MEM_READ, REG_JIT_ADDR]
  orr REG_JIT_ADDR, REG_JIT_ADDR, REG_JIT_SCRATCH, lsl #8

ASM_SYM(asm_jit_addr_load_16bit_wrap_END):
  ret

.globl ASM_SYM(asm_jit_addr_load_addr)
.globl ASM_SYM(asm_jit_addr_load_addr_END)
ASM_SYM(asm_jit_addr_load_addr):
  ldrb REG_JIT_ADDR_32, [REG_MEM_READ, REG_JIT_ADDR]

ASM_SYM(asm_jit_addr_load_addr_END):
  ret

.globl ASM_SYM(asm_jit_addr_set)
.globl ASM_SYM(asm_jit_addr_set_END)
ASM_SYM(asm_jit_addr_set):
  movz REG_JIT_ADDR, 0xFFFF

ASM_SYM(asm_jit_addr_set_END):
  ret

.globl ASM_SYM(asm_jit_addr_set_base)
.globl ASM_SYM(asm_jit_addr_set_base_END)
ASM_SYM(asm_jit_addr_set_base):
  movz REG_JIT_ADDR_BASE, 0xFFFF

ASM_SYM(asm_jit_addr_set_base_END):
  ret

.globl ASM_SYM(asm_jit_addr_trunc_8bit)
.globl ASM_SYM(asm_jit_addr_trunc_8bit_END)
ASM_SYM(asm_jit_addr_trunc_8bit):
  and REG_JIT_ADDR, REG_JIT_ADDR, #0xFF

ASM_SYM(asm_jit_addr_trunc_8bit_END):
  ret

.globl ASM_SYM(asm_jit_call_scratch_param_load_param1)
.globl ASM_SYM(asm_jit_call_scratch_param_load_param1_END)
.globl ASM_SYM(asm_jit_call_scratch_param_load_function)
.globl ASM_SYM(asm_jit_call_scratch_param_load_function_END)
.globl ASM_SYM(asm_jit_call_scratch_param_call_function)
.globl ASM_SYM(asm_jit_call_scratch_param_call_function_END)
ASM_SYM(asm_jit_call_scratch_param_load_param1):
  ldr REG_PARAM1, [REG_SCRATCH1, 0x7FF8]
ASM_SYM(asm_jit_call_scratch_param_load_param1_END):
ASM_SYM(asm_jit_call_scratch_param_load_function):
  ldr REG_JIT_SCRATCH, [REG_SCRATCH1, 0x7FF8]
ASM_SYM(asm_jit_call_scratch_param_load_function_END):
ASM_SYM(asm_jit_call_scratch_param_call_function):
  blr REG_JIT_SCRATCH
ASM_SYM(asm_jit_call_scratch_param_call_function_END):
  ret

.globl ASM_SYM(asm_jit_check_bcd)
.globl ASM_SYM(asm


.75.75.75h13.5a.75.75 0 0 0 .75-.75v-2.69l-2.22-2.219a.75.75 0 0 0-1.06 0l-1.91 1.909.47.47a.75.75 0 1 1-1.06 1.06L6.53 8.091a.75.75 0 0 0-1.06 0l-2.97 2.97ZM12 7a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z' clip-rule='evenodd'/%3E%3C/svg%3E")}.EasyMDEContainer .editor-toolbar .undo:before{-webkit-mask-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20' fill='currentColor' class='size-5'%3E%3Cpath fill-rule='evenodd' d='M7.793 2.232a.75.75 0 0 1-.025 1.06L3.622 7.25h10.003a5.375 5.375 0 0 1 0 10.75H10.75a.75.75 0 0 1 0-1.5h2.875a3.875 3.875 0 0 0 0-7.75H3.622l4.146 3.957a.75.75 0 0 1-1.036 1.085l-5.5-5.25a.75.75 0 0 1 0-1.085l5.5-5.25a.75.75 0 0 1 1.06.025Z' clip-rule='evenodd'/%3E%3C/svg%3E");mask-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20' fill='currentColor' class='size-5'%3E%3Cpath fill-rule='evenodd' d='M7.793 2.232a.75.75 0 0 1-.025 1.06L3.622 7.25h10.003a5.375 5.375 0 0 1 0 10.75H10.75a.75.75 0 0 1 0-1.5h2.875a3.875 3.875 0 0 0 0-7.75H3.622l4.146 3.957a.75.75 0 0 1-1.036 1.085l-5.5-5.25a.75.75 0 0 1 0-1.085l5.5-5.25a.75.75 0 0 1 1.06.025Z' clip-rule='evenodd'/%3E%3C/svg%3E")}.EasyMDEContainer .editor-toolbar .redo:before{-webkit-mask-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20' fill='currentColor' class='size-5'%3E%3Cpath fill-rule='evenodd' d='M12.207 2.232a.75.75 0 0 0 .025 1.06l4.146 3.958H6.375a5.375 5.375 0 0 0 0 10.75H9.25a.75.75 0 0 0 0-1.5H6.375a3.875 3.875 0 0 1 0-7.75h10.003l-4.146 3.957a.75.75 0 0 0 1.036 1.085l5.5-5.25a.75.75 0 0 0 0-1.085l-5.5-5.25a.75.75 0 0 0-1.06.025Z' clip-rule='evenodd'/%3E%3C/svg%3E");mask-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20' fill='currentColor' class='size-5'%3E%3Cpath fill-rule='evenodd' d='M12.207 2.232a.75.75 0 0 0 .025 1.06l4.146 3.958H6.375a5.375 5.375 0 0 0 0 10.75H9.25a.75.75 0 0 0 0-1.5H6.375a3.875 3.875 0 0 1 0-7.75h10.003l-4.146 3.957a.75.75 0 0 0 1.036 1.085l5.5-5.25a.75.75 0 0 0 0-1.085l-5.5-5.25a.75.75 0 0 0-1.06.025Z' clip-rule='evenodd'/%3E%3C/svg%3E")}.EasyMDEContainer .editor-statusbar{display:none


            glVertex2f(x + m_bar_x, y + m_bar_offset);
            glVertex2f(x + m_bar_x + m_bar_w, y + m_bar_offset);
            glVertex2f(x + m_bar_x + m_bar_w, y + m_bar_offset + m_bar_h);
            glVertex2f(x + m_bar_x, y + m_bar_offset + m_bar_h);
            glEnd();

            glColor3fv((GLfloat *) &m_bar_color_inner.r);
            glRectf(x + m_bar_x, y + m_bar_offset + m_bar_h, x + m_bar_x + ((m_bar_w-1)*(*p)->GetPercentage()), y + m_bar_offset + 1);

            y += m_separation;
        }

    }

    endWinCoords();
}

bool
ParamListGL::Mouse(int x, int y, int button, int state)
{
    if ((y < m_start_y) || (y > (int)(m_start_y + (m_separation * m_params.size()) - 1)))
        return false;

    int i = (y - m_start_y) / m_separation;

    if ((button==GLUT_LEFT_BUTTON) && (state==GLUT_DOWN)) {
#if defined(__GNUC__) && (__GNUC__ < 3)
        m_current = &m_params[i];
#else
        // MJH: workaround since the version of vector::at used here is non-standard
        for (m_current = m_params.begin(); m_current != m_params.end() && i > 0; m_current++, i--) ;
        //m_current = (std::vector<ParamBase *>::const_iterator)&m_params.at(i);
#endif

        if ((x > m_bar_x) && (x < m_bar_x + m_bar_w)) {
            Motion(x, y);
        }
    }
    return true;
}

bool
ParamListGL::Motion(int x, int y)
{
    if ((y < m_start_y) || (y > m_start_y + (m_separation * (int)m_params.size()) - 1) )
        return false;

    if (x < m_bar_x) {
        (*m_current)->SetPercentage(0.0);
        return true;
    }

    if (x > m_bar_x + m_bar_w) {
        (*m_current)->SetPercentage(1.0);
        return true;
    }

    (*m_current)->SetPercentage((x-m_bar_x) / (float) m_bar_w);
    return true;
}

void
ParamListGL::Special(int key, int /*x*/, int /*y*/)
{
    switch(key) {
    case GLUT_KEY_DOWN:
        Increment();
        break;
    case GLUT_KEY_UP:
        Decrement();
        break;
    case GLUT_KEY_RIGHT:
        GetCurrent()->Increment();
        break;
    case GLUT_KEY_LEFT:
        GetCurrent()->Decrement();
        break;
    case GLUT_KEY_HOME:
        GetCurrent()->Reset();
        break;
    case GLUT_KEY_END:
        GetCurrent()->SetPercentage(1.0);
        break;
    }
    glutPostRedisplay();
}
/*
 * Copyright 1993-2010 NVIDIA Corporation.  All rights reserved.
 *
 * Please refer to the NVIDIA end user license agreement (EULA) associated
 * with this source code for terms and conditions that govern your use of
 * this software. Any use, reproduction, disclosure, or distribution of
 * this software and related documentation outside the terms of the EULA
 * is strictly prohibited.
 *
 */

//
//  Utility funcs to wrap up saving a surface or the back buffer as a PPM file
//	In addition, wraps up a threshold comparision of two PPMs.
/


 [],
  "s_0_6": [],
  "w_0_6": [],
  "k_0_7": [],
  "s_0_7": [],
  "w_0_7": [],
  "k_0_8": [],
  "s_0_8": [],
  "w_0_8": [],
  "k_0_9": [],
  "s_0_9": [],
  "w_0_9": [],
  "k_0_10": [],
  "s_0_10": [],
  "w_0_10": [],
  "k_0_11": [],
  "s_0_11": [],
  "w_0_11": []
};

final Map<String, List<Map<String, dynamic>>> emptyHistoryBatchResponse = {
  "k_0_0": [],
  "s_0_0": [],
  "w_0_0": [],
  "k_0_1": [],
  "s_0_1": [],
  "w_0_1": [],
  "k_0_2": [],
  "s_0_2": [],
  "w_0_2": [],
  "k_0_3": [],
  "s_0_3": [],
  "w_0_3": [],
  "k_0_4": [],
  "s_0_4": [],
  "w_0_4": [],
  "k_0_5": [],
  "s_0_5": [],
  "w_0_5": [],
  "k_0_6": [],
  "s_0_6": [],
  "w_0_6": [],
  "k_0_7": [],
  "s_0_7": [],
  "w_0_7": [],
  "k_0_8": [],
  "s_0_8": [],
  "w_0_8": [],
  "k_0_9": [],
  "s_0_9": [],
  "w_0_9": [],
  "k_0_10": [],
  "s_0_10": [],
  "w_0_10": [],
  "k_0_11": [],
  "s_0_11": [],
  "w_0_11": []
};

final List<String> activeScriptHashes = [
  "3fedd8a2d5fc355727afe353413dc1a0ef861ba768744d5b8193c33cbc829339",
  "b6fce6c41154ccf70676c5c91acd9b6899ef0195e34b4c05c4920daa827c19a3",
  "0e8b6756b404db5a381fd71ad79cb595a6c36c938cf9913c5a0494b667c2151a",
  "c4b1d9cd4edb7c13eae863b1e4f8fd5acff29f1fe153c4f859906cbea26a3f2f"
];
abstract class GetUtxoSampleData {
  static const scriptHash0 =
      "477906c20249d06e4891c5c252957cdc4dd38b7932144a8b5407e2cdcdbf8be8";
  static const List<Map<String, dynamic>> utxos0 = [];

  static const scriptHash1 =
      "0d23f206295307df70e97534c4ceb92f82b4ebe7983342f8fd287071f90caf38";
  static const List<Map<String, dynamic>> utxos1 = [
    {
      "tx_pos": 0,
      "value": 45318048,
      "tx_hash":
          "9f2c45a12db0144909b5db269415f7319179105982ac70ed80d76ea79d923ebf",
      "height": 437146
    },
    {
      "tx_pos": 0,
      "value": 919195,
      "tx_hash":
          "3d2290c93436a3e964cfc2f0950174d8847b


;
            write!(writer, ";")?;
            writeln!(writer)?;
        }
        writeln!(writer)?;
        writeln!(writer, "        Ok({} {{", struct_ty.name)?;
        for field in &struct_ty.fields {
            writeln!(writer, "            {},", field.name)?;
        }
        writeln!(writer, "        }})")?;
        writeln!(writer, "    }}")?;
    }
    writeln!(writer, "}}")?;

    Ok(())
}

fn emit_ty(writer: &mut impl Write, ty: &Type) -> io::Result<()> {
    match ty {
        Type::Var(name) => write!(writer, "{}", name),
        Type::If(_, _, _) => write!(writer, "{rt}::InvalidDataDescription", rt = RT_NAME),
        Type::U8 => write!(writer, "u8"),
        Type::U16 => write!(writer, "u16"),
        Type::U32 => write!(writer, "u32"),
        Type::U64 => write!(writer, "u64"),
        Type::I8 => write!(writer, "i8"),
        Type::I16 => write!(writer, "i16"),
        Type::I32 => write!(writer, "i32"),
        Type::I64 => write!(writer, "i64"),
        Type::F32 => write!(writer, "f32"),
        Type::F64 => write!(writer, "f64"),
        Type::Bool => write!(writer, "bool"),
        Type::Rt(rt_ty) => match rt_ty {
            RtType::Either(lhs, rhs) => {
                write!(writer, "{rt}::Either<", rt = RT_NAME)?;
                emit_ty(writer, lhs)?;
                write!(writer, ", ")?;
                emit_ty(writer, rhs)?;
                write!(writer, ">")
            }
            RtType::U8 => write!(writer, "{rt}::U8", rt = RT_NAME),
            RtType::U16Le => write!(writer, "{rt}::U16Le", rt = RT_NAME),
            RtType::U16Be => write!(writer, "{rt}::U16Be", rt = RT_NAME),
            RtType::U32Le => write!(writer, "{rt}::U32Le", rt = RT_NAME),
            RtType::U32Be => write!(writer, "{rt}::U32Be", rt = RT_NAME),
            RtType::U64Le => write!(writer, "{rt}::U64Le", rt = RT_NAME),
            RtType::U64Be => write!(writer, "{rt}::U64Be", rt = RT_NAME),
            RtType::I8 => write!(writer, "{rt}::I8", rt = RT_NAME),
            RtType::I16Le => write!(writer, "{rt}::I16Le", rt = RT_NAME),
            RtType::I16Be => write!(writer, "{rt}::I16Be", rt = RT_NAME),
            RtType::I32Le => write!(writer, "{rt}::I32Le", rt = RT_NAME),
            RtType::I32Be => write!(writer, "{rt}::I32Be", rt = RT_NAME),
            RtType::I64Le => write!(writer, "{rt}::I64Le", rt = RT_NAME),
            RtType::I64Be => write!(writer, "{rt}::I64Be", rt = RT_NAME),
            RtType::F32Le => write!(writer, "{rt}::F32Le", rt = RT_NAME),
            RtType::F32Be => write!(writer, "{rt}::F32Be", rt = RT_NAME),
            RtType::F64Le => write!(writer, "{rt}::F64Le", rt = RT_NAME),
            RtType::F64Be => write!(writer, "{rt}::F64Be", rt = RT_NAME),
            RtType::InvalidDataDescription => {
                write!(writer, "{rt}::InvalidDataDescription",


TypeEnumeration.read(buffer);
        const value = PrimitiveTypeEnumeration.readPrimitiveForType(buffer, primitiveTypeEnum.Value);

        return new MemberPrimitiveTypedRecord(primitiveTypeEnum, value);
    }

}
// Learn TypeScript:
//  - [Chinese] http://www.cocos.com/docs/creator/scripting/typescript.html
//  - [English] http://www.cocos2d-x.org/docs/editors_and_tools/creator-chapters/scripting/typescript/index.html
// Learn Attribute:
//  - [Chinese] http://www.cocos.com/docs/creator/scripting/reference/attributes.html
//  - [English] http://www.cocos2d-x.org/docs/editors_and_tools/creator-chapters/scripting/reference/attributes/index.html
// Learn life-cycle callbacks:
//  - [Chinese] http://www.cocos.com/docs/creator/scripting/life-cycle-callbacks.html
//  - [English] http://www.cocos2d-x.org/docs/editors_and_tools/creator-chapters/scripting/life-cycle-callbacks/index.html

const {ccclass, property} = cc._decorator;

@ccclass
export default class MyListCell extends cc.Component {

    index:number = 0;
    data:any = null;

    // LIFE-CYCLE CALLBACKS:

    // onLoad () {},

    start () {

    }
    // update (dt) {},
    setData(data){
        this.data = data;
    }

    getData(){
        return this.data;
    }

    setIndex(index){
        this.index = index;
    }

    getIndex(){
        return this.index;
    }
}
export class MenuItem {

  /**
   * Menu name
   */
  public name: string;

  /**
   * Menu link
   */
  public link: string;

  /**
   * Css class for font awesome icon
   */
  public awesomeIcon: string;

  constructor(name?: string, link?: string, awesomeIcon?: string) {
    this.name = name;
    this.link = link;
    this.awesomeIcon = awesomeIcon;
  }

}
import { Field, ObjectType } from 'type-graphql';
import { Column, Entity, Index, ManyToOne, OneToMany } from 'typeorm';

import { MainEntity } from './MainEntity';
import { Office } from './Office';
import { User } from './User';

@ObjectType()
@Entity({ orderBy: { name: 'ASC' } })
export class Team extends MainEntity {
  @Field()
  @Column()
  @Index({ unique: true })
  name: string;

  @Field(() => Office, { nullable: true })
  @ManyToOne(() => Office, (office) => office.teams, {
    cascade: ['insert', 'update'],
  })
  office: Office;

  @Field(() => [User])
  @OneToMany(() => User, (user) => user.team, {
    cascade: true,
    onDelete: 'CASCADE',
    primary: true,
  })
  users: User[];
}
export class Comment {
    commentid: number;
    articleid: number;
    username: string;
    role: string;
    body: string;
    upvotes: number;
    downvotes: number;
    stars: number;

    constructor(articleId: number, username: string, role: string, body: string) {
        this.commentid = 1;
        this.articleid = articleId;
        this.username = username;
        this.role = role;
        this.body = body;
        this.upvotes = 0;
        this.downvotes = 0;
        this.stars = 0;
    }
}
import Item from './Item';
import Entity from './Entity';

interface RoomExits {
    north: Room | undefined
    west: Room | undefined
    south: Room | undefined
    east: Room | undefined

    northwest: Room | undefined


ltiSelectionMode => _multiSelectionMode;
  List<Peer> _currentTabCachedPeers = List.empty(growable: true);
  List<Peer> get currentTabCachedPeers => _currentTabCachedPeers;
  bool _isShiftDown = false;
  bool get isShiftDown => _isShiftDown;
  String _lastId = '';
  String get lastId => _lastId;

  PeerTabModel(this.parent) {
    // visible
    try {
      final option = bind.getLocalFlutterOption(k: kOptionPeerTabVisible);
      if (option.isNotEmpty) {
        List<dynamic> decodeList = jsonDecode(option);
        if (decodeList.length == _isVisible.length) {
          for (int i = 0; i < _isVisible.length; i++) {
            if (decodeList[i] is bool) {
              _isVisible[i] = decodeList[i];
            }
          }
        }
      }
    } catch (e) {
      debugPrint("failed to get peer tab visible list:$e");
    }
    // order
    try {
      final option = bind.getLocalFlutterOption(k: kOptionPeerTabOrder);
      if (option.isNotEmpty) {
        List<dynamic> decodeList = jsonDecode(option);
        if (decodeList.length == maxTabCount) {
          var sortedList = decodeList.toList();
          sortedList.sort();
          bool valid = true;
          for (int i = 0; i < maxTabCount; i++) {
            if (sortedList[i] is! int || sortedList[i] != i) {
              valid = false;
            }
          }
          if (valid) {
            for (int i = 0; i < orders.length; i++) {
              orders[i] = decodeList[i];
            }
          }
        }
      }
    } catch (e) {
      debugPrint("failed to get peer tab order list: $e");
    }
    // init currentTab
    _currentTab =
        int.tryParse(bind.getLocalFlutterOption(k: kOptionPeerTabIndex)) ?? 0;
    if (_currentTab < 0 || _currentTab >= maxTabCount) {
      _currentTab = 0;
    }
    _trySetCurrentTabToFirstVisibleEnabled();
  }

  setCurrentTab(int index) {
    if (_currentTab != index) {
      _currentTab = index;
      notifyListeners();
    }
  }

  String tabTooltip(int index) {
    if (index >= 0 && index < tabNames.length) {
      return translate(tabNames[index]);
    }
    return index.toString();
  }

  IconData tabIcon(int index) {
    if (index >= 0 && index < icons.length) {
      return icons[index];
    }
    return Icons.help;
  }

  setMultiSelectionMode(bool mode) {
    _multiSelectionMode = mode;
    if (!mode) {
      _selectedPeers.clear();
      _lastId = '';
    }
    notifyListeners();
  }

  select(Peer peer) {
    if (!_multiSelectionMode) {
      // https://github.com/flutter/flutter/issues/101275#issuecomment-1604541700
      // After onTap, the shift key should be pressed for a while when not in multiselection mode,
      // because onTap is delayed when onDoubleTap is not null
      if (isDesktop || isWebDesktop) return;
      _multiSelectionMode = true;
    }
    final cached = _currentTabCachedPeers.map((e) => e.id).toList();
    int thisIndex = cached.indexOf(peer.id);
    int lastIndex = cached.indexOf(_lastId);
    if (_isShiftDown && thisIndex >= 0 && lastIndex >= 0) {
      int start = min(thisIndex, lastIndex);
      int end = max(thisIndex, lastIndex);
      bool remove = isPeerSelected(peer.id);
      for


šiem nolūkiem. Noklikšķini uz “Noraidīt visas”, lai noraidītu sīkdatnes, izņemot tās, kuras ir noteikti nepieciešamas. Izvēlies <manageLink>pārvaldīt sīkdatnes</manageLink>, lai mainītu savas preferences.","CookieConsentBanner.updateFailure":"Neizdevās atjaunināt sīkdatņu preferences. Mēģini vēlreiz vēlāk.","CookieConsentBanner.updateSuccess":"Tavas sīkdatņu preferences tika veiksmīgi atjauninātas.","CopyButton.copied":"Nokopēts!","CopyButton.copy":"Kopēt","CopyButton.copyTooltip":"Kopēt","CPEfES":"Koplietot tērzētavu","CqDpiM":"Darba kopijas ID nokopēts","createWorkspace.cancel":"Atcelt","createWorkspace.continueToBillingButton":"Doties uz norēķiniem","createWorkspace.exampleTeamWorkspaceName":"Acme Inc.","createWorkspace.paymentErrorWarning":"Maksājumu lapā radās kļūda. Lūdzu, mēģini vēlreiz. Ja problēma joprojām pastāv, apmeklē vietni help.openai.com.","createWorkspace.selectBillingOption":"Atlasīt norēķinu opcijas","createWorkspace.selectTeamPlan":"Atlasīt plānu Team","createWorkspace.selectTeamPlanModalTitle":"Atlasi savas komandas plānu","createWorkspace.title":"Izveido darba kopiju","createWorkspace.workspaceNameDescription":"Izveido darba kopijas nosaukumu savai komandai. Nosaukumu var mainīt jebkurā brīdī.","createWorkspace.workspaceNameLabel":"Darba kopijas nosaukums","Ctw3o0":"Organizācijas ID nokopēts","cVAvAj":"Reģistrējies un izmēģini jaunāko modeli","Cvr6Bs":"Jauna tērzētava","czjW8I":"Dinamisks","D1Mw8a":"Informāciju par balsošanu vienmēr pārbaudi savā valsts vai vietējā vēlēšanu iestādē. Plašākai informācijai apmeklē <usElectionLink></usElectionLink>.","D4IuIb":"Atcelt","D9gbPp":"Atcelt","dalleControls.aspectRatio":"Attēla samērs","dalleControls.aspectRatio.square":"Kvadrāts","dalleControls.aspectRatio.squareExpanded":"Kvadrāta attēla samērs","dalleControls.aspectRatio.vertical":"Vertikāls","dalleControls.aspectRatio.verticalExpanded":"Vertikāls attēla samērs","dalleControls.aspectRatio.widescreen":"Platekrāns","dalleControls.aspectRatio.widescreenExpanded":"Platekrāna attēla samērs","dalleMessage.creatingImagesV2":"Attēla izveide","dalleMessage.errorCreatingV2":"Izveidojot attēlu, radās kļūda","dalleMessage.imageEditButton":"Rediģēt","dalleMessage.imageLoadError":"Ielādējot attēlu, radās kļūda","dalleMessage.imageViewerMetadataCopyButton":"Kopēt","dalleMessage.imageViewerMetadataCopyButtonCopied":"Nokopēts!","dalleMessage.imageViewerMetadataTitle":"Uzvedne","dalleMessage.stoppedV3":"Attēla izveide apturēta","dalleStyle.35mmFilm":"35\xa0mm filma","dalleStyle.35mmFilmExpanded":"35\xa0mm filmas stils","dalleStyle.3dWireframe":"3D karkasattēlojums","dalleStyle.abstract


id=228109 - variation
public void test155() {
	this.runConformTest(
		new String[] {
				"Y.java",
				"public class Y {\n" +
				"	public static void main(String[] args) {\n" +
				"		enum TestEnum {\n" +
				"			RED, GREEN, BLUE; \n" +
				"    		static int test = 0;  \n" +
				"		}\n" +
				"\n" +
				"		enum TestEnum2 {\n" +
				"			; \n" +
				"    		TestEnum2() {\n" +
				"        		TestEnum.test=12;\n" +
				"    		}\n" +
				"		}\n" +
				"	}\n" +
				"}\n"
		},
		"");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
public void test156() {
	this.runConformTest(
		new String[] {
				"Y.java",
				"public class Y {\n" +
				"	public static void main(String[] args) {\n" +
				"		enum TestEnum {\n" +
				"			RED, GREEN, BLUE; \n" +
				"    		static int test = 0;  \n" +
				"\n" +
				"    		TestEnum() {\n" +
				"       		 new Object() {\n" +
				"				{ TestEnum.test=10; }\n" +
				"				};\n" +
				"			}\n" +
				"		}\n" +
				"    }\n" +
				"}\n"
		},
		"");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
public void test157() {
	this.runNegativeTest(
		new String[] {
				"Y.java",
				"public class Y {\n" +
				"	public static void main(String[] args) {\n" +
				"		enum Foo {\n" +
				"			ONE, TWO, THREE;\n" +
				"			static int val = 10;\n" +
				"			Foo () {\n" +
				"				this(Foo.val);\n" +
				"				System.out.println(Foo.val);\n" +
				"			}\n" +
				"			Foo(int i){}\n" +
				"			{\n" +
				"				System.out.println(Foo.val);\n" +
				"			}\n" +
				"			int field = Foo.val;\n" +
				"		}\n" +
				"	}\n" +
				"}\n"
		},
		"----------\n" +
		"1. ERROR in Y.java (at line 7)\n" +
		"	this(Foo.val);\n" +
		"	         ^^^\n" +
		"Cannot refer to the static enum field Foo.val within an initializer\n" +
		"----------\n" +
		"2. ERROR in Y.java (at line 8)\n" +
		"	System.out.println(Foo.val);\n" +
		"	                       ^^^\n" +
		"Cannot refer to the static enum field Foo.val within an initializer\n" +
		"----------\n" +
		"3. ERROR in Y.java (at line 12)\n" +
		"	System.out.println(Foo.val);\n" +
		"	                       ^^^\n" +
		"Cannot refer to the static enum field Foo.val within an initializer\n" +
		"----------\n" +
		"4. ERROR in Y.java (at line 14)\n" +
		"	int field = Foo.val;\n" +
		"	                ^^^\n" +
		"Cannot refer to the static enum field Foo.val within an initializer\n" +
		"----------\n",
		JavacTestOptions.Javac


pdpwusd ymm2, ymm3, ymmword ptr [edi + 4*eax + 291]
// CHECK: encoding: [0xc4,0xe2,0x65,0xd2,0x94,0x87,0x23,0x01,0x00,0x00]
               vpdpwusd ymm2, ymm3, ymmword ptr [edi + 4*eax + 291]

// CHECK:      vpdpwusd ymm2, ymm3, ymmword ptr [eax]
// CHECK: encoding: [0xc4,0xe2,0x65,0xd2,0x10]
               vpdpwusd ymm2, ymm3, ymmword ptr [eax]

// CHECK:      vpdpwusd ymm2, ymm3, ymmword ptr [2*ebp - 1024]
// CHECK: encoding: [0xc4,0xe2,0x65,0xd2,0x14,0x6d,0x00,0xfc,0xff,0xff]
               vpdpwusd ymm2, ymm3, ymmword ptr [2*ebp - 1024]

// CHECK:      vpdpwusd ymm2, ymm3, ymmword ptr [ecx + 4064]
// CHECK: encoding: [0xc4,0xe2,0x65,0xd2,0x91,0xe0,0x0f,0x00,0x00]
               vpdpwusd ymm2, ymm3, ymmword ptr [ecx + 4064]

// CHECK:      vpdpwusd ymm2, ymm3, ymmword ptr [edx - 4096]
// CHECK: encoding: [0xc4,0xe2,0x65,0xd2,0x92,0x00,0xf0,0xff,0xff]
               vpdpwusd ymm2, ymm3, ymmword ptr [edx - 4096]

// CHECK:      vpdpwusd xmm2, xmm3, xmmword ptr [esp + 8*esi + 268435456]
// CHECK: encoding: [0xc4,0xe2,0x61,0xd2,0x94,0xf4,0x00,0x00,0x00,0x10]
               vpdpwusd xmm2, xmm3, xmmword ptr [esp + 8*esi + 268435456]

// CHECK:      vpdpwusd xmm2, xmm3, xmmword ptr [edi + 4*eax + 291]
// CHECK: encoding: [0xc4,0xe2,0x61,0xd2,0x94,0x87,0x23,0x01,0x00,0x00]
               vpdpwusd xmm2, xmm3, xmmword ptr [edi + 4*eax + 291]

// CHECK:      vpdpwusd xmm2, xmm3, xmmword ptr [eax]
// CHECK: encoding: [0xc4,0xe2,0x61,0xd2,0x10]
               vpdpwusd xmm2, xmm3, xmmword ptr [eax]

// CHECK:      vpdpwusd xmm2, xmm3, xmmword ptr [2*ebp - 512]
// CHECK: encoding: [0xc4,0xe2,0x61,0xd2,0x14,0x6d,0x00,0xfe,0xff,0xff]
               vpdpwusd xmm2, xmm3, xmmword ptr [2*ebp - 512]

// CHECK:      vpdpwusd xmm2, xmm3, xmmword ptr [ecx + 2032]
// CHECK: encoding: [0xc4,0xe2,0x61,0xd2,0x91,0xf0,0x07,0x00,0x00]
               vpdpwusd xmm2, xmm3, xmmword ptr [ecx + 2032]

// CHECK:      vpdpwusd xmm2, xmm3, xmmword ptr [edx - 2048]
// CHECK:


SP) × [6.0] <LINE TABULATION> (BK) ÷ [0.3]
× AC00 × 0308 × 000B ÷	#  × [0.3] HANGUL SYLLABLE GA (H2) × [9.0] COMBINING DIAERESIS (CM1_CM) × [6.0] <LINE TABULATION> (BK) ÷ [0.3]
× AC00 × 0308 × 0020 × 000B ÷	#  × [0.3] HANGUL SYLLABLE GA (H2) × [9.0] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) × [6.0] <LINE TABULATION> (BK) ÷ [0.3]
× AC00 ÷ FFFC ÷	#  × [0.3] HANGUL SYLLABLE GA (H2) ÷ [20.01] OBJECT REPLACEMENT CHARACTER (CB) ÷ [0.3]
× AC00 × 0020 ÷ FFFC ÷	#  × [0.3] HANGUL SYLLABLE GA (H2) × [7.01] SPACE (SP) ÷ [18.0] OBJECT REPLACEMENT CHARACTER (CB) ÷ [0.3]
× AC00 × 0308 ÷ FFFC ÷	#  × [0.3] HANGUL SYLLABLE GA (H2) × [9.0] COMBINING DIAERESIS (CM1_CM) ÷ [20.01] OBJECT REPLACEMENT CHARACTER (CB) ÷ [0.3]
× AC00 × 0308 × 0020 ÷ FFFC ÷	#  × [0.3] HANGUL SYLLABLE GA (H2) × [9.0] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) ÷ [18.0] OBJECT REPLACEMENT CHARACTER (CB) ÷ [0.3]
× AC00 × 007D ÷	#  × [0.3] HANGUL SYLLABLE GA (H2) × [13.02] RIGHT CURLY BRACKET (CL) ÷ [0.3]
× AC00 × 0020 × 007D ÷	#  × [0.3] HANGUL SYLLABLE GA (H2) × [7.01] SPACE (SP) × [13.02] RIGHT CURLY BRACKET (CL) ÷ [0.3]
× AC00 × 0308 × 007D ÷	#  × [0.3] HANGUL SYLLABLE GA (H2) × [9.0] COMBINING DIAERESIS (CM1_CM) × [13.03] RIGHT CURLY BRACKET (CL) ÷ [0.3]
× AC00 × 0308 × 0020 × 007D ÷	#  × [0.3] HANGUL SYLLABLE GA (H2) × [9.0] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) × [13.02] RIGHT CURLY BRACKET (CL) ÷ [0.3]
× AC00 × 000D ÷	#  × [0.3] HANGUL SYLLABLE GA (H2) × [6.0] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
× AC00 × 0020 × 000D ÷	#  × [0.3] HANGUL SYLLABLE GA (H2) × [7.01] SPACE (SP) × [6.0] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
× AC00 × 0308 × 000D ÷	#  × [0.3] HANGUL SYLLABLE GA (H2) × [9.0] COMBINING DIAERESIS (CM1_CM) × [6.0] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
× AC00 × 0308 × 0020 × 000D ÷	#


 can't be timed out now.
				assert!(pred(CoreIndex(1), would_be_timed_out)); // but threads can.
			}

			run_to_block(1 + group_rotation_frequency + thread_availability_period, |_| None);

			assert!(Scheduler::availability_timeout_predicate().is_none());
		});
	}

	#[test]
	fn availability_predicate_no_rotation() {
		let genesis_config = MockGenesisConfig {
			configuration: crate::configuration::GenesisConfig {
				config: HostConfiguration {
					group_rotation_frequency: 0, // no rotation
					..default_config()
				},
				..Default::default()
			},
			..Default::default()
		};
		let HostConfiguration {
			chain_availability_period,
			thread_availability_period,
			..
		} = default_config();
		let collator = CollatorId::from(Sr25519Keyring::Alice.public());

		let chain_a = ParaId::from(1);
		let thread_a = ParaId::from(2);

		let schedule_blank_para = |id, is_chain| Paras::schedule_para_initialize(id, ParaGenesisArgs {
			genesis_head: Vec::new().into(),
			validation_code: Vec::new().into(),
			parachain: is_chain,
		});

		new_test_ext(genesis_config).execute_with(|| {
			schedule_blank_para(chain_a, true);
			schedule_blank_para(thread_a, false);

			// start a new session with our chain & thread registered.
			run_to_block(1, |number| match number {
				1 => Some(SessionChangeNotification {
					new_config: HostConfiguration{
						// Note: the `group_rotation_frequency` config change
						// is not accounted for on session change
						// group_rotation_frequency: 0,
						..default_config()
					},
					validators: vec![
						ValidatorId::from(Sr25519Keyring::Alice.public()),
						ValidatorId::from(Sr25519Keyring::Bob.public()),
						ValidatorId::from(Sr25519Keyring::Charlie.public()),
						ValidatorId::from(Sr25519Keyring::Dave.public()),
						ValidatorId::from(Sr25519Keyring::Eve.public()),
					],
					..Default::default()
				}),
				_ => None,
			});

			// assign some availability cores.
			{
				AvailabilityCores::mutate(|cores| {
					cores[0] = Some(CoreOccupied::Parachain);
					cores[1] = Some(CoreOccupied::Parathread(ParathreadEntry {
						claim: ParathreadClaim(thread_a, collator),
						retries: 0,
					}))
				});
			}
			run_to_block(1 + 1, |_| None);
			run_to_block(1 + 1 + 100500, |_| None);
			{
				let pred = Scheduler::availability_timeout_predicate()
					.expect("predicate exists with no rotation");

				let now = System::block_number();

				assert!(!pred(CoreIndex(0), now)); // assigned: chain
				assert!(!pred(CoreIndex(1), now)); // assigned: thread
				assert!(pred(CoreIndex(2), now));

				// check the tighter bound on chains vs threads.
				assert!(pred(CoreIndex(0), now - chain_availability_period));
				assert!(pred(CoreIndex(1), now - thread_availability_period));

				// check the threshold is exact.
				assert!(!pred(CoreIndex(0), now - chain_availability_period + 1));
				assert!(!pred(CoreIndex(1), now - thread_availability_period + 1));
			}
		});
	}

	#[test]
	fn next_up_on_available_uses_next_scheduled_or_none_for_thread() {
		let mut config = default_config();
		conf


using System.Threading;
using System.Threading.Tasks;
using NormalizingApp.Lib;
using NormalizingApp.MVVM;

namespace NormalizingApp.ViewModels
{
    public class CurvePageViewModel:NotifyObject
    {
        #region 曲线数据数字显示
        private float temperature1;
        public float Temperature1
        {
            get { return temperature1; }
            set
            {
                temperature1 = value;
                RaisePropertyChanged("Temperature1");
            }
        }
        private float temperature2;
        public float Temperature2
        {
            get { return temperature2; }
            set
            {
                temperature2 = value;
                RaisePropertyChanged("Temperature2");
            }
        }
        private float temperature3;
        public float Temperature3
        {
            get { return temperature3; }
            set
            {
                temperature3 = value;
                RaisePropertyChanged("Temperature3");
            }
        }
        private float temperature4;
        public float Temperature4
        {
            get { return temperature4; }
            set
            {
                temperature4 = value;
                RaisePropertyChanged("Temperature4");
            }
        }
        private float pressure;
        public float Pressure
        {
            get { return pressure; }
            set
            {
                pressure = value;
                RaisePropertyChanged("Pressure");
            }
        }
        private float


splay: flex;
    flex-flow: column nowrap;
    justify-content: center;
    align-items: center;
    overflow: hidden;
    z-index: 4;
  }
  .ui__theme {
    padding-top: 15em;
  }
  .ui__buttons {
    z-index: 5;
  }

  font-family: "BungeeFont";
  font-weight: normal;
  font-style: normal;

  src: url("data:font/truetype;charset=utf-8;base64,d09GMgABAAAAACZQABIAAAAAbvQAACXoAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP0ZGVE0cGh4byGIcgW4GYACDGghQCYRlEQgK7wjfAAuBRgABNgIkA4MIBCAFjGMHgw8MgjEb5WQV7NgLbgekMv6v8igENg5QCMa7I6pI6dn/H4+TI6pRucF/LYhNhovYtD4Krf6ybd4KjulSyDi2HjZEfrfyKtpdSpVGjIdn5NaN1SqtTduTgy2PuDLWjMCudfVcZNajE5NFViltnAyHDz5aQY/9KIf/iFKqiMiiy08NsWuNHaGxT3Kteqdfj2SUbAVpQ6QQooGSPMtAr3zE4COgr+M/Jp5/2u9/a8+dM9+c7JVIKJ5JGs0Sv0L9DSmN5KGYlEYlauL9wG/zn5W+IdY1EYl7dRyxAcHqOezADJa6+fdsjIo/de33u7JquDUr3ZpF9eZsy6Vv3n5Ii9EzmqragVH4fHPlZDGbveSSWYJscsdzRCkA6SrTVyPOqPr/Z1K0IGxVdd+bIh+ss5TyEAfykDerbO2vckwXma0Bn+NTRGUWtcrFcmqzqMFDTVWjEHrYb3gKFhFENBhGXzEslLDWl+NC+g9Ut6YZE8IiUOrBXKWTfCLj54mMxydSfp5IeVw+D5fD9XCG5vz30lywhwG8wKUpYPoubR/BR1YbOzNhpsSEfEJNflLibw248HD8cGyhEiolERKENjHEXjQienWD9uYSCvJ/y6bdpdsmDIqHREjeKbpC+eHf3J8ttL7gULha5qZRa0p3URE2QkfJvEiL0X+jRsbI/J+pZvv/LEDO8iJwDgq5OnVXlIpV5Vj5uZz9Oxjszu4ikhICcQxQBC+AgAKouBBgHQCHHIuSVEiQLkbeOaTaXe78VDpVLnPntjR8L9PZXtMr8zOEQr14vCtq2jnjxxJKoAjbWjaJxUBvNlKwlEsT/e9uZL73e/qz/g5HakVSCRIkHVNs638Wx0MvPaORQ4mtZqlXxY/8gwEQAB986zy6ALz74bRJAPiYq9oHAhgAqQAOISZEBeAABBD0WsedGJ5chHTbFHAjmwqA/7v903jc8b5FhvizM1NBcjJoc8vmc0Pa3c+SAToEdBLNK0XblKzqF9ci8YMgiXQAYkDgouIornaSG64d+zuuHAsbikQDE73ZeG77x4w1EMgzBsKRGJRil8/9s/HTqOUaiI3oBnvhKg3OiVQkif1txihAKdcZCpvAOIftLI9wzqBmQRcqp3Gk2Tkz6UcwgagZ3wAoB1tzIFCXwzgCVVzlhWGExap+Hvcn6Y3WyOARkeyCX0SNKR3RzNIpdO4MDGGYv8o4HK0RJa1jUkKZuEkqMjwc3cjjvadoOgA9AkpACQNnzZFlYqOMtqY5HjCKx8s7GD99IsiXAoH04HT3QcrHYvs+qMIx7EBwayBzijQKhmCS2VeV65VesIj40dE4FI5fdFb+GicK0JWRVbprkpwY62tAMTglcgzyNt9a50VMPAK5Esyx3kRf8poh6QutZw0v


 != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type FloodlightActivitiesPatchCall struct {
	s                  *Service
	profileId          int64
	floodlightactivity *FloodlightActivity
	urlParams_         gensupport.URLParams
	ctx_               context.Context
	header_            http.Header
}

// Patch: Updates an existing floodlight activity. This method supports patch
// semantics.
//
// - id: EventTag ID.
// - profileId: User profile ID associated with this request.
func (r *FloodlightActivitiesService) Patch(profileId int64, id int64, floodlightactivity *FloodlightActivity) *FloodlightActivitiesPatchCall {
	c := &FloodlightActivitiesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.profileId = profileId
	c.urlParams_.Set("id", fmt.Sprint(id))
	c.floodlightactivity = floodlightactivity
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *FloodlightActivitiesPatchCall) Fields(s ...googleapi.Field) *FloodlightActivitiesPatchCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *FloodlightActivitiesPatchCall) Context(ctx context.Context) *FloodlightActivitiesPatchCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *FloodlightActivitiesPatchCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *FloodlightActivitiesPatchCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.floodlightactivity)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{+profileId}/floodlightActivities")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PATCH", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"profileId": strconv.FormatInt(c.profileId, 10),
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "dfareporting.floodlightActivities.patch", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "dfareporting.floodlightActivities.patch" call.
// Any non-2xx status code is an error. Response headers are in either
// *FloodlightActivity.ServerResponse.Header or (if a response was returned at
// all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
// check whether the returned error was because http.StatusNotModified was
// returned.
func (c *FloodlightActivitiesPatchCall) Do(opts ...googleapi.CallOption) (*FloodlightActivity


قايتۇرامسىز؟ ___دىن ئېچىش___ئۆتۈپ كېتىش___ئادرېس كىرگۈزۈڭ/بەھرلەيدىغان ھۆججەت قىسقۇچ نامى ___قۇرۇلۇۋاتىدۇ، سەل ساقلاڭ...___يوللاش مەغلۇپ بولدى، قوبۇللىغۇچى تەرەپ قوبۇل قىلىشىنى رەت قىلغان___باھا بېرىش مۇۋەپپەقىيەتلىك بولدى___چاپلاش تاختىسى___ %sتۈر___ھۆججەت___سىلكىش___ساقلىۋېلىش___مۇلازىمىتېرىنى%sتەھرىرلەش___كومپيۇتېردا كىرگۈزۈلۈۋاتىدۇ :\n___ھۆججەت ئورنىنى ئېچىش___ھۆججەت قىسقۇچىنى\"%s\"مۇلازىمىتېر تىزىملىكىگە قوشۇش___خاتالىق كۆرۈلدى___مۇلازىمىتېردىكى ھۆججەتلەرنى ئىزدەش___يېڭى تور بەھىرلەش___ھۆججەتنى بەھرىلىگىلى بولمايدۇ___بەتنى يېڭىلاش___قاچىلىنىۋاتىدۇ___تور ئۇلاندى___ئۇلىنىش تېپىلمىدى， \n سىمسىز تورنى قوزغىتىڭ___سىناش نومۇرىنى كۆرسىتىش ___غول مۇندەرىجە___شىفىر تازىلاندى، قوغداش توختىتىلدى___بېسىپ تۇرۇپ تارتقاندا، يۆتكەش/ئۆچۈرۈش/بەھرىرلەش___يېڭى___ئەپ:___ئۆچۈرۈلدى___دىسكا بوشلۇقى___ساقلىغۇچ كارتا يوق ياكى سەپلەنمىگەن___ھازىرقى ئاساسىي مۇندەرىجە:___تىل تاللاش___غا قوشۇش___يوشۇرۇش شەكلى___كېسىش___ھېسابلىغۇچ___شىفىرنى كىرگۈزۈڭ___ئاكونت قوللانمىسى___ئۇسلۇبنى تەھرىرلەش___ساقلاش___كۆكچىش بەھرىلەنگەن مۇندەرىجە:___قالغىنى:___ھالىتى___يېڭى%sمۇلازىمىتېر قۇرۇش___


/// Use events to execute code when something happened or changed in the dialog.

using System.Windows;
using System.Windows.Controls;

var b = new wpfBuilder("Window").WinSize(400);
b.R.Add("Text", out TextBox t1).Focus();
b.R.Add("List", out ListBox list1).Items("Zero|One|Two");
b.R.Add(out CheckBox c1, "Check");
b.R.AddButton("Button", _ => { print.it("Button clicked"); c1.IsChecked = true; });
b.R.AddOkCancel();
b.End();

b.Loaded += () => { print.it("Loaded"); };
b.OkApply += e => { print.it("OkApply", e.Button); };

t1.TextChanged += (o, e) => {
	var v = o as TextBox;


localparam PAD_WIDTH       = (PAD_WIDTH_RAW == STEP_WORD_WIDTH) ? 0 : PAD_WIDTH_RAW;

We must add a bit of width to the step counter to deal with the special
 case where STEP_WORD_WIDTH equals WORD_WIDTH, so the STEP_WORD_COUNT
 is 1, and thus the counter would be of width zero, which is impossible.
 The overhead is insignificant and grows logarithmically at worst.

    localparam STEP_COUNT_WIDTH   = clog2(STEP_WORD_COUNT) + 1;
    localparam STEP_COUNT_INITIAL = STEP_WORD_COUNT - 1;
    localparam STEP_ONE           = {{STEP_COUNT_WIDTH-1{1'b0}},1'b1};
    localparam STEP_ZERO          = {STEP_COUNT_WIDTH{1'b0}};

Datapath

Carry Bit Storage

Set the initial step_carry_in into the step adder/subtractor to 1 (which
 matches the add_sub convention) if subtracting to complete the negation
 of the inverted B operand, and update it at each calculation step with the
 step_carry_out.  The final carry_out is calculated later, and depends on
 the PAD_WIDTH.

    reg  load_carry_initial     = 1'b0;
    reg  load_carry_step        = 1'b0;
    reg  step_carry_selected    = 1'b0;
    wire step_carry_out;
    wire step_carry_in;

    always @(*) begin
        step_carry_selected = (load_carry_initial == 1'b1) ? add_sub : step_carry_out;
    end

    Register
    #(
        .WORD_WIDTH     (1),
        .RESET_VALUE    (1'b0)
    )
    carry_storage
    (
        .clock          (clock),
        .clock_enable   (load_carry_step),
        .clear          (1'b0),
        .data_in        (step_carry_selected),
        .data_out       (step_carry_in)
    );

Input Pipeline for A

Extend A to the total width of the pipeline as a signed integer.

    wire [STEP_WORD_WIDTH_TOTAL-1:0] A_extended;

    Width_Adjuster
    #(
        .WORD_WIDTH_IN  (WORD_WIDTH),
        .SIGNED         (1),
        .WORD_WIDTH_OUT (STEP_WORD_WIDTH_TOTAL)
    )
    A_extender
    (
        .original_input     (A),
        .adjusted_output    (A_extended)
    );

Word-reverse A_extended so the pipeline outputs the least significant
 step word first.

    wire [STEP_WORD_WIDTH_TOTAL-1:0] A_reversed;

    Word_Reverser
    #(
        .WORD_WIDTH (STEP_WORD_WIDTH),
        .WORD_COUNT (STEP_WORD_COUNT)
    )
    A_reverser
    (
        .words_in   (A_extended),
        .words_out  (A_reversed)
    );

Read A_extended into the pipeline, and feed it out one step word at
 a time, from least to most-significant.

    reg                        load_A = 1'b0;
    wire [STEP_WORD_WIDTH-1:0] step_A;

    Register_Pipeline
    #(
        .WORD_WIDTH


start/stop
* characters are to be displayed in the human-readable message,
* extendedCharSetEnabled to indicate that the barcode can display characters
* from the entire 7-bit ASCII set, intercharGapWidth to control the width between
* the characters and a wideFactor attribute.

*
Interleaved2Of5 barcodes can specify checksumMode, displayChecksum and
* wideFactor attributes with the same meanings as in Code39 barcodes.

*
RoyalMailCustomer and USPSIntelligentMail barcodes have a checksumMode
* attribute, an intercharGapWidth attribute, an ascenderHeight attribute which
* sets the length of the bar ascender/descender, and a trackHeight attribute which
* provides the height of the barcode track.

*
POSTNET barcodes can specify checksumMode, displayChecksum and
* intercharGapWidth attributes, plus shortBarHeight for setting the height of
* the short bar, and baselinePosition which can be top or bottom
* to indicate how bars should align.

*
PDF417 barcode can control the number of columns and rows with the
* minColumns, maxColumns, minRows, maxRows and
* widthToHeightRatio attributes. The error correction level can be set using the
* errorCorrectionLevel attribute.

*
QRCode barcode can control its error correction level using the errorCorrectionLevel attribute.

*

* The object model for the barcode components uses
* {@link net.sf.jasperreports.barcode4j.BarcodeComponent BarcodeComponent}
* as base class and concrete classes for each barcode type.
*

* When a report that contains barcodes is filled, the data and attributes of the barcode are
* collected into an object and passed to an image producer whose responsibility is to create
* a renderer for the barcode. The image producer implements the
* {@link net.sf.jasperreports.barcode4j.BarcodeImageProducer BarcodeImageProducer}
* interface. As for Barbecue barcode elements, the resulting images have the size of the
* design barcode element and use RetainShape as scale type.
*

* Determining which image producer to use for a barcode component element relies on
* custom properties defined at the element, report and global levels. The
* {@link net.sf.jasperreports.barcode4j.BarcodeImageProducer#PROPERTY_IMAGE_PRODUCER net.sf.jasperreports.components.barcode4j.image.producer} property can
* have a value of the name of the class that implements the image producer interface or an
* alias that has been set for such a class, using a property of the form
* {@link net.sf.jasperreports.barcode4j.BarcodeImageProducer#PROPERTY_PREFIX_IMAGE_PRODUCER net.sf.jasperreports.components.barcode4j.image.producer.<alias>}.
* JasperReports has two barcode image producer implementations: one which renders the
* barcode in SVG format and one which renders the barcode as a rasterized image. The
* first implementation is registered under the svg alias and is used by default;
* the second one has image as alias and can be used by changing the
* {@link net.sf.jasperreports.barcode4j.BarcodeImageProducer#PROPERTY_PREFIX_IMAGE_PRODUCER net.sf.jasperreports.components.barcode4j.image.producer.<alias>}
* property at any level.
*

* The SVG barcode image producer uses the Barcode


 numpy as np

vec_col = np.array([1, 2, 3])[:, np.newaxis] # 형태: (3, 1)
vec_row = np.array([10, 20]) # 형태: (2,) -> (1, 2)로 브로드캐스팅됨

print(f"열 벡터 (vec_col):\n{vec_col}, shape: {vec_col.shape}")
print(f"행 벡터 (vec_row): {vec_row}, shape: {vec_row.shape}")

# 브로드캐스팅 과정:
# vec_col 형태: (3, 1)
# vec_row 형태: (2,) -> (1, 2)로 확장 (규칙 1 적용)
# 비교:
# - 마지막 차원: 1과 2 (하나가 1) -> 호환, 1이 2로 확장
# - 두 번째 차원: 3과 1 (하나가 1) -> 호환, 1이 3으로 확장
# 최종적으로 vec_col은 (3, 2)로, vec_row는 (3, 2)로 가상 확장되어 연산됩니다.

result_cross_broadcast = vec_col + vec_row
print(f"\nvec_col + vec_row (양쪽 브로드캐스팅):\n{result_cross_broadcast}")
# 결과:
# [[11 21]
#  [12 22]
#  [13 23]]
```

### 1.3. 브로드캐스팅의 한계 및 주의점

브로드캐스팅은 매우 편리하지만, 메모리 사용량에 주의해야 합니다. 브로드캐스팅은 실제로 데이터를 복사하여 배열을 확장하는 것이 아니라, **메모리를 효율적으로 사용하기 위해 가상으로 배열을 확장**하여 연산을 수행합니다. 하지만 연산의 결과물은 **확장된 크기의 새로운 배열**이 되어 메모리에 할당됩니다.

#### 1.3.1. 메모리 급증

매우 큰 두 배열을 브로드캐스팅하면, 결과 배열의 크기가 예상을 초과하여 메모리 부족(Out of Memory) 오류를 일으킬 수 있습니다.

```python
# 예시