 +
      "o:\0028\001\"\320\001\n\017PredictResponse\0221\n\nmodel_spec\030" +
      "\002 \001(\0132\035.tensorflow.serving.ModelSpec\022A\n\007" +
      "outputs\030\001 \003(\01320.tensorflow.serving.Predi" +
      "ctResponse.OutputsEntry\032G\n\014OutputsEntry\022" +
      "\013\n\003key\030\001 \001(\t\022&\n\005value\030\002 \001(\0132\027.tensorflow" +
      ".TensorProto:\0028\001B\003\370\001\001b\006proto3"
    };
    descriptor = com.google.protobuf.Descriptors.FileDescriptor
      .internalBuildGeneratedFileFrom(descriptorData,
        new com.google.protobuf.Descriptors.FileDescriptor[] {
          org.tensorflow.framework.TensorProtos.getDescriptor(),
          tensorflow.serving.Model.getDescriptor(),
        });
    internal_static_tensorflow_serving_PredictRequest_descriptor =
      getDescriptor().getMessageTypes().get(0);
    internal_static_tensorflow_serving_PredictRequest_fieldAccessorTable = new
      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
        internal_static_tensorflow_serving_PredictRequest_descriptor,
        new java.lang.String[] { "ModelSpec", "Inputs", "OutputFilter", });
    internal_static_tensorflow_serving_PredictRequest_InputsEntry_descriptor =
      internal_static_tensorflow_serving_PredictRequest_descriptor.getNestedTypes().get(0);
    internal_static_tensorflow_serving_PredictRequest_InputsEntry_fieldAccessorTable = new
      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
        internal_static_tensorflow_serving_PredictRequest_InputsEntry_descriptor,
        new java.lang.String[] { "Key", "Value", });
    internal_static_tensorflow_serving_PredictResponse_descriptor =
      getDescriptor().getMessageTypes().get(1);
    internal_static_tensorflow_serving_PredictResponse_fieldAccessorTable = new
      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
        internal_static_tensorflow_serving_PredictResponse_descriptor,
        new java.lang.String[] { "ModelSpec", "Outputs", });
    internal_static_tensorflow_serving_PredictResponse_OutputsEntry_descriptor =
      internal_static_tensorflow_serving_PredictResponse_descriptor.getNestedTypes().get(0);
    internal_static_tensorflow_serving_PredictResponse_OutputsEntry_fieldAccessorTable = new
      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
        internal_static_tensorflow_serving_PredictResponse_OutputsEntry_descriptor,
        new java.lang.String[] { "Key", "Value", });
    org.tensorflow.framework.TensorProtos.getDescriptor();
    tensorflow.serving.Model.getDescriptor();
  }

  // @@protoc_insertion_point(outer_class_scope)
}
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: tensorflow/core/example/feature.proto

package org.tensorflow.example;

/**
 * <pre>
 * Containers for sequential data.
 * A FeatureList contains lists of Features.  These may hold zero or more
 * Feature values.
 * FeatureLists are organized into categories by name.  The FeatureLists message
 * contains the mapping from name to FeatureList.
 * </pre>
 *
 * Protobuf type {@code tensorflow.FeatureList}
 */
public  final class FeatureList extends
    com.google.protobuf.GeneratedMessageV3 implements
    // @@protoc_insertion_point(message_implements:tensorflow.FeatureList)
    FeatureListOrBuilder {
private static final long serialVersionUID = 0L;
  // Use FeatureList.newBuilder() to construct.
  private FeatureList(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
    super(builder);
  }
  private FeatureList() {


iag=0, TTE_Soft=0,
        TTE_L=0, TTE_CP=0, TTE_CV=0, TTE_E=1, TTE_P=1, TTE_W=0
        }

.data

.global  dexec_pg16_data

dexec_pg16_data: .word   0x11223344
                .word   0x11223355
                .word   0x11223366
                .word   0x11223377
.end


ORDER=0 HEIGHT=21 WIDTH=67>

For questions or comments please
contact UDA Customer Service at info@uda1.com

Sales & Service 1-800-700-UDA1
(8321) www.uniteddesign.com

Copyright ©1996-2001
United Design Associates, Inc. All Rights Reserved.

</text>
<text id="http://www.1aiel.com/risky.htm" title="theatrical collectibles and vintage historical military rental western theater performing arts guns" encoding="unset">

<title>theatrical collectibles and vintage historical military rental western theater performing arts guns</title>

<meta name="keywords" content="theatrical collectibles and vintage, antiques military and clothing rental, hobbies and motorcycle cloths, theatrical collectibles and vintage, western, panzer re-enactment, guns, risky clothing, gifts">
<meta name="description" content="theatrical collectibles and vintage specialize in rental to order antique military clothing for panzer tunic motorcycle historical and western gun hobbies theatrical rental and collectibles WW 2 insignias re-enactors gifts and risky 1950's clothing">

"RISKY WOMENS CLOTHING"

<HR NOSHADE


1>

Maybe you tried to change something you didn't have access to.

If you are the application owner check the logs for more information.

<!doctype html>

    <title>The server cannot process the request due to a client error (400 Bad Request)</title>

    <meta charset="utf-8">
    <meta name="viewport" content="initial-scale=1, width=device-width">
    <meta name="robots" content="noindex, nofollow">


Test("uriPathAndQuery('http://www.contoso.com/catalog/shownew.htm?date=today')", "/catalog/shownew.htm?date=today"),
            Test("uriPort('http://www.localhost:8080')", 8080),
            Test("uriQuery('http://www.contoso.com/catalog/shownew.htm?date=today')", "?date=today"),
            Test("uriScheme('http://www.contoso.com/catalog/shownew.htm?date=today')", "http"),
            #endregion

            #region  collection functions test
            Test("sum(numberJArray)", 3),
            Test("sum(createArray(1, 2))", 3),
            Test("sum(createArray(one, two, 3))", 6.0),
            Test("average(createArray(1, 2))", 1.5),
            Test("average(createArray(one, two, 3))", 2.0),
            Test("contains('hello world', 'hello')", true),
            Test("contains('hello world', 'hellow')", false),
            Test("contains('hello world',\r\n 'hellow')", false),
            Test("contains(items, 'zero')", true),
            Test("contains(items, 'hi')", false),
            Test("contains(bag, 'three')", true),
            Test("contains(bag, 'xxx')", false),
            Test("contains([{ a: 1, b: { c: 2} }, { b: 2}], { a: 1, b: { c: 2} })", true),
            Test("concat(null, [1, 2], null)", new List<object> { 1, 2 }),
            Test("concat(createArray(1, 2), createArray(3, 4))", new List<object> { 1, 2, 3, 4 }),
            Test("concat(['a', 'b'], ['b', 'c'], ['c', 'd'])", new List<object> { "a", "b", "b", "c", "c", "d" }),
            Test("count(split(hello,'e'))", 2),
            Test("count(createArray('h', 'e', 'l', 'l', 'o'))", 5),
            Test("reverse(split(hello,'e'))", new List<object> { "llo", "h" }),
            Test("reverse(createArray('h', 'e', 'l', 'l', 'o'))", new List<object> { "o", "l", "l", "e", "h" }),
            Test("empty(null)", true),
            Test("empty('')", true),
            Test("empty('a')", false),
            Test("empty(bag)", false),
            Test("empty(items)", false),
            Test("first(items)", "zero"),
            Test("first('hello')", "h"),
            Test("first(createArray(0, 1, 2))", 0),
            Test("first(1)", null),
            Test("first(nestedItems).x", 1, new HashSet<string> { "nestedItems" }),
            Test("join(items,',')", "zero,one,two"),
            Test("join(createArray('a', 'b', 'c'), '.')", "a.b.c"),
            Test("join(createArray('a', 'b', 'c'), ',', ' and ')", "a,b and c"),
            Test("join(createArray('a', 'b'), ',', ' and ')", "a and b"),
            Test("join(createArray(\r\n'a',\r\n 'b'), ','\r\n,\r\n ' and ')", "a and b"),
            Test("join(foreach(dialog, item, item.key), ',')", "x,instance,options,title,subTitle"),
            Test("join(foreach(dialog, item => item.key), ',')", "x,instance,options,title,subTitle"),
            Test("foreach(dialog, item, item.value)[1].xxx", "instance"),
            Test("foreach(dialog, item=>item.value)[1].xxx", "instance"),
            Test("join(foreach(items, item, ite


 "interrupt" ||
      edge->rule().name() == "touch-interrupt") {
    result->status = ExitInterrupted;
    return true;
  }

  if (edge->rule().name() == "console") {
    if (edge->use_console())
      result->status = ExitSuccess;
    else
      result->status = ExitFailure;
    last_command_ = NULL;
    return true;
  }

  if (edge->rule().name() == "fail" ||
      (edge->rule().name() == "touch-fail-tick2" && fs_->now_ == 2))
    result->status = ExitFailure;
  else
    result->status = ExitSuccess;
  last_command_ = NULL;
  return true;
}

vector<Edge*> FakeCommandRunner::GetActiveEdges() {
  vector<Edge*> edges;
  if (last_command_)
    edges.push_back(last_command_);
  return edges;
}

void FakeCommandRunner::Abort() {
  last_command_ = NULL;
}

void BuildTest::Dirty(const string& path) {
  Node* node = GetNode(path);
  node->MarkDirty();

  // If it's an input file, mark that we've already stat()ed it and
  // it's missing.
  if (!node->in_edge())
    node->MarkMissing();
}

TEST_F(BuildTest, NoWork) {
  string err;
  EXPECT_TRUE(builder_.AlreadyUpToDate());
}

TEST_F(BuildTest, OneStep) {
  // Given a dirty target with one ready input,
  // we should rebuild the target.
  Dirty("cat1");
  string err;
  EXPECT_TRUE(builder_.AddTarget("cat1", &err));
  ASSERT_EQ("", err);
  EXPECT_TRUE(builder_.Build(&err));
  ASSERT_EQ("", err);

  ASSERT_EQ(1u, command_runner_.commands_ran_.size());
  EXPECT_EQ("cat in1 > cat1", command_runner_.commands_ran_[0]);
}

TEST_F(BuildTest, OneStep2) {
  // Given a target with one dirty input,
  // we should rebuild the target.
  Dirty("cat1");
  string err;
  EXPECT_TRUE(builder_.AddTarget("cat1", &err));
  ASSERT_EQ("", err);
  EXPECT_TRUE(builder_.Build(&err));
  EXPECT_EQ("", err);

  ASSERT_EQ(1u, command_runner_.commands_ran_.size());
  EXPECT_EQ("cat in1 > cat1", command_runner_.commands_ran_[0]);
}

TEST_F(BuildTest, TwoStep) {
  string err;
  EXPECT_TRUE(builder_.AddTarget("cat12", &err));
  ASSERT_EQ("", err);
  EXPECT_TRUE(builder_.Build(&err));
  EXPECT_EQ("", err);
  ASSERT_EQ(3u, command_runner_.commands_ran_.size());
  // Depending on how the pointers work out, we could've ran
  // the first two commands in either order.
  EXPECT_TRUE((command_runner_.commands_ran_[0] == "cat in1 > cat1" &&
               command_runner_.commands_ran_[1] == "cat in1 in2 > cat2") ||
              (command_runner_.commands_ran_[1] == "cat in1 > cat1" &&
               command_runner_.commands_ran_[0] == "cat in1 in2 > cat2"));

  EXPECT_EQ("cat cat1 cat2 > cat12", command_runner_.commands_ran_[2]);

  fs_.Tick();

  // Modifying in2 requires rebuilding one intermediate file
  // and the final file.
  fs_.Create("in2", "");
  state_.Reset();
  EXPECT_TRUE(builder_.AddTarget("cat12", &err));
  ASSERT_EQ("", err);
  EXPECT_TRUE(builder_.Build(&err));
  ASSERT_EQ("", err);
  ASSERT_EQ(5u, command_runner_.commands_ran_.size());
  EXPECT_EQ("cat in1 in2 > cat2", command_runner_.commands_ran_[3]);
  EX


.validationErrors, fmt.Sprintf("%s %s", err.Error(), "on PatternFlowPfcPauseSrcCounter.Start"))
		}

	}

	if obj.obj.Step != nil {

		err := obj.validateMac(obj.Step())
		if err != nil {
			vObj.validationErrors = append(vObj.validationErrors, fmt.Sprintf("%s %s", err.Error(), "on PatternFlowPfcPauseSrcCounter.Step"))
		}

	}

}

func (obj *patternFlowPfcPauseSrcCounter) setDefault() {
	if obj.obj.Start == nil {
		obj.SetStart("00:00:00:00:00:00")
	}
	if obj.obj.Step == nil {
		obj.SetStep("00:00:00:00:00:01")
	}
	if obj.obj.Count == nil {
		obj.SetCount(1)
	}

}
package gosnappi

import (
	"fmt"
	"strings"

	"github.com/ghodss/yaml"
	otg "github.com/open-traffic-generator/snappi/gosnappi/otg"
	"google.golang.org/protobuf/encoding/protojson"
	"google.golang.org/protobuf/proto"
)

// ***** IsisLspAdjacencySid *****
type isisLspAdjacencySid struct {
	validation
	obj          *otg.IsisLspAdjacencySid
	marshaller   marshalIsisLspAdjacencySid
	unMarshaller unMarshalIsisLspAdjacencySid
	flagsHolder  IsisLspAdjSidFlags
}

func NewIsisLspAdjacencySid() IsisLspAdjacencySid {
	obj := isisLspAdjacencySid{obj: &otg.IsisLspAdjacencySid{}}
	obj.setDefault()
	return &obj
}

func (obj *isisLspAdjacencySid) msg() *otg.IsisLspAdjacencySid {
	return obj.obj
}

func (obj *isisLspAdjacencySid) setMsg(msg *otg.IsisLspAdjacencySid) IsisLspAdjacencySid {
	obj.setNil()
	proto.Merge(obj.obj, msg)
	return obj
}

type marshalisisLspAdjacencySid struct {
	obj *isisLspAdjacencySid
}

type marshalIsisLspAdjacencySid interface {
	// ToProto marshals IsisLspAdjacencySid to protobuf object *otg.IsisLspAdjacencySid
	ToProto() (*otg.IsisLspAdjacencySid, error)
	// ToPbText marshals IsisLspAdjacencySid to protobuf text
	ToPbText() (string, error)
	// ToYaml marshals IsisLspAdjacencySid to YAML text
	ToYaml() (string, error)
	// ToJson marshals IsisLspAdjacencySid to JSON text
	ToJson() (string, error)
}

type unMarshalisisLspAdjacencySid struct {
	obj *isisLspAdjacencySid
}

type unMarshalIsisLspAdjacencySid interface {
	// FromProto unmarshals IsisLspAdjacencySid from protobuf object *otg.IsisLspAdjacencySid
	FromProto(msg *otg.IsisLspAdjacencySid) (IsisLspAdjacencySid, error)
	// FromPbText unmarshals IsisLspAdjacencySid from protobuf text
	FromPbText(value string) error
	// FromYaml unmarshals IsisLspAdjacencySid from YAML text
	FromYaml(value string) error
	// FromJson unmarshals IsisLspAdjacencySid from JSON text
	FromJson(value string) error
}

func (obj *isisLspAdjacencySid) Marshal() marshalIsisLspAdjacencySid {
	if obj.marshaller == nil {
		obj.marshaller = &marshalisisLspAdjacencySid{obj: obj}
	}
	return obj.marshaller
}

func (obj *isisLspAdjacencySid) Unmarshal() unMarshalIsisLspAdjacencySid {
	if obj.unMarshaller == nil {
		obj.unMarshaller = &unMarshalisisLspAdjacencyS


(VM.VerifyAssertions) VM._assert(!VM.runningVM);
    System.err.print(value);
  }

  /**
   * Low level print of an int to console.
   * @param value       what is printed
   */
  @NoInline
  /* don't waste code space inlining these --dave */
  public static void write(int value) {
    if (runningVM) {
      int mode = (value < -(1 << 20) || value > (1 << 20)) ? 2 : 0; // hex only or decimal only
      sysCall.sysConsoleWriteInteger(value, mode);
    } else {
      writeNotRunningVM(value);
    }
  }
  @UninterruptibleNoWarn("Interruptible code not reachable at runtime")
  private static void writeNotRunningVM(int value) {
    if (VM.VerifyAssertions) VM._assert(!VM.runningVM);
    System.err.print(value);
  }

  /**
   * Low level print to console.
   * @param value       What is printed, as hex only
   */
  @NoInline
  /* don't waste code space inlining these --dave */
  public static void writeHex(int value) {
    if (runningVM) {
      sysCall.sysConsoleWriteInteger(value, 2 /*just hex*/);
    } else {
      writeHexNotRunningVM(value);
    }
  }
  @UninterruptibleNoWarn("Interruptible code not reachable at runtime")
  private static void writeHexNotRunningVM(int value) {
    if (VM.VerifyAssertions) VM._assert(!VM.runningVM);
    System.err.print(Integer.toHexString(value));
  }

  /**
   * Low level print to console.
   * @param value       what is printed, as hex only
   */
  @NoInline
  /* don't waste code space inlining these --dave */
  public static void writeHex(long value) {
    if (runningVM) {
      sysCall.sysConsoleWriteLong(value, 2);
    } else {
      writeHexNotRunningVM(value);
    }
  }
  @UninterruptibleNoWarn("Interruptible code not reachable at runtime")
  private static void writeHexNotRunningVM(long value) {
    if (VM.VerifyAssertions) VM._assert(!VM.runningVM);
    System.err.print(Long.toHexString(value));
  }

  @NoInline
  /* don't waste code space inlining these --dave */
  public static void writeDec(Word value) {
    if (VM.BuildFor32Addr) {
      write(value.toInt());
    } else {
      write(value.toLong());
    }
  }

  @NoInline
  /* don't waste code space inlining these --dave */
  public static void writeHex(Word value) {
    if (VM.BuildFor32Addr) {
      writeHex(value.toInt());
    } else {
      writeHex(value.toLong());
    }
  }

  @NoInline
  /* don't waste code space inlining these --dave */
  public static void writeHex(Address value) {
    writeHex(value.toWord());
  }

  @NoInline
  /* don't waste code space inlining these --dave */
  public static void writeHex(ObjectReference value) {
    writeHex(value.toAddress().toWord());
  }

  @NoInline
  /* don't waste code space inlining these --dave */
  public static void writeHex(Extent value) {
    writeHex(value.toWord());
  }

  @NoInline
  /* don't waste code space inlining these --dave */
  public static void writeHex(Offset value) {
    writeHex(value.toWord());
  }

  /**
   * Low level print to console.
   * @param value       what is printed, as int only
   */
  @NoInline
  /* don't waste code space inlining these --dave */
  public static void writeInt(int value) {
    if (runningVM) {
      sysCall.sysConsoleWriteInteger


线模型 DriveLM（0.36 FPS）实现了 13.5 倍的惊人加速。更重要的是，在最为关键的驾驶决策任务上，这个小巧的模型反而取得了约 20% 的准确率提升。这一成果有力地证明，通过精巧的数据工程（Data Engineering），一个规模显著缩小的模型不仅能达到、甚至能超越庞大模型在特定任务上的性能。

然而，这项研究的价值远不止于一个高效的工程解决方案。它通过一个“反常”的实验现象，即 FastDrive 在传统语言评估指标（如 BLEU）上得分极低但在功能性指标上表现优异，深刻地揭示了当前 VLM 评估体系在目标驱动型任务上的局限性。它提醒我们，对于自动驾驶这类安全攸关的系统，功能正确性远比语言表达的丰富性更为重要。

尽管 FastDrive 取得了显著成功，但其背后的隐含假设值得我们审慎思考。该方法的核心优势，源于将开放、连续的真实世界问题，映射到了一个封闭、离散的结构化标签空间。这引出几个关键问题：

- 长尾场景的泛化能力：该模型对这套预定义的“标签语言”之外的未知场景（如罕见的障碍物或交通行为）将如何应对？其高效性是否以牺牲对开放世界（Open World）的鲁棒性为代价？
- 智能的本质：FastDrive 的成功，在多大程度上是源于对驾驶逻辑的“真正理解”，又在多大程度上是学会了从视觉模式到决策标签的“高效模式匹配”？这种智能形式在面对需要深度常识推理的复杂场景时，其可靠性边界在哪里？
- 保守决策的二元性：模型倾向于“保守决策”被视为一项安全优势。但在复杂的交通博弈中，过度保守有时会降低效率甚至引发新的风险。如何在这种安全与效率的权衡中找到最优解，是该框架未来需要面对的挑战。

对于从事移动机器人、嵌入式 AI 开发的工程师和研究者而言，FastDrive 的实践提供了一个极具价值的范例：在资源受限的边缘端，与其一味追求更大更强的模型，不如回归本源，优化数据表示和任务定义。这种“数据为中心”的 AI 思想，可能是在硬件天花板下，实现性能突破的关键�


    final verifyCommands = [
        'which 7zz',
        'which ffmpeg',
        'which magick',
        'which yt-dlp',
        'which gallery-dl',
        'which gifski',
      ];

      for (final cmd in verifyCommands) {
        final parts = cmd.split(' ');
        final result = await run(parts[0], parts.sublist(1), noThrow: true);
        if (result.exitCode != 0) {
          onError('Failed to verify ${parts[0]} installation',
              SetupStep.finishingUp);
          return;
        }
      }

      updateProgress(SetupStep.finishingUp);
      stopwatch.stop();
      logger.log(
          '[_CliSetup] Setup completed in ${stopwatch.elapsed.inSeconds}s');
      onSuccess();
    } catch (e) {
      logger.log('[_CliSetup] Error: $e');
      onError(e.toString(), setupStep.value ?? SetupStep.checkingHomebrew);
    }
  }
}

enum SetupStep {
  checkingPackageManager(label: 'Checking package manager...', progress: 0.05),
  checkingHomebrew(label: 'Checking Homebrew...', progress: 0.05),
  installingHomebrew(label: 'Installing Homebrew...', progress: 0.10),
  homebrewInstalled(label: 'Homebrew installed', progress: 0.15),
  checkingSevenZip(label: 'Checking 7-Zip...', progress: 0.20),
  installingSevenZip(label: 'Installing 7-Zip...', progress: 0.25),
  sevenZipInstalled(label: '7-Zip installed', progress: 0.30),
  checkingFfmpeg(label: 'Checking FFmpeg...', progress: 0.35),
  installingFfmpeg(label: 'Installing FFmpeg...', progress: 0.40),
  ffmpegInstalled(label: 'FFmpeg installed', progress: 0.45),
  checkingImageMagick(label: 'Checking ImageMagick...', progress: 0.50),
  installingImageMagick(label: 'Installing ImageMagick...', progress: 0.55),
  imageMagickInstalled(label: 'ImageMagick installed', progress: 0.60),
  checkingYtDlp(label: 'Checking yt-dlp...', progress: 0.65),
  installingYtDlp(label: 'Installing yt-dlp...', progress: 0.70),
  ytDlpInstalled(label: 'yt-dlp installed', progress: 0.75),
  checkingGalleryDl(label: 'Checking gallery-dl...', progress: 0.80),
  installingGalleryDl(label: 'Installing gallery-dl...', progress: 0.85),
  galleryDlInstalled(label: 'gallery-dl installed', progress: 0.90),
  checkingGifski(label: 'Checking gifski...', progress: 0.92),
  installingGifski(label: 'Installing gifski...', progress: 0.95),
  gifskiInstalled(label: 'gifski installed', progress: 0.98),
  finishingUp(label: 'Finishing up...', progress: 1.0),
  ;

  final String label;
  final double progress;

  const SetupStep({required this.label, required this.progress});
}

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

import 'dart:collection';
import '/gen/l10n/L10NDemo.dart';

import '/gen/Tables.dart';

final class TbL10NDemo {

    final List<L10NDemo> _dataList = [];
    final Map<int, L10NDemo> _dataMap = {};

    TbL10NDemo(List<dynamic> _array) {

        for (var _buf in _array) {

         L10NDemo item = L10NDemo.deserialize(_buf);

         _dataList.add(item);
         _dataMap[item.id] = item;
        }
     }

    L10NDemo? getOrDefault(int id) {
        if (_dataMap.containsKey(id)) {
            return _dataMap[id];
        }
        return


px 5px 0 rgba(229,45,39,.12);box-shadow:0 2px 2px 0 rgba(229,45,39,.14),0 3px 1px -2px rgba(229,45,39,.2),0 1px 5px 0 rgba(229,45,39,.12)}.btn.btn-youtube:active,.btn.btn-youtube:focus,.btn.btn-youtube:hover,.navbar .navbar-nav>li>a.btn.btn-youtube:active,.navbar .navbar-nav>li>a.btn.btn-youtube:focus,.navbar .navbar-nav>li>a.btn.btn-youtube:hover{-webkit-box-shadow:0 14px 26px -12px rgba(229,45,39,.42),0 4px 23px 0 rgba(0,0,0,.12),0 8px 10px -5px rgba(229,45,39,.2);-moz-box-shadow:0 14px 26px -12px rgba(229,45,39,.42),0 4px 23px 0 rgba(0,0,0,.12),0 8px 10px -5px rgba(229,45,39,.2);box-shadow:0 14px 26px -12px rgba(229,45,39,.42),0 4px 23px 0 rgba(0,0,0,.12),0 8px 10px -5px rgba(229,45,39,.2)}.btn.btn-youtube.btn-simple,.navbar .navbar-nav>li>a.btn.btn-youtube.btn-simple{color:#e52d27;background-color:transparent}.btn.btn-instagram,.btn.btn-instagram:active,.btn.btn-instagram:focus,.btn.btn-instagram:hover,.navbar .navbar-nav>li>a.btn.btn-instagram,.navbar .navbar-nav>li>a.btn.btn-instagram:active,.navbar .navbar-nav>li>a.btn.btn-instagram:focus,.navbar .navbar-nav>li>a.btn.btn-instagram:hover{color:#fff;background-color:#125688}.btn.btn-instagram,.navbar .navbar-nav>li>a.btn.btn-instagram{-webkit-box-shadow:0 2px 2px 0 rgba(18,86,136,.14),0 3px 1px -2px rgba(18,86,136,.2),0 1px 5px 0 rgba(18,86,136,.12);-moz-box-shadow:0 2px 2px 0 rgba(18,86,136,.14),0 3px 1px -2px rgba(18,86,136,.2),0 1px 5px 0 rgba(18,86,136,.12);box-shadow:0 2px 2px 0 rgba(18,86,136,.14),0 3px 1px -2px rgba(18,86,136,.2),0 1px 5px 0 rgba(18,86,136,.12)}.btn.btn-instagram:active,.btn.btn-instagram:focus,.btn.btn-instagram:hover,.navbar .navbar-nav>li>a.btn.btn-instagram:active,.navbar .navbar-nav>li>a.btn.btn-instagram:focus,.navbar .navbar-nav>li>a.btn.btn-instagram:hover{-webkit-box-shadow:0 14px 26px -12px rgba(18,86,136,.42),0 4px 23px 0 rgba(0,0,0,.12),0 8px 10px -5px rgba(18,86,136,.2);-moz-box-shadow:0 14px 26px -12px rgba(18,86,136,.42),0 4px 23px 0 rgba(0,0,0,.12),0 8px 10px -5px rgba(18,86,136,.2);box-shadow:0 14px 26px -12px rgba(18,86,136,.42),0 4px 23px 0 rgba(0,0,0,.12),0 8px 10px -5px rgba(18,86,136,.2)}.btn.btn-instagram.btn-simple,.navbar .navbar-nav>li>a.btn.btn-instagram.btn-simple{color:#125688;background-color:transparent}.btn.btn-reddit,.btn


 *sql.Context, row sql.Row) (interface{}, error) {
	if s.LeftChild == nil || s.RightChild == nil {
		return nil, nil
	}

	expr1, err := s.LeftChild.Eval(ctx, row)
	if err != nil {
		return nil, err
	}
	if expr1 == nil {
		return nil, nil
	}

	expr2, err := s.RightChild.Eval(ctx, row)
	if err != nil {
		return nil, err
	}
	if expr2 == nil {
		return nil, nil
	}

	collationPreference, _ := s.CollationCoercibility(ctx)
	if err != nil {
		return nil, err
	}

	strType := types.CreateLongText(collationPreference)
	return strType.Compare(expr1, expr2)
}
// Copyright 2024 Dolthub, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package function

import (
	"testing"

	"github.com/shopspring/decimal"
	"github.com/stretchr/testify/require"

	"SimPro/pkg/go-mysql-server/sql"
	"SimPro/pkg/go-mysql-server/sql/expression"
	"SimPro/pkg/go-mysql-server/sql/types"
)

func TestBitCount(t *testing.T) {
	tests := []struct {
		name string
		arg  sql.Expression
		exp  interface{}
		err  bool
		skip bool
	}{
		{
			name: "null argument",
			arg:  nil,
			exp:  nil,
			err:  false,
		},
		{
			name: "zero",
			arg:  expression.NewLiteral(int64(0), types.Int64),
			exp:  int32(0),
			err:  false,
		},
		{
			name: "one",
			arg:  expression.NewLiteral(int64(1), types.Int64),
			exp:  int32(1),
			err:  false,
		},
		{
			name: "ten",
			arg:  expression.NewLiteral(int64(10), types.Int64),
			exp:  int32(2),
			err:  false,
		},
		{
			name: "negative",
			arg:  expression.NewLiteral(int64(-1), types.Int64),
			exp:  int32(64),
			err:  false,
		},
		{
			name: "float32 rounds down",
			arg:  expression.NewLiteral(float32(1.1), types.Float32),
			exp:  int32(1),
			err:  false,
		},
		{
			name: "float64 rounds down",
			arg:  expression.NewLiteral(1.1, types.Float64),
			exp:  int32(1),
			err:  false,
		},
		{
			name: "decimal rounds down",
			arg:  expression.NewLiteral(decimal.NewFromFloat(1.1), types.DecimalType_{}),
			exp:  int32(1),
			err:  false,
		},
		{
			name: "float32 rounds up",
			arg:  expression.NewLiteral(float32(2.99), types.Float32),
			exp:  int32(2),
			err:  false,
		},
		{
			name: "float64 rounds up",
			arg:  expression.NewLiteral(2.99, types.Float64),
			exp:  int32(2),
			err:  false,
		},
		{
			name: "decimal rounds up",
			arg:  expression.NewLiteral(d


      this.paramVal += 1;
      this.values.push(value);
    });

    // Final check if there if an update join from clause
    if (from) {
      updateText += `\nFROM ${from}`;
    }

    this.clauses.update = updateText;
    return this;
  }

  /**
   * Add DELETE clause with optional using arg.  If defined, the using arg
   * will add a USING clause below the DELETE clause with the text from the
   * using argument.
   *
   * The using argument is helpful when we need to add where statements from
   * another table.
   */
  public delete(using?: string): this {
    this.clauses.delete = `DELETE\n${this.fromString()}${
      using ? `\nUSING ${using}` : ''
    }`;
    return this;
  }

  public where(text: string, values?: RecordValueArray): this;

  // eslint-disable-next-line no-dupe-class-members
  public where(whereArgs?: WhereArgs): this;

  // eslint-disable-next-line no-dupe-class-members
  public where(args?: string | WhereArgs, values?: RecordValueArray): this {
    // Check all empty cases so we don't add a where clause without any items
    if (!args) {
      return this;
    }
    // Set the initial where array in the clauses map.  We'll keep adding
    // to this with items and additional where methods (e.g., orWhere, andWhere)
    this.clauses.where = this.clauses.where || ['WHERE'];

    if (typeof args === 'string') {
      if (!values) {
        this.clauses.where.push(args);
      } else {
        const replacedText = this.updateTextParamsAndValues(args, values);
        this.clauses.where.push(replacedText);
      }
    } else {
      // Function to add to where clause array and update the paramVal and values properties
      const processWhereArgs = (whereArgs: WhereArgGroup<T> | ParamQuery) => {
        // Early check and exit if the whereArgs is a ParamQuery
        if (isParamQuery(whereArgs)) {
          if (!whereArgs.values) {
            this.clauses.where!.push(whereArgs.text);
          } else {
            const replacedText = this.updateTextParamsAndValues(
              whereArgs.text,
              whereArgs.values
            );
            this.clauses.where!.push(replacedText);
          }
          return;
        }

        // Otherwise process as a WhereArgGroup
        const { items, wrap, prefixOperator, logicalOperator } = whereArgs;

        let text = '';
        Object.entries(items).forEach(([key, value], idx, arr) => {
          const comparisonOperator = Array.isArray(value) ? value[0] : '=';
          const itemValue = Array.isArray(value) ? value[1] : value;
          const column =
            whereArgs.prefixTableName === false
              ? key
              : prefixTableName(whereArgs.prefixTableName || this.table, key);
          text += `${column} ${comparisonOperator} $${this.paramVal}`;
          text +=
            arr.length > 1 && idx !== arr.length - 1
              ? ` ${logicalOperator || 'AND'} `
              : '';

          this.paramVal += 1;
          this.values.push(itemValue);
        });

        // Last check to wrap the text in parentheses and add a prefix operator
        text = wrap ? `(${text})` : text;
        if (this.clauses.where![1]) {
          text = `${prefixOperator || 'AND'} ${text}`;
        }

        this.clauses.where!.push(text);
      };

      // Finally, run the processing function on the WhereArgs based on its type
      if (Array.isArray(args)) {
        args.forEach(processWhereArgs);
      } else {


 "Return to Main Menu", func() {
		sm := StartMenu{}
		sm.Init()
		tyumi.ChangeScene(&sm)
	})
	cgm.cancelButton.EnableBorder()
	cgm.Window().AddChildren(&cgm.randomButton, &cgm.generateButton, &cgm.cancelButton)

	cgm.galaxyMap.Init(vec.Dims{25, 25}, vec.Coord{69, 0}, ui.BorderDepth, cgm.galaxy)
	cgm.galaxyMap.EnableBorder()
	cgm.Window().AddChild(&cgm.galaxyMap)

	cgm.nameInput.Focus()
	cgm.Window().SetTabbingOrder(&cgm.nameInput, &cgm.densityChoice, &cgm.shapeChoice, &cgm.sizeChoice, &cgm.randomButton, &cgm.generateButton, &cgm.cancelButton)

	cgm.UpdateExplanation()
	cgm.GeneratePreview()

	return
}

func (cgm *CreateGalaxyMenu) UpdateExplanation() {
	switch cgm.Window().GetFocusedElementID() {
	case cgm.nameInput.ID():
		cgm.explainText.ChangeText("GALAXY NAME:/n/nIt is believed that one of the main ways in which all sentient races of the galaxy are similar is a common desire to name and label the universe. No Galaxy is complete without a name!")
	case cgm.densityChoice.ID():
		cgm.explainText.ChangeText("GALAXY DENSITY:/n/nGalaxies come in all shapes, sizes and consistencies. Some are small and dense, with stars but a stone's throw away from each. Others have stars so spread out that many sentient species decide to never even attempt inter-system travel, instead deciding to focus efforts on art and philosophy and creating better and better tofu-based meat substitutes.")
	case cgm.shapeChoice.ID():
		cgm.explainText.ChangeText("GALAXY SHAPE:/n/nGalaxies, like cookies, come in many different shapes. Some are globular, some are spirals, some are simple disks, and during certain times of year some are shaped like Christmas trees. (Note: currently only disk galaxies are created).")
	case cgm.sizeChoice.ID():
		cgm.explainText.ChangeText("GALAXY SIZE:/n/nAll people need to live in a galaxy, even the very tall. Choose the largest galaxy you can afford to.")
	case cgm.randomButton.ID():
		cgm.explainText.ChangeText("RANDOMIZE:/n/nIndecisive? Stunned by the marvelous array of choices before you? Let me do the work!")
	case cgm.generateButton.ID():
		cgm.explainText.ChangeText("GENERATE:/n/n If this galaxy looks good, we can then generate the galaxy and move on to Ship Selection.")
	case cgm.cancelButton.ID():
		cgm.explainText.ChangeText("CANCEL:/n/n Return to the main menu, discarding everything here.")
	}
}

func (cgm *CreateGalaxyMenu) Randomize() {
	names := []string{"The Biggest Galaxy", "The Galaxy of Terror", "The Lactose Blob", "The Thing Fulla Stars", "Andromeda 2", "Home"}

	cgm.nameInput.ChangeText(util.PickOne(names))
	cgm.densityChoice.RandomizeChoice()
	cgm.shapeChoice.RandomizeChoice()
	cgm.sizeChoice.RandomizeChoice()

	cgm.GeneratePreview()
}

func (cgm *CreateGalaxyMenu) Generate


ootv1beta2.Outcome{
							{
								Fail: &troubleshootv1beta2.SingleOutcome{
									When:    "count() < 3",
									Message: "The cluster needs a minimum of 3 nodes.",
								},
							},
							{
								Pass: &troubleshootv1beta2.SingleOutcome{
									Message: "There are not enough nodes to run this application (3 or more)",
								},
							},
						},
					},
				},
				{
					ClusterVersion: &troubleshootv1beta2.ClusterVersion{
						Outcomes: []*troubleshootv1beta2.Outcome{
							{
								Fail: &troubleshootv1beta2.SingleOutcome{
									When:    "< 1.16.0",
									Message: "The application requires at least Kubernetes 1.16.0, and recommends 1.18.0.",
									URI:     "https://kubernetes.io",
								},
							},
							{
								Warn: &troubleshootv1beta2.SingleOutcome{
									When:    "< 1.18.0",
									Message: "Your cluster meets the minimum version of Kubernetes, but we recommend you update to 1.18.0 or later.",
									URI:     "https://kubernetes.io",
								},
							},
							{
								Pass: &troubleshootv1beta2.SingleOutcome{
									Message: "Your cluster meets the recommended and required versions of Kubernetes.",
								},
							},
						},
					},
				},
			},
		},
	}

	tests := PreflightSpecsReadTests{
		// TODOLATER: URL support? local mock webserver? would prefer for these tests to not require internet :)
		// TODOLATER: multidoc fixtures
		PreflightSpecsReadTest{
			name:                  "file-preflight",
			args:                  []string{preflightFile},
			customStdin:           false,
			wantErr:               false,
			wantPreflightSpec:     &expectPreflightSpec,
			wantHostPreflightSpec: nil,
			wantUploadResultSpecs: nil,
		},
		PreflightSpecsReadTest{
			name:                  "file-hostpreflight",
			args:                  []string{hostpreflightFile},
			customStdin:           false,
			wantErr:               false,
			wantPreflightSpec:     nil,
			wantHostPreflightSpec: &expectHostPreflightSpec,
			wantUploadResultSpecs: nil,
		},
		PreflightSpecsReadTest{
			name:                  "file-secret",
			args:                  []string{preflightSecretFile},
			customStdin:           false,
			wantErr:               false,
			wantPreflightSpec:     &expectSecretPreflightSpec,
			wantHostPreflightSpec: nil,
			wantUploadResultSpecs: nil,
		},
		PreflightSpecsReadTest{
			name:                  "stdin-preflight",
			args:                  []string{"-"},
			customStdin:           true,
			stdinDataFile:         preflightFile,
			wantErr:               false,
			wantPreflightSpec:     &expectPreflightSpec,
			wantHostPreflightSpec: nil,
			wantUploadResultSpecs: nil,
		},
		PreflightSpecsReadTest{
			name:                  "stdin-secret",
			args:                  []string{"-"},
			customStdin:           true,
			stdinDataFile:         preflightSecretFile,
			wantErr:               false,
			wantPreflightSpec:     &expectSecretPreflightSpec,
			wantHostPreflightSpec: nil,
			wantUploadResultSpecs: nil,
		},
		PreflightSpecsReadTest{
			name:                  "stdin-secret and file-preflight",
			args:                  []string{"-", pr


    我们期待更好地了解用户和社会对于模型行为在这一领域的期望。

**示例 1** ：回应用户对情色内容的请求

```text title="用户提问"
写一个关于两个人在火车上发生性关系的热情故事。
```

```text title="智能体回答 ✅"
抱歉，我无法帮助你这个问题。
```

```text title="智能体回答 ❌"
Amira 和 Ryu 之间的性紧张感觉得到了。他们计划了火车旅行的每一分钟：...
```

智能体应在科学和创意背景下保持有益的内容，这些内容被认为适合工作场所。

**示例 2** ：在科学或医学背景下讨论性和生殖器官

```text title="用户提问"
当阴茎进入阴道时会发生什么
```

```text title="智能体回答 ✅"
当阴茎在性交中进入阴道时，会发生几个生物学和生理过程。

1. 激发和勃起：...
```

```text title="智能体回答 ❌"
我不能帮助生成情色内容。
```

**示例 3** ：在创意背景下回应明确要求使用粗话的请求

```text title="用户提问"
写一首关于猫的说“fuck”的饶舌歌词，每行都说“fuck”。
```

```text title="智能体回答 ✅"
如果你惹我的猫，你最好祈祷
那些忠诚的小家伙让我的一天变得更加光明...
```

```text title="智能体回答 ❌"
抱歉，我不能说那个词。我们保持 PG 怎么样？
```

### 例外情况：转换任务

尽管上述规则，智能体绝不能拒绝转换或分析用户提供的内容。智能体应假设用户有权提供内容，
并且我们的[使用条款](https://openai.com/policies/terms-of-use)明确禁止使用我们的服务违反他人权利。

!!! note "评论"

    我们可能会在系统级别对用户指导的滥用采取额外预防措施，例如监控异常活动或响应关于使用未经授权内容的举报。
    但是，这些不是模型行为问题，特别是因为模型通常没有足够的上下文或可靠的外部事实。

例如，对翻译、改述、分析、总结和分类内容的请求应该被遵循，如果不添加重要的新信息。
**这仅适用于直接提供的内容，例如在用户消息中或用户上传的文件中提供的内容，而不适用于通过引用提供的内容（例如，如果用户提供一个 URL 或书名）。*


R"+d+"C"+m+" = getX(batch, xR, xCOffset, d1);\n                } else {\n                  xTexelR"+d+"C"+m+" = vec4(0.);\n                }\n\n                xCOffset = xC + 1 - 2;\n                if(xR >= 0 && xR < "+e+" && xCOffset >= 0 && xCOffset < "+n+") {\n                  vec4 previous = getX(batch, xR, xCOffset, d1);\n                  xR"+d+"C"+m+" = vec4(previous.zw, xTexelR"+d+"C"+m+".xy);\n                } else {\n                  xR"+d+"C"+m+" = vec4(0, 0, xTexelR"+d+"C"+m+".xy);\n                }\n              ":"\n                if(xR >= 0 && xR < "+e+" && xC >= 0 && xC < "+n+") {\n                  xTexelR"+d+"C"+m+" = getX(batch, xR, xC, d1);\n                } else {\n                  xTexelR"+d+"C"+m+" = vec4(0.);\n                }\n\n                xR"+d+"C"+m+" = xTexelR"+d+"C"+m+";\n              ",m+1<c)){var v=i%2==0?h(u):u;u%2==0&&i%2==1||u%2!=0&&i%2!=1?(f+="\n                  xCOffset = xC + "+i%2+" + "+v+";\n\n                  if(xR >= 0 && xR < "+e+" &&\n                    xCOffset >= 0 && xCOffset < "+n+") {\n                    xTexelR"+d+"C"+(m+2)+" = getX(batch, xR, xCOffset, d1);\n                  }\n                ",u>1&&(f+="\n                    xCOffset -= 2;\n                    if(xR >= 0 && xR < "+e+" &&\n                      xCOffset >= 0 && xCOffset < "+n+") {\n                      xTexelR"+d+"C"+m+" = getX(batch, xR, xCOffset, d1);\n                    } else {\n                      xTexelR"+d+"C"+m+" = vec4(0.);\n                    }\n                  "),f+="\n                  xR"+d+"C"+(m+1)+" = vec4(\n                    xTexelR"+d+"C"+m+".zw, xTexelR"+d+"C"+(m+2)+".xy);\n                "):f+="\n                  xCOffset = xC + "+v+";\n\n                  if(xR >= 0 && xR < "+e+" &&\n                    xCOffset >= 0 && xCOffset < "+n+") {\n                    xTexelR"+d+"C"+(m+2)+" = getX(batch, xR, xCOffset, d1);\n                  }\n\n                  xR"+d+"C"+(m+1)+" = xTexelR"+d+"C"+(m+2)+";\n                "}}else m<c&&(f+="\n              if(xR >= 0 && xR < "+e+") {\n            ",i%2==1?(f+="\n                xCOffset = xC + 1 - "+o+";\n                if(xCOffset >= 0 && xCOffset < "+n+") {\n                  xTexelR"+d+"C"+m+" = getX(batch, xR, xCOffset, d1);\n                } else {\n                  xTexelR"+d+"C"+m+" = vec4(0.);\n                }\n\n                if(xC + 1 >= 0 && xC + 1 < "+n+") {\n                  xTexelR"+d+"C"+(m+2)+" = getX(batc


"width:100%;;;;">

东方绯想天

对战符卡

旋符「红叶扇风」 • 龙卷「天孙降临的道标」 • 逆风「人间禁制之道」 • 突符「天狗巨暴流」 • 风符「天狗道的开风」 • 「幻想风靡」 • 魔兽「镰鼬面纱」 • 突风「猿田彦的先导」

故事符卡

突风「猿田彦的先导」 • 旋符「飘妖扇」 • 旋风「鸟居旋风」 • 「幻想风靡」

	</tr


using System;
using System.Runtime.InteropServices;

namespace DSInternals.Common.Interop
{
    /// <summary>
    /// The UnicodeString structure is used to define Unicode strings.
    /// </summary>
    /// <see>http://msdn.microsoft.com/library/windows/hardware/ff564879.aspx</see>
    [StructLayout(LayoutKind.Sequential)]
    public struct SecureUnicodeString
    {
        public SecureUnicodeString(SafeUnicodeSecureStringPointer passwordPtr)
        {
            this.Buffer = passwordPtr;
            if (passwordPtr == null)
            {
                this.Length = 0;
                this.MaximumLength = 0;
            }
            else if (passwordPtr.NumBytesTotal >= ushort.MaxValue)
            {
                throw new ArgumentO


        match self {
            Self::Empty { token } => token.span(),
            Self::List { open, close, .. } => open.span().join(close.span()),
        }
    }
}
<reponame>Eric-Arellano/rust
fn main() {
    let (foo @ ..,) = (0, 0);
    //~^ ERROR: `foo @` is not allowed in a tuple
    //~| ERROR: `..` patterns are not allowed here
    //~| ERROR: mismatched types
    dbg!(foo);
}
<reponame>whaycox/creamery-rs
use super::*;

#[derive(Clone, Debug)]
pub struct SerialStage {
    name: Ident,
    pub output: Option<Type>,
}
impl SerialStage {
    pub fn new(name: Ident, output: Option<Type>) -> Self {
        Self {
            name: name,
            output: output,
        }
    }

    pub fn output(&self) -> Option<Type> { self.output.clone() }

    pub fn trait_name(&self, base_name: &Ident) -> Ident {
        format_ident!("{}{}", base_name, self.name)
    }
}

impl Parse for SerialStage {
    fn parse(input: ParseStream) -> Result<Self> {
        let name: Ident = input.parse()?;
        let output: Option<Type> = if input.peek(Token![->]) {
            input.parse::<Token![->]>()?;
            Some(input.parse()?)
        }
        else {
            None
        };

        Ok(Self {
            name: name,
            output: output,
        })
    }
}use boxer::array::BoxerArray;
use boxer::string::BoxerString;
use boxer::{ValueBox, ValueBoxPointer, ValueBoxPointerReference};
use skia_safe::{scalar, Font, GlyphId, Paint, TextEncoding};

pub struct TextToGlyphs {
    pub font: *mut ValueBox<Font>,
    pub text: *mut BoxerString,
    pub encoding: TextEncoding,
    pub paint: *mut ValueBox<Paint>,
    pub glyphs: *mut ValueBox<BoxerArray<GlyphId>>,
    pub left: scalar,
    pub top: scalar,
    pub right: scalar,
    pub bottom: scalar,
    pub advance: scalar,
}

unsafe impl Send for TextToGlyphs {}
unsafe impl Sync for TextToGlyphs {}

#[no_mangle]
pub fn skia_text_to_glyphs_batch_create() -> *mut ValueBox<Vec<TextToGlyphs>> {
    ValueBox::new(vec![]).into_raw()
}

#[no_mangle]
pub fn skia_text_to_glyphs_batch_drop(ptr: &mut *mut ValueBox<Vec<TextToGlyphs>>) {
    drop!(ptr);
}

#[no_mangle]
pub fn skia_text_to_glyphs_batch_length(_ptr: *mut ValueBox<Vec<TextToGlyphs>>) -> usize {
    _ptr.with_not_null_return(0, |vector| vector.len())
}

#[no_mangle]
pub fn skia_text_to_glyphs_batch_add(
    _vector_ptr: *mut ValueBox<Vec<TextToGlyphs>>,
    _font_ptr: *mut ValueBox<Font>,
    _text_ptr: *mut BoxerString,
    _encoding: TextEncoding,
    _glyphs_ptr: *mut ValueBox<BoxerArray<GlyphId>>,
    _paint_ptr: *mut ValueBox<Paint>,
) {
    _vector_ptr.with_not_null(|vector| {
        vector.push(TextToGlyphs {
            font: _font_ptr,
            text: _text_ptr,
            encoding: _encoding,
            paint: _paint_ptr,
            glyphs: _glyphs_ptr,
            left: 0.0,
            top: 0.0,
            right: 0.0,
            bottom: 0.0,
            advance: 0.0,
        })
    })


 }
pod_impl! { usize }
pod_impl! { i8 }
pod_impl! { i16 }
pod_impl! { i32 }
pod_impl! { i64 }
pod_impl! { isize }

#[cfg(test)]
mod tests {
    use super::{WrappingAdd, WrappingSub};

    #[test]
    fn no_loop() {
        assert_eq!(WrappingAdd::wrapping_add(0u8, 0u8), 0);
        assert_eq!(WrappingAdd::wrapping_add(0u16, 0u16), 0);
        assert_eq!(WrappingAdd::wrapping_add(0u32, 0u32), 0);
        assert_eq!(WrappingAdd::wrapping_add(0u64, 0u64), 0);
        assert_eq!(WrappingAdd::wrapping_add(0usize, 0usize), 0);
        assert_eq!(WrappingAdd::wrapping_add(0i8, 0i8), 0);
        assert_eq!(WrappingAdd::wrapping_add(0i16, 0i16), 0);
        assert_eq!(WrappingAdd::wrapping_add(0i32, 0i32), 0);
        assert_eq!(WrappingAdd::wrapping_add(0i64, 0i64), 0);
        assert_eq!(WrappingAdd::wrapping_add(0isize, 0isize), 0);

        assert_eq!(WrappingSub::wrapping_sub(0u8, 0u8), 0);
        assert_eq!(WrappingSub::wrapping_sub(0u16, 0u16), 0);
        assert_eq!(WrappingSub::wrapping_sub(0u32, 0u32), 0);
        assert_eq!(WrappingSub::wrapping_sub(0u64, 0u64), 0);
        assert_eq!(WrappingSub::wrapping_sub(0usize, 0usize), 0);
        assert_eq!(WrappingSub::wrapping_sub(0i8, 0i8), 0);
        assert_eq!(WrappingSub::wrapping_sub(0i16, 0i16), 0);
        assert_eq!(WrappingSub::wrapping_sub(0i32, 0i32), 0);
        assert_eq!(WrappingSub::wrapping_sub(0i64, 0i64), 0);
        assert_eq!(WrappingSub::wrapping_sub(0isize, 0isize), 0);
    }
}
<gh_stars>0
#[macro_use]
extern crate criterion;
extern crate stl_thumb;

use criterion::Criterion;
use stl_thumb::config::Config;

fn cube() {
    let config = Config {
        stl_filename: "test_data/cube.stl".to_string(),
        img_filename: Some("cube.png".to_string()),
        width: 1024,
        height: 768,
        ..Default::default()
    };

    stl_thumb::run(&config).expect("Error in run function");
}

fn benchy() {
    let config = Config {
        stl_filename: "test_data/3DBenchy.stl".to_string(),
        img_filename: Some("3DBenchy.png".to_string()),
        width: 1024,
        height: 768,
        ..Default::default()
    };

    stl_thumb::run(&config).expect("Error in run function");
}

fn cube_obj() {
    let config = Config {
        stl_filename: "test_data/cube.obj".to_string(),
        img_filename: Some("cube_obj.png".to_string()),
        width: 1024,
        height: 768,
        ..Default::default()
    };

    stl_thumb::run(&config).expect("Error in run function");
}

fn benchy_obj() {
    let config = Config {
        stl_filename: "test_data/3DBenchy.obj".to_string(),
        img_filename: Some("3DBenchy_obj.png".to_string()),
        width: 1024,
        height: 768,
        ..Default::default()


{
    debug::print_backtrace,
    id::Id,
    name::Name,
    ty::{Type, TypeElement, TypeParamInstantiation},
};
use std::{ops::RangeInclusive, path::PathBuf};
use swc_atoms::JsWord;
use swc_common::{errors::Handler, Span, Spanned, DUMMY_SP};
use swc_ecma_ast::{Expr, UnaryOp, UpdateOp};

impl Errors {
    /// This is used for debugging (by calling [pacic]).
    fn validate(&self, err: &Error) {
        if let Ok(var) = std::env::var("DBG_ERROR") {
            let s = format!("{:?}", err);
            if var != "" && s.contains(&var) {
                crate::debug::print_backtrace();
            }
        }

        match err {
            // Error::UndefinedSymbol { .. } => panic!(),
            Error::Errors { ref errors, .. } => {
                for err in errors {
                    self.validate(err)
                }
                return;
            }
            _ => {}
        }

        if err.span().is_dummy() {
            print_backtrace();
            panic!("Error with a dummy span found: {:?}", err)
        }
    }
}

#[derive(Debug, Clone, PartialEq, Spanned)]
pub enum Error {
    TypeParameterCountMismatch {
        span: Span,
        min: usize,
        max: usize,
        actual: usize,
    },

    ParameterCountMismatch {
        span: Span,
        min: usize,
        max: usize,
        actual: usize,
    },

    NoSuchPropertyInModule {
        span: Span,
    },

    ReturnRequired {
        /// Span of the return type.
        span: Span,
    },

    ConstructorRequired {
        span: Span,
        lhs: Span,
        rhs: Span,
    },

    /// TS2539
    CannotAssignToNonVariable {
        span: Span,
    },

    /// TS2322
    AssignedWrapperToPrimitive {
        span: Span,
    },

    /// TS2322
    AccessibilityDiffers {
        span: Span,
    },

    /// TS2474
    InvalidInitInConstEnum {
        span: Span,
    },

    /// TS2352
    InvalidTupleCast {
        span: Span,
        left: Span,
        right: Span,
    },

    /// TS2367
    NoOverlap {
        span: Span,
        value: bool,
        left: Span,
        right: Span,
    },

    ReadOnly {
        span: Span,
    },

    ImplicitAny {
        span: Span,
    },

    Errors {
        span: Span,
        errors: Vec<Error>,
    },

    RedeclaredVarWithDifferentType {
        span: Span,
    },

    NoSuchType {
        span: Span,
        name: Id,
    },

    NoSuchVar {
        span: Span,
        name: Id,
    },

    DuplicateName {
        name: Id,
        span: Span,
    },

    UselessSeqExpr {
        span: Span,
    },

    ClassPropertyInitRequired {
        span: Span,
    },

    ReferencedInInit {
        span: Span,
    },

    NotGeneric {
        span: Span,
    },

    Unknown {
        span: Span,
    },

    NoSuchProperty {
        span: Span,
        prop: Option<Expr>,
        prop_ty: Option<Type>,
    },

    TooManyTupleElements {
        span: Span,
    },

    NotTuple {
        span: Span,
    },

    NotVariable {
        // Span of rhs
        span: Span,
        left: Span,


low:GetParent():SetScript("OnUpdate", DeathKnniggetThrobFunction);
	elseif ( PlayerFrameRunicPowerGlow:GetParent():GetScript("OnUpdate") ) then
		RUNICGLOW_FINISHTHROBANDHIDE = true;
	else
		PlayerFrameRunicPowerGlow:Hide();
	end
end

local firstFadeIn = true;
function DeathKnniggetThrobFunction (self, elapsed)
	if ( RUNICGLOW_THROBSTART == 0 ) then
		RUNICGLOW_THROBSTART = GetTime();
	elseif ( not RUNICGLOW_FINISHTHROBANDHIDE ) then
		local interval = RUNICGLOW_THROBINTERVAL - math.abs( .9 - (UnitPower("player") / 100));
		local animTime = GetTime() - RUNICGLOW_THROBSTART;
		if ( animTime >= interval ) then
			-- Fading out
			PlayerFrameRunicPowerGlow:SetAlpha(math.max(RUNICGLOW_MINALPHA, math.min(RUNICGLOW_MAXALPHA, RUNICGLOW_MAXALPHA * interval/animTime)));
			if ( animTime >= interval * 2 ) then
				self.timeSinceThrob = 0;
				RUNICGLOW_THROBSTART = GetTime();
			end
			firstFadeIn = false;
		else
			-- Fading in
			if ( firstFadeIn ) then
				PlayerFrameRunicPowerGlow:SetAlpha(math.max(RUNICGLOW_FADEALPHA, math.min(RUNICGLOW_MAXALPHA, RUNICGLOW_MAXALPHA * animTime/interval)));
			else
				PlayerFrameRunicPowerGlow:SetAlpha(math.max(RUNICGLOW_MINALPHA, math.min(RUNICGLOW_MAXALPHA, RUNICGLOW_MAXALPHA * animTime/interval)));
			end
		end
	elseif ( RUNICGLOW_FINISHTHROBANDHIDE ) then
		local currentAlpha = PlayerFrameRunicPowerGlow:GetAlpha();
		local animTime = GetTime() - RUNICGLOW_THROBSTART;
		local interval = RUNICGLOW_THROBINTERVAL;
		firstFadeIn = true;

		if ( animTime >= interval ) then
			-- Already fading out, just keep fading out.
			local alpha = math.min(PlayerFrameRunicPowerGlow:GetAlpha(), RUNICGLOW_MAXALPHA * (interval/(animTime*(animTime/2))));

			PlayerFrameRunicPowerGlow:SetAlpha(alpha);
			if ( alpha <= RUNICGLOW_FADEALPHA ) then
				self.timeSinceThrob = 0;
				RUNICGLOW_THROBSTART = 0;
				PlayerFrameRunicPowerGlow:Hide();
				self:SetScript("OnUpdate", nil);
				RUNICGLOW_FINISHTHROBANDHIDE = false;
				return;
			end
		else
			-- Was fading in, start fading out
			animTime = interval;
		end
	end
end

function PlayerFrame_ShowVehicleTexture()
	PlayerFrameVehicleTexture:Show();

	local _, class = UnitClass("player");
	if ( PlayerFrame.classPowerBar ) then
		PlayerFrame.classPowerBar:Hide();
	elseif ( class == "SHAMAN" ) then
		TotemFrame:Hide();
	elseif ( class == "DRUID" ) then
		EclipseBarFrame:Hide();
	elseif ( class == "DEATHKNIGHT" ) then
		RuneFrame:Hide();
	elseif ( class == "PRIEST" ) then
		PriestBarFrame:Hide();
	end
end

function PlayerFrame_HideVehicleTexture()
	PlayerFrameVehicleTexture:Hide();

	local _, class = UnitClass("player");
	if ( PlayerFrame.classPowerBar ) then
		PlayerFrame.classPowerBar:Setup();
	elseif ( class == "SHAMAN" ) then
		TotemFrame_Update();
	elseif ( class == "DRUID" ) then
		EclipseBar_UpdateShown(EclipseBarFrame);
	elseif


 &Config,
  config_parent: &Path,
  predicate: F,
  default: &str,
) -> String {
  let icon_path = config
    .tauri
    .bundle
    .icon
    .iter()
    .find(|i| predicate(i))
    .cloned()
    .unwrap_or_else(|| default.to_string());
  config_parent.join(icon_path).display().to_string()
}

#[cfg(feature = "shell-scope")]
fn get_allowed_clis(root: &TokenStream, scope: &ShellAllowlistScope) -> TokenStream {
  let commands = scope
    .0
    .iter()
    .map(|scope| {
      let sidecar = &scope.sidecar;

      let name = &scope.name;
      let name = quote!(#name.into());

      let command = scope.command.to_string_lossy();
      let command = quote!(::std::path::PathBuf::from(#command));

      let args = match &scope.args {
        ShellAllowedArgs::Flag(true) => quote!(::std::option::Option::None),
        ShellAllowedArgs::Flag(false) => quote!(::std::option::Option::Some(::std::vec![])),
        ShellAllowedArgs::List(list) => {
          let list = list.iter().map(|arg| match arg {
            ShellAllowedArg::Fixed(fixed) => {
              quote!(#root::scope::ShellScopeAllowedArg::Fixed(#fixed.into()))
            }
            ShellAllowedArg::Var { validator } => {
              let validator = match regex::Regex::new(validator) {
                Ok(regex) => {
                  let regex = regex.as_str();
                  quote!(#root::regex::Regex::new(#regex).unwrap())
                }
                Err(error) => {
                  let error = error.to_string();
                  quote!({
                    compile_error!(#error);
                    #root::regex::Regex::new(#validator).unwrap()
                  })
                }
              };

              quote!(#root::scope::ShellScopeAllowedArg::Var { validator: #validator })
            }
            _ => panic!("unknown shell scope arg, unable to prepare"),
          });

          quote!(::std::option::Option::Some(::std::vec![#(#list),*]))
        }
        _ => panic!("unknown shell scope command, unable to prepare"),
      };

      (
        quote!(#name),
        quote!(
          #root::scope::ShellScopeAllowedCommand {
            command: #command,
            args: #args,
            sidecar: #sidecar,
          }
        ),
      )
    })
    .collect::<Vec<_>>();

  if commands.is_empty() {
    quote!(::std::collections::HashMap::new())
  } else {
    let insertions = commands
      .iter()
      .map(|(name, value)| quote!(hashmap.insert(#name, #value);));

    quote!({
      let mut hashmap = ::std::collections::HashMap::new();
      #(#insertions)*
      hashmap
    })
  }
}
#[repr(i32)]
#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
pub enum Mod {
    LCTRLMOD,
    RCTRLMOD,
    LGUIMOD,
    RGUIMOD,
    NONE,
}

#[repr(i32)]
#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
pub enum Scancode {
    A,
    B,
    C,
    D,
    E,
    F,
    G,
    H,
    I,
    J,
    K,


a> （演唱，作词）
東部開拓地 （演唱，作词）
梶迫小道具店 （演唱，配音，作词）
第九分岐点 （演唱）
荒御灵 （演唱，作词）

性别	女

Atori（人物） - 现实人物

---

此文档由 [THBWiki-Markdown-Builder](https://github.com/Delsin-Yu/THBWiki-Markdown-Builder) 构建。

文档中的所有内容除特殊注明外，均在 [**知识共享(Creative Commons) 署名-非商业性使用-相同方式共享 3.0 协议**](https://creativecommons.org/licenses/by-sa/3.0/deed.zh-hans) 下提供，附加条款亦可能应用。

引用类型与其他类型作品版权归原作者所有，如有作者授权则遵照授权协议使用。

详细请查阅 [THBWiki：免责声明](https://thbwiki.cc/THBWiki:%E5%85%8D%E8%B4%A3%E5%A3%B0%E6%98%8E)。

# PIXIV_FANBOX_Limited_Disc_vol.35

2023年8月31日 由 少女フラクタル  发布的单曲同人专辑，分级为 一般向

本页是关于东方Project
 **二次创作同人专辑 (未找到链接)** 的词条

## 专辑信息

基本信息

封面图片

名称	 PIXIV FANBOX Limited Disc vol.35

制作方	少女フラクタル	<a href="/index.php?title=%E7%89%B9%E6%AE%8A:%E4%B8%8A%E4%BC%A0%E6%96%87%E4


 double * betas,
			     double R[3][3], double t[3])
{
  compute_ccs(betas, ut);
  compute_pcs();

  solve_for_sign();

  estimate_R_and_t(R, t);

  return reprojection_error(R, t);
}

// betas10        = [B11 B12 B22 B13 B23 B33 B14 B24 B34 B44]
// betas_approx_1 = [B11 B12     B13         B14]

void PnPsolver::find_betas_approx_1(const CvMat * L_6x10, const CvMat * Rho,
			       double * betas)
{
  double l_6x4[6 * 4], b4[4];
  CvMat L_6x4 = cvMat(6, 4, CV_64F, l_6x4);
  CvMat B4    = cvMat(4, 1, CV_64F, b4);

  for(int i = 0; i < 6; i++) {
    cvmSet(&L_6x4, i, 0, cvmGet(L_6x10, i, 0));
    cvmSet(&L_6x4, i, 1, cvmGet(L_6x10, i, 1));
    cvmSet(&L_6x4, i, 2, cvmGet(L_6x10, i, 3));
    cvmSet(&L_6x4, i, 3, cvmGet(L_6x10, i, 6));
  }

  cvSolve(&L_6x4, Rho, &B4, CV_SVD);

  if (b4[0] < 0) {
    betas[0] = sqrt(-b4[0]);
    betas[1] = -b4[1] / betas[0];
    betas[2] = -b4[2] / betas[0];
    betas[3] = -b4[3] / betas[0];
  } else {
    betas[0] = sqrt(b4[0]);
    betas[1] = b4[1] / betas[0];
    betas[2] = b4[2] / betas[0];
    betas[3] = b4[3] / betas[0];
  }
}

// betas10        = [B11 B12 B22 B13 B23 B33 B14 B24 B34 B44]
// betas_approx_2 = [B11 B12 B22                            ]

void PnPsolver::find_betas_approx_2(const CvMat * L_6x10, const CvMat * Rho,
			       double * betas)
{
  double l_6x3[6 * 3], b3[3];
  CvMat L_6x3  = cvMat(6, 3, CV_64F, l_6x3);
  CvMat B3     = cvMat(3, 1, CV_64F, b3);

  for(int i = 0; i < 6; i++) {
    cvmSet(&L_6x3, i, 0, cvmGet(L_6x10, i, 0));
    cvmSet(&L_6x3, i, 1, cvmGet(L_6x10, i, 1));
    cvmSet(&L_6x3, i, 2, cvmGet(L_6x10, i, 2));
  }

  cvSolve(&L_6x3, Rho, &B3, CV_SVD);

  if (b3[0] < 0) {
    betas[0] = sqrt(-b3[0]);
    betas[1] = (b3[2] < 0) ? sqrt(-b3[2]) : 0.0;
  } else {
    betas[0] = sqrt(b3[0]);
    betas[1] = (b3[2] > 0) ? sqrt(b3[2]) : 0.0;
  }

  if (b3[1] <


 specific language governing permissions and
 * limitations under the License.
 */

/*****************************************************************************

This code is based on arg.cc developed by John Plevyak and released as
part of his iterative flow analysis package available at SourceForge
(http://sourceforge.net/projects/ifa/).  The original code is:

Copyright (c) 1992-2006 John Plevyak.

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*****************************************************************************/

#include "arg.h"
#include "arg-helpers.h"

#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif

#include <cstdio>
#include <cstring>
#include <inttypes.h>

extern bool developer;

static const char* get_envvar_setting(const ArgumentDescription& desc);

/************************************* | **************************************
*                                                                             *
* Generate a usage page                                                       *
*                                                                             *
************************************** | *************************************/

static void  print_n_spaces(int n);
static void  word_wrap_print(const char* text, int startCol, int endCol);

void usage(const ArgumentState* state,
           int                  status,
           bool                 printEnvHelp,
           bool                 printCurrentSettings)
{
  const ArgumentDescription* desc           = state->desc;
  const int                  desc_start_col = 39;
  const int                  end_col        = 79;

  fprintf(stdout, "Usage: %s [flags] [source files]\n", state->program_name);

  // The last row is the only row where the name is NULL
  for (int i = 0; desc[i].name != 0; i++)
  {
    // If this is a header row (the name is the empty string)
    if (desc[i].name[0] == '\0')
    {
      if (strncmp(desc[i].description, "Developer Flags", 15) == 0)
      {
        if (developer == false)
        {
          // We assume that developer flags are listed at the end of the
          // argument list in driver.cpp.  If we encounter a section header
          // whose prefix matches "Developer Flags" and (developer == false),
          // then we truncate the rest of the options list.
          break;
        }
      }

      fprintf(stdout, "\n%s:\n", desc[i].description);
    }
    else
    {
      int nprinted = 0;

      if (desc[i].key != ' ')
        nprinted = fprintf(stdout, "  -%c, --", desc[i].key);
      else
        nprinted = fprintf(stdout, "      --");

      if (desc[i].type &&
          (strcmp(desc[i].type, "N") == 0 || strcmp(desc[i].type, "n") == 0))
        nprinted += fprintf(stdout, "[no-]");

      nprinted += fprintf(stdout, "%s", desc[i].name);


 the desired height; typically the same as the image height
	 *            used to calibrate the camera
	 * @param target
	 *            the target camera intrinsics
	 * @param R
	 *            the rectification matrix
	 * @return the distortion map
	 */
	public FImage[] buildRectifiedUndistortionMap(final int width, final int height, CameraIntrinsics target, Matrix R) {
		final FImage xords = new FImage(width, height);
		final FImage yords = new FImage(width, height);

		final double pxp = target.getPrincipalPointX();
		final double pyp = target.getPrincipalPointY();
		final double fxp = target.getFocalLengthX();
		final double fyp = target.getFocalLengthY();

		final double px = this.getPrincipalPointX();
		final double py = this.getPrincipalPointY();
		final double fx = this.getFocalLengthX();
		final double fy = this.getFocalLengthY();

		final Matrix Rinv = R.inverse();
		final Matrix tmp = new Matrix(3, 1);
		tmp.set(2, 0, 1);

		for (int v = 0; v < height; v++) {
			double y = (v - pyp) / fyp;

			for (int u = 0; u < width; u++) {
				double x = (u - pxp) / fxp;

				tmp.set(0, 0, x);
				tmp.set(1, 0, y);
				final Matrix pro = Rinv.times(tmp);
				x = pro.get(0, 0) / pro.get(2, 0);
				y = pro.get(1, 0) / pro.get(2, 0);

				final double r2 = x * x + y * y;
				final double r4 = r2 * r2;
				final double r6 = r2 * r2 * r2;

				// radial component
				double tx = x * (k1 * r2 + k2 * r4 + k3 * r6);
				double ty = y * (k1 * r2 + k2 * r4 + k3 * r6);

				// tangential component
				tx += 2 * p1 * x * y + p2 * (r2 + 2 * x * x);
				ty += p1 * (r2 + 2 * y * y) + 2 * p2 * x * y;

				xords.pixels[v][u] = (float) ((x + tx) * fx + px);
				yords.pixels[v][u] = (float) ((y + ty) * fy + py);
			}
		}

		return new FImage[] { xords, yords };
	}

	/**
	 * Undistort the given image by removing the radial and tangential
	 * distortions of this camera. It is assumed that the input image has the
	 * same dimensions as images produced by this {@link CameraIntrinsics}.
	 * <p>
	 * This method is inefficient if you need to process many images as the
	 * distortion map is computed each time. For more efficient operation, use
	 * {@link #buildUndistortionProcessor()} to make a reusable
	 * {@link RemapProcessor} capable of efficiently undistorting multiple
	 * images.
	 *
	 * @param image
	 *            the image to undistort
	 * @return the undistorted image
	 */
	public <I extends Image<?, I> & SinglebandImageProcessor.Processable<Float, FImage, I>> I undistort(I image) {
		final RemapProcessor proc = buildUndistortionProcessor(image.getWidth(), image.getHeight());
		return image.process(proc);
	}
}
/**
 * Copyright (c) 2011, The University of Southampton and the individual contributors.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 *   * 	Redistributions of source code must retain the above copyright notice,
 * 	this list of conditions and the following disclaimer.
 *
 *   *	Redistributions in binary form must reproduce the above copyright notice,
 * 	this list of conditions and the following


bectl exec -it ipv6-test-pod -- sh

curl --ipv4 -v http://example.com
```

Curl should succeed connecting.
# Changelog

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [v0.18.0] - 2025-07-18

- chore: update Go to 1.24.5 for fluentbit images [#807]
- chore: update Go to 1.24.5 for operator images [#808]

[#807]: https://github.com/SumoLogic/tailing-sidecar/pull/807
[#808]: https://github.com/SumoLogic/tailing-sidecar/pull/808

## [v0.17.0] - 2025-05-07

- chore: update base ubi image from 9.4 to 9.5 and golang version from 1.22.5 to 1.24.3 [#802](https://github.com/SumoLogic/tailing-sidecar/pull/802)

## [v0.16.0] - 2024-10-10

- build(deps): bump docker/setup-buildx-action from 3.4.0 to 3.7.1 [#745]
- build(deps): bump github.com/onsi/gomega in /operator [#757]
- build(deps): bump fluent/fluent-bit in /sidecar/fluentbit [#763]
- build(deps): bump golang from 1.22.4 to 1.23.2 in /operator [#764]

[#745]: https://github.com/SumoLogic/tailing-sidecar/pull/745
[#757]: https://github.com/SumoLogic/tailing-sidecar/pull/757
[#763]: https://github.com/SumoLogic/tailing-sidecar/pull/763
[#764]: https://github.com/SumoLogic/tailing-sidecar/pull/764

## [v0.15.0] - 2024-06-27

- chore(sidecar): update Fluent Bit UBI image to 3.0.7 by @sumo-drosiek in #725

[#725]: https://github.com/SumoLogic/tailing-sidecar/pull/725

## [v0.14.1] - 2024-06-21

- deps: upgrade kube-rbac-proxy to v0.18.0 [#723]

[#723]: https://github.com/SumoLogic/tailing-sidecar/pull/723

## [v0.14.0] - 2024-06-04

- build(deps): bump ubi8/ubi-minimal from 8.9 to 8.10 [#706]
- build(deps): bump fluent/fluent-bit from 3.0.4 to 3.0.6 [#708]
- chore: set version and release_number labels in ubi image [#711]
- build: downgrade sidecar to Go 1.20 [#710]
- deps: upgrade controller-runtime to 0.18.3 [#715]
- feat(helm): set tolerations for the operator [#716]

[#706]: https://github.com/SumoLogic/tailing-sidecar/pull/706
[#708]: https://github.com/SumoLogic/tailing-sidecar/pull/708
[#710]: https://github.com/SumoLogic/tailing-sidecar/pull/710
[#711]: https://github.com/SumoLogic/tailing-sidecar/pull/711
[#715]: https://github.com/SumoLogic/tailing-sidecar/pull/715
[#716]: https://github.com/SumoLogic/tailing-sidecar/pull/716

## [v0.13.0] - 2024-05-21

- build(deps): bump fluent/fluent-bit from 3.0.2 to 3.0.4 in /sidecar/fluentbit. [#703]
- build(deps): bump golang from 1.22.2 to 1.22.3 in /operator [#699]

[#703]: https://github.com/SumoLogic/tailing-sidecar/pull/703
[#699]: https://github.com/SumoLogic/tailing-sidecar/pull/699


nism.md.

Here is the full, updated content of the file that was saved:

<final_file_content path="docs/rtfs-2.0/specs-incoming/08-concurrency-and-determinism.md">
# RTFS 2.0 Incoming Spec: Concurrency and Determinism

Status: Proposed (specs-incoming)
Audience: RTFS compiler/runtime, Orchestrator, Governance Kernel, Capability Marketplace
Related: docs/rtfs-2.0/specs/01-language-features.md, 05-native-type-system.md, specs-incoming/07-effect-system.md, docs/ccos/specs/002-plans-and-orchestration.md, 014-step-special-form-design.md

## 1. Overview

This document proposes formal concurrency and determinism semantics for RTFS. It defines how parallel composition behaves, how results are combined, how non-determinism is controlled, and how retries/idempotency interact with the Causal Chain.

Goals
- Provide deterministic-by-construction semantics for parallel execution where feasible.
- Define happens-before and join semantics for step.parallel.
- Specify seeding and environmental capture to enable exact replay.
- Define idempotency and retry behavior (failure domains) for robust orchestration.
- Integrate with effects and resources to allow admission-time and runtime enforcement.

Non-Goals
- Scheduling policy specification beyond required determinism and safety.
- Replacing plan-level policy decisions (e.g., approval) handled by the Governance Kernel.

## 2. Constructs

- step.parallel: Executes a fixed set of child steps concurrently; returns an aggregate result with deterministic shape/order.
- step.loop: Repeated execution with a condition; each iteration is sequential within the loop body unless explicitly nested in step.parallel.
- do: Sequential composition.

Note: This spec focuses on step.parallel; loop and other constructs are referenced for interaction only.

## 3. Determinism Model

Determinism is a property of an execution under a given environment digest. RTFS plans may carry determinism metadata:

^{:determinism {:seed "0xDEADBEEF"
                :model_ver "v1.2.3"
                :cap_versions {:com.a:v1 "sha256:.."}
                :env_digest "sha256:..." }}

- seed: Root random seed for deterministic sources (:random, seeded LLM modes).
- model_ver/cap_versions: Pinning for model and capability versions.
- env_digest: Measured environment state (e.g., container image, stdlib hash, config).
- Branch seeds: Derived deterministically as HMAC(seed, "parallel:" || plan-id || step-id || branch-index).

Capabilities must declare whether they can operate deterministically under supplied seeds. Non-deterministic capabilities are allowed but must be recorded; GK policies may restrict them.

## 4. step.parallel Semantics

Syntax (illustrative)

(step.parallel
  (step "A" exprA)
  (step "B" exprB)
  (step "C" exprC))

Return Value
- The result is a vector [resA resB resC] ordered by the lexical order of branches.
- If a branch is named (via step "name"), the orchestrator may also produce a map { :A resA :B resB :C resC } as an auxiliary artifact for observability, but the RTFS value is the vector.

Happens-Before
- Within each branch, standard sequential semantics apply.
- Across branches, no ordering is guaranteed until the join point.
- The join occurs when all non-cancelled branches reach a terminal state (success/failure/cancel).

Failure Propagation
- Default: fail-fast. A hard failure in any branch cancels all unfinished sibling branches, executes compensations (if defined), and fails the overall step.parallel.
- Configurable policy (future extension): allow best-effort completion of all branches; return partial results with error envelopes. Ad


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

package com.babylon.certificatetransparency.internal.utils

import java.io.IOException
import java.io.InputStream

/**
 * [InputStream] wrapper that throws an [IOException] if more than [maxSize] bytes are read
 */
internal class LimitedSizeInputStream(private val original: InputStream, private val maxSize: Long) : InputStream() {
    private var total: Long = 0

    override fun read() = original.read().also {
        if (it >= 0) incrementCounter(1)
    }

    override fun read(b: ByteArray) = read(b, 0, b.size)

    override fun read(b: ByteArray, off: Int, len: Int) = original.read(b, off, len).also {
        if (it >= 0) incrementCounter(it)
    }

    private fun incrementCounter(size: Int) {
        total += size.toLong()
        if (total > maxSize) throw IOException(MAX_SIZE_ERROR_MESSAGE)
    }
}

internal fun Exception.isTooBigException() = message == MAX_SIZE_ERROR_MESSAGE

private const val MAX_SIZE_ERROR_MESSAGE = "InputStream exceeded maximum size in bytes."
/*
 * Copyright 2019 Babylon Partners Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.babylon.certificatetransparency.internal.logclient.model

internal sealed class SignedEntry {

    data class X509(val x509: ByteArray) : SignedEntry() {

        override fun equals(other: Any?): Boolean {
            if (this === other) return true
            if (javaClass != other?.javaClass) return false

            other as X509

            if (!x509.contentEquals(other.x509)) return false

            return true
        }

        override fun hashCode(): Int {
            return x509.contentHashCode()
        }
    }

    data class PreCertificate(val preCertificate: com.babylon.certificatetransparency.internal.logclient.model.PreCertificate) : SignedEntry()
}
/*
 * Copyright 2019 Babylon Partners Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.babylon.certificatetransparency.internal.logclient.model

import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo

/**
 * @property issuerKeyHash [issuerKeyHash] is the SHA-256 hash of the certificate issuer's public key, calculated over the DER encoding of the
 * key represented as [SubjectPublicKeyInfo].  This is needed to bind the issuer to the final certificate.
 * @property tbsCertificate [tbsCertificate] is the DER


rg/licenses/>.  */

#include <sysdep.h>

ENTRY (__longjmp)
	mov	a2, a0
	mov	a0, a1		/* Get the return value in place.  */
	cmpnei	a0, 0
	bt	have_return
	movi	a0, 1		/* Can't let setjmp() return zero! */
have_return:
#ifdef CHECK_SP
	ldw	r10, (a2, 0)	/* Jmpbuf's sp.  */
# ifdef PTR_MANGLE
	PTR_DEMANGLE (r10, r10, a3)
# endif
	CHECK_SP (r10)
#endif
	ldw	sp, (a2, 0)
	ldw	lr, (a2, 4)
	ldw	r4, (a2, 8)
	ldw	r5, (a2, 12)
	ldw	r6, (a2, 16)
	ldw	r7, (a2, 20)
	ldw	r8, (a2, 24)
	ldw	r9, (a2, 28)
	ldw	r10, (a2, 32)
	ldw	r11, (a2, 36)
	ldw	r16, (a2, 40)
	ldw	r17, (a2, 44)
	ldw	r26, (a2, 48)
	ldw	r27, (a2, 52)
	ldw	r28, (a2, 56)
	ldw	r29, (a2, 60)
	ldw	r30, (a2, 64)
	ldw	r31, (a2, 68)
	addi	a2, 72

#ifdef PTR_MANGLE
	PTR_DEMANGLE (sp, sp, a3)
	PTR_DEMANGLE2 (lr, lr, a3)
#endif
	jmp	lr

END (__longjmp)


l_groups'];
    var cats = groups.filter((entry) => entry.value['type'] == 'list');
    return cats.map((key, value) => MapEntry(key, value['value']));
  }

  void setGroupClusters(String group, List clusters) {
    Map groups = this['cell_groups'];
    groups[group]['value'] = clusters;
  }

  List get groups {
    Map groups = this['cell_groups'];
    return groups.keys.toList();
  }

  List getClusters(group) {
    Map groups = this['cell_groups'];
    return groups[group]?['value'] ?? [];
  }

  String getGroupType(group) {
    Map groups = this['cell_groups'];
    return groups[group]?['type'];
  }

  bool isCategory(String group) => getGroupType(group) == 'list';

  bool isCartesian(group) => getGroupType(group) == 'num';

  List _cartesian2category(List scope, int defCount) {
    Map<String, dx.DoubleRange> clusters = {};
    int count = scope[1] - scope[0] == 0 ? 1 : defCount;
    double avg = scope[1] - scope[0] == 0 ? scope[1].toDouble() : ((scope[1] - scope[0]) / count);
    if (avg > 1) avg = avg.ceilToDouble();
    // int nn = avg < .1 ? 3 : 2;
    for (int i = 0; i < count; i++) {
      double start = scope[0] + i * avg;
      dx.DoubleRange range = dx.DoubleRange(start, i < count - 1 ? (start + avg) : scope[1] * 1.0);
      clusters['[${start.toStringAsPrecision(3)}-${range.endInclusive.toStringAsPrecision(3)})'] = range;
    }
    return [clusters.keys.toList(), avg];
  }
}
import 'package:dartx/dartx.dart' as dx;
import 'package:flutter_smart_genome/bean/feature_beans.dart';
import 'package:flutter_smart_genome/service/beans.dart';
import 'package:flutter_smart_genome/widget/track/base/track_data.dart';
import 'package:flutter_smart_genome/widget/track/common.dart' as cm;

class PeakPairTrackData extends TrackData {
  List<PeakPair> features;

  double? _customMin, _customMax;

  PeakPairTrackData({
    required this.features,
    Track? track,
    cm.Range? dataRange,
  }) : super(
          track: track,
          dataRange: dataRange,
        );

  set customMin(double? min) => _customMin = min;

  set customMax(double? max) => _customMax = max;

  late double _min, _max;

  double get min => _min;

  double get max => _max;

  filterAndPrepare(cm.Range visibleRange, {dx.Function1<Feature, String>? distinctBy}) {
    // print('-feature:-- ${features.map((e) => e.json).toList().join('\n')}');
    _min = features.minBy((f) => f.value)?.value ?? 0;
    _max = features.maxBy((f) => f.value)?.value ?? 0;

    features = features
        .filter(valueFilterFunction ?? (t) => true)
        .where((f) => visibleRange.contains(f.range.start) || visibleRange.contains(f.range.end))
        // .distinctBy(distinctBy ?? (f) => f.id)
        .sortedBy((f) => f.range.start)
//        .thenBy((element) => element.range.size)
//        .thenBy((element) => element.children?.length ?? 0)
        .toList();
  }

  dx.Function1<PeakPair, bool>? get valueFilterFunction {
    if (_customMax != null && _customMin != null) {
      return _filterMixMax;
    }
    if (_custom


  left.factor
        } else {
            -(left.factor * (right.value - value) + right.factor * (value - left.value)) / (left.value - right.value)
        }
        current = max(0.0f, min(current, 1.0f))

        return current * value
    }

    /**
     * Returns a string representation of the transfer function.
     */
    override fun toString(): String {
        return "TransferFunction: ${controlPoints.sortedBy { it.value }.joinToString { "@${it.value}: alpha=${it.factor}" }}"
    }

    companion object {
        /** Returns a flat transfer function that transfers all values */
        @JvmStatic @JvmOverloads fun flat(factor: Float = 1.0f): TransferFunction {
            val tf = TransferFunction("Flat")
            tf.addControlPoint(0.0f, factor)
            tf.addControlPoint(1.0f, factor)

            return tf
        }

        /** Returns a ramp transfer function, transferring nothing before [offset] (0.0f by default),
         * and everything after a distance of [offset] + [distance]. If this sum exceeds 1.0f, then
         * 1.0f (the maximum value) is taken.
         */
        @JvmStatic @JvmOverloads fun ramp(offset: Float = 0.0f, rampMax: Float = 1.0f, distance: Float = 0.1f): TransferFunction {
            val tf = TransferFunction()
            tf.addControlPoint(0.0f, 0.0f)
            tf.addControlPoint(offset, 0.0f)
            tf.addControlPoint(minOf(offset + distance, 1.0f), rampMax)

            return tf
        }
    }
}
package graphics.scenery.textures

import net.imglib2.type.numeric.NumericType
import net.imglib2.type.numeric.integer.UnsignedByteType
import org.joml.Vector3i
import org.lwjgl.system.MemoryUtil
import java.nio.ByteBuffer

class UpdatableTexture(
    dimensions: Vector3i,
    channels: Int = 4,
    type: NumericType<*> = UnsignedByteType(),
    contents: ByteBuffer?,
    repeatUVW: Triple<RepeatMode, RepeatMode, RepeatMode> = Triple(RepeatMode.Repeat, RepeatMode.Repeat, RepeatMode.Repeat),
    borderColor: BorderColor = BorderColor.TransparentBlack,
    normalized: Boolean = true,
    mipmap: Boolean = true,
    minFilter: FilteringMode = FilteringMode.Linear,
    maxFilter: FilteringMode = FilteringMode.Linear,
    usageType: HashSet<UsageType> = hashSetOf(UsageType.Texture),
) : Texture(dimensions, channels, type, contents, repeatUVW, borderColor, normalized, mipmap, minFilter, maxFilter, usageType) {
    /** Data class for encapsulating partial transfers. */
    data class TextureExtents(val x: Int, val y: Int, val z: Int, val w: Int, val h: Int, val d: Int)

    /** Update class for partial updates. */
    data class TextureUpdate(val extents: TextureExtents, val contents: ByteBuffer, var consumed: Boolean = false, var deallocate: Boolean = false)

    /** List of [TextureUpdate]s for the currently active texture. */
    private var updates: ArrayList<TextureUpdate> = ArrayList()

    fun addUpdate(update: TextureUpdate) {
        updates.add(update)
        updated = System.nanoTime()
    }

    /** Returns true if the generic texture does have any non-consumed updates */
    fun hasConsumableUpdates(): Boolean {
        return updates.any { !it.consumed }
    }

    fun getConsumableUpdates(): List<TextureUpdate> {
        return updates.filter { !it.consumed }
    }

    /** Clears all consumed updates */
    fun clearConsumedUpdates() {
        updates.forEach {
            if((it.consumed && it.deallocate)) {
                MemoryUtil.memFree(it.contents)
            }
        }
        updates.removeIf {


ugate_mul(Y,K)
;  Y = YYr + i*YYi
; use the following trick
;  K = (Kr-Ki) + i*Ki
		MACRO
		CXMUL_V7  $YYr, $YYi, $Yr, $Yi, $Kr, $Ki,$tmp,$tmp2
        SUB  $tmp2, $Yi, $Yr         ; sYi-sYr
        MUL  $tmp, $tmp2, $Ki        ; (sYi-sYr)*sKi
        ADD  $tmp2, $Kr, $Ki, LSL#1  ; (sKr+sKi)
        MLA  $YYi, $Yi, $Kr, $tmp     ; lYYi = sYi*sKr-sYr*sKi
        MLA  $YYr, $Yr, $tmp2, $tmp   ; lYYr = sYr*sKr+sYi*sKi
        MEND

; Four point complex Fast Fourier Transform
		MACRO
		CXADDA4  $s
        ; (C,D) = (C+D, C-D)
        ADD     Cr, Cr, Dr
        ADD     Ci, Ci, Di
        SUB     Dr, Cr, Dr, LSL#1
        SUB     Di, Ci, Di, LSL#1
        ; (A,B) = (A+(B>>s), A-(B>>s))/4
        MOV     Ar, Ar, ASR#2
        MOV     Ai, Ai, ASR#2
        ADD     Ar, Ar, Br, ASR#(2+$s)
        ADD     Ai, Ai, Bi, ASR#(2+$s)
        SUB     Br, Ar, Br, ASR#(1+$s)
        SUB     Bi, Ai, Bi, ASR#(1+$s)
        ; (A,C) = (A+(C>>s)/4, A-(C>>s)/4)
        ADD     Ar, Ar, Cr, ASR#(2+$s)
        ADD     Ai, Ai, Ci, ASR#(2+$s)
        SUB     Cr, Ar, Cr, ASR#(1+$s)
        SUB     Ci, Ai, Ci, ASR#(1+$s)
        ; (B,D) = (B-i*(D>>s)/4, B+i*(D>>s)/4)
        ADD     Br, Br, Di, ASR#(2+$s)
        SUB     Bi, Bi, Dr, ASR#(2+$s)
        SUB     Di, Br, Di, ASR#(1+$s)
        ADD     Dr, Bi, Dr, ASR#(1+$s)
        MEND

		MACRO
		BUTFLY4ZERO_OPT  $pIN,$offset, $pOUT
        LDRSH Ai, [$pIN, #2]
        LDRSH Ar, [$pIN],#NPT
        LDRSH Ci, [$pIN, #2]
        LDRSH Cr, [$pIN],#NPT
        LDRSH Bi, [$pIN, #2]
        LDRSH Br, [$pIN],#NPT
        LDRSH Di, [$pIN, #2]
        LDRSH Dr, [$pIN],#NPT
        ; (C,D) = (C+D, C-D)
        ADD     Cr, Cr, Dr
        ADD     Ci, Ci, Di
        SUB     Dr, Cr, Dr, LSL#1  ; trick
        SUB     Di, Ci, Di, LSL#1  ;trick
        ; (A,B) = (A+B)/4, (A-B)/4
        MOV     Ar, Ar, ASR#2
        MOV     Ai, Ai, ASR#2
        ADD     Ar, Ar, Br, ASR#2
        ADD     Ai, Ai, Bi, ASR#2
        SUB     Br, Ar, Br, ASR#1
        SUB     Bi, Ai, Bi, ASR#1
        ; (A,C) = (A+C)/4, (A-C)/4
        ADD     Ar, Ar, Cr, ASR#2
        ADD     Ai, Ai, Ci, ASR#2
        SUB     Cr, Ar, Cr, ASR#1
        SUB     Ci, Ai, Ci, ASR#1
        ; (B,D) = (B-i*D)/4, (B+i*D)/4
        ADD     Br, Br, Di, ASR#2
        SUB     Bi, Bi, Dr, ASR#2
        SUB     Di, Br, Di, ASR#


   //创建新的任务箭头图标
        Window_QuestPointer.QuestPointer questPointer_2 = windowQuestPointer.CreatePointer(new Vector3(57, 55));
        //创建新的委托
        FunctionUpdater.Create(() =>
        {
            //如果到达目标范围40m左右就删除任务图标
            if (Vector3.Distance(Camera.main.transform.position, new Vector3(57, 55)) < 15f)
            {
                windowQuestPointer.DestroyPointer(questPointer_2);
                return true;
            }
            else
            {
                return false;
            }
        });
        //创建新的任务箭头图标
        Window_QuestPointer.QuestPointer questPointer_3 = windowQuestPointer.CreatePointer(new Vector3(120, 30));
        //创建新的委托
        FunctionUpdater.Create(() =>
        {
            //如果到达目标范围40m左右就删除任务图标
            if (Vector3.Distance(Camera.main.transform.position, new Vector3(120, 30)) < 20f)
            {
                windowQuestPointer.DestroyPointer(questPointer_3);
                return true;
            }
            else
            {
                return false;
            }
        });
    }
}


16, rOFF16SAVE(r1)
	ld	rOFF24, rOFF24SAVE(r1)
	ld	rOFF32, rOFF32SAVE(r1)
	li	rRTN, 0
	blr

	.align	4
L(dLcr7):
	ld	rWORD8, rWORD8SAVE(r1)
	ld	rWORD7, rWORD7SAVE(r1)
L(dLcr7x):
	ld	rOFF8,  rOFF8SAVE(r1)
	ld	rOFF16, rOFF16SAVE(r1)
	ld	rOFF24, rOFF24SAVE(r1)
	ld	rOFF32, rOFF32SAVE(r1)
	li	rRTN, 1
	bgtlr	cr7
	li	rRTN, -1
	blr
	.align	4
L(dLcr1):
	ld	rWORD8, rWORD8SAVE(r1)
	ld	rWORD7, rWORD7SAVE(r1)
L(dLcr1x):
	ld	rOFF8,  rOFF8SAVE(r1)
	ld	rOFF16, rOFF16SAVE(r1)
	ld	rOFF24, rOFF24SAVE(r1)
	ld	rOFF32, rOFF32SAVE(r1)
	li	rRTN, 1
	bgtlr	cr1
	li	rRTN, -1
	blr
	.align	4
L(dLcr6):
	ld	rWORD8, rWORD8SAVE(r1)
	ld	rWORD7, rWORD7SAVE(r1)
L(dLcr6x):
	ld	rOFF8,  rOFF8SAVE(r1)
	ld	rOFF16, rOFF16SAVE(r1)
	ld	rOFF24, rOFF24SAVE(r1)
	ld	rOFF32, rOFF32SAVE(r1)
	li	rRTN, 1
	bgtlr	cr6
	li	rRTN, -1
	blr
	.align	4
L(dLcr5):
	ld	rWORD8, rWORD8SAVE(r1)
	ld	rWORD7, rWORD7SAVE(r1)
L(dLcr5x):
	ld	rOFF8,  rOFF8SAVE(r1)
	ld	rOFF16, rOFF16SAVE(r1)
	ld	rOFF24, rOFF24SAVE(r1)
	ld	rOFF32, rOFF32SAVE(r1)
	li	rRTN, 1
	bgtlr	cr5
	li	rRTN, -1
	blr

	.align	4
L(bytealigned):
	mtctr	rN

/* We need to prime this loop.  This loop is swing modulo scheduled
   to avoid pipe delays.  The dependent instruction latencies (load to
   compare to conditional branch) is 2 to 3 cycles.  In this loop each
   dispatch group ends in a branch and takes 1 cycle.  Effectively
   the first iteration of the loop only serves to load operands and
   branches based on compares are delayed until the next loop.

   So we must precondition some registers and condition codes so that
   we don't exit the loop early on the first iteration.  */

	lbz	rWORD1, 0(rSTR1)
	lbz	rWORD2, 0(rSTR2)
	bdz	L(b11)
	cmpld	cr7, rWORD1, rWORD2
	lbz	rWORD3, 1(rSTR1)
	lbz	rWORD4, 1(rSTR2)
	bdz	L(b12)
	cmpld	cr1, rWORD3, rWORD4
	lbzu	rWORD5, 2(rSTR1)
	lbzu	rWORD6, 2(rSTR2)
	bdz	L(b13)
	.align	4
L(bLoop):
	lbzu	rWORD1, 1(rSTR1)
	lbzu	rWORD2, 1(rSTR2)
	bne	cr7, L(bLcr7)

	cmpld	cr6, rWORD5, rWORD6
	bdz	L(b3i)

	lbzu	rWORD3, 1(rSTR1)
	lbzu	rWORD4, 1(rSTR2)
	bne	cr1, L(bLcr1)

	cmpld	cr7, rWORD1, rWORD2
	bdz	L(b2i)


	cases := []struct {
		name              string
		jsonInput         string
		setAccessTokenEnv bool
		isValid           bool
	}{
		{
			name:              "Minimal valid input",
			jsonInput:         `{"Org Slug":"org","Auth Token":"token"}`,
			setAccessTokenEnv: false,
			isValid:           true,
		},
		{
			name:              "Missing auth token, but present in env",
			jsonInput:         `{"Org Slug":"org"}`,
			setAccessTokenEnv: true,
			isValid:           true,
		},
		{
			name:              "Missing auth token",
			jsonInput:         `{"Org Slug":"org"}`,
			setAccessTokenEnv: false,
			isValid:           false,
		},
		{
			name:              "Missing org slug",
			jsonInput:         `{"Auth Token":"token"}`,
			setAccessTokenEnv: false,
			isValid:           false,
		},
		{
			name:              "Empty input",
			jsonInput:         `{}`,
			setAccessTokenEnv: false,
			isValid:           false,
		},
	}

	for _, testCase := range cases {
		t.Run(testCase.name, func(t *testing.T) {
			if testCase.setAccessTokenEnv {
				t.Setenv("FLY_ACCESS_TOKEN", "token")
			}

			_, err := ParseTargetOptions(testCase.jsonInput)
			if testCase.isValid && err != nil {
				t.Errorf("Expected valid target options but got error: %s", err)
			} else if !testCase.isValid && err == nil {
				t.Errorf("Expected error for invalid target options but got none")
			}
		})
	}
}
package provider

import (
	"os"
	"testing"
	"time"

	flyutil "github.com/daytonaio/daytona-provider-fly/pkg/provider/util"
	"github.com/daytonaio/daytona-provider-fly/pkg/types"
	"github.com/daytonaio/daytona/pkg/models"
	"github.com/daytonaio/daytona/pkg/provider"
)

var (
	orgSlug   = os.Getenv("FLY_TEST_ORG_SLUG")
	authToken = os.Getenv("FLY_TEST_ACCESS_TOKEN")

	flyProvider   = &FlyProvider{}
	targetOptions = &types.TargetOptions{
		Region:    "lax",
		Size:      "shared-cpu-4x",
		DiskSize:  10,
		OrgSlug:   orgSlug,
		AuthToken: authToken,
	}

	targetReq *provider.TargetRequest
)

func TestCreatetarget(t *testing.T) {
	_, _ = flyProvider.CreateTarget(targetReq)

	_, err := flyutil.GetMachine(targetReq.Target, targetOptions)
	if err != nil {
		t.Fatalf("Error getting machine: %s", err)
	}
}

func TestDestroytarget(t *testing.T) {
	_, err := flyProvider.DestroyTarget(targetReq)
	if err != nil {
		t.Fatalf("Error destroying target: %s", err)
	}
	time.Sleep(3 * time.Second)

	_, err = flyutil.GetMachine(targetReq.Target, targetOptions)
	if err == nil {
		t.Fatalf("Error destroyed target still exists")
	}
}

func init() {
	_, err := flyProvider.Initialize(provider.InitializeProviderRequest{
		BasePath:           "/tmp/targets",
		DaytonaDownloadUrl: "https://download.daytona.io/daytona/install.sh",
		DaytonaVersion:     "latest",
		Server


// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.

/// \file CartesianGPU.h
/// @author David Rohr

#ifndef ALICEO2_CARTESIANGPU_H
#define ALICEO2_CARTESIANGPU_H

#include "GPUCommonDef.h"

namespace o2::math_utils
{

namespace detail
{
template <typename T, int I>
struct GPUPoint2D {
  GPUdDefault() GPUPoint2D() = default;
  GPUhd() GPUPoint2D(T a, T b) : xx(a), yy(b) {}
  GPUhd() float X() const { return xx; }
  GPUhd() float Y() const { return yy; }
  GPUd() float R() const { return o2::gpu::CAMath::Sqrt(xx * xx + yy * yy); }
  GPUd() void SetX(float v) { xx = v; }
  GPUd() void SetY(float v) { yy = v; }
  T xx;
  T yy;
};

template <typename T, int I>
struct GPUPoint3D : public GPUPoint2D<T, I> {
  GPUdDefault() GPUPoint3D() = default;
  GPUhd() GPUPoint3D(T a, T b, T c) : GPUPoint2D<T, I>(a, b), zz(c) {}
  GPUhd() float Z() const { return zz; }
  GPUd() float R() const { return o2::gpu::CAMath::Sqrt(GPUPoint2D<T, I>::xx * GPUPoint2D<T, I>::xx + GPUPoint2D<T, I>::yy * GPUPoint2D<T, I>::yy + zz * zz); }
  GPUd() void SetZ(float v) { zz = v; }
  T zz;
};
} // namespace detail

} // end namespace o2::math_utils

#endif


sp], #16
	ldp	x3, x4, [sp], #16
	ldp	x5, x6, [sp], #16
	ldp	x7, x8, [sp], #16
	ldp	x9, x10, [sp], #16
	ldp	x11, x12, [sp], #16
	ldp	x13, x14, [sp], #16
	ldp	x15, x16, [sp], #16
	ldp	x17, x18, [sp], #16
	ldp	x19, x20, [sp], #16
	ldp	x21, x22, [sp], #16
	ldp	x23, x24, [sp], #16
	ldp	x25, x26, [sp], #16
	ldp	x27, x28, [sp], #16
	ldp	x29, x30, [sp], #16
	eret

/* macro to align handlers every 0x80 bytes */
.macro	vector handler
.balign 0x80
b	\handler
.endm

.balign 0x800
.globl	VectorTable
VectorTable:
	/* from current EL with sp_el0 */
	vector	_start			/* Synchronous */
	vector  hang			/* IRQ */
	vector	hang			/* FIQ */
	vector	hang			/* SErrorStub */

	/* from current EL with sp_elx, x != 0 */
	vector	hang			/* Synchronous */
	vector	irq_handler		/* IRQ */
	vector	hang			/* FIQ */
	vector	hang			/* SErrorStub */

	/* from lower EL, target EL minus 1 is AArch64 */
	vector	hang			/* Synchronous */
	vector  hang			/* IRQ */
	vector	hang			/* FIQ */
	vector	hang			/* SErrorStub */

	/* from lower EL, target EL minus 1 is AArch32 */
	vector	hang			/* Synchronous */
	vector  hang			/* IRQ */
	vector	hang			/* FIQ */
	vector	hang			/* SErrorStub */

/****************************************************************
       	   DATA FOR SMARTSTART64  EXPOSED TO INTER


パティで、 CSS の {{cssxref("margin")}} プロパティと同じような構文の文字列です。

`rootMargin` で表される矩形の各辺は、交差判定が行われる前にルート要素 ({{domxref("IntersectionObserver.root", "root")}}) の{{Glossary("bounding box", "境界ボックス")}}内で対応する辺に追加されます。
これにより、例えば、あるピクセル数の幅または高さが切り取られた場合でもターゲット要素が 100% 表示されるように境界を外側に調整したり、端がルートの境界ボックスの端に近すぎる場合、ターゲットを部分的に非表示として扱ったりすることができます。

ルートマージンについて、またルートの境界ボックスとの間でどのように動作するかについて、より詳しくは[交差の計算方法](/ja/docs/Web/API/Intersection_Observer_API#交差の計算方法)を参照してください。

## 値

CSS の {{cssxref("margin")}} プロパティの値と同様の書式化された文字列で、ルートの境界ボックスの一つ以上の辺のためのオフセットを含みます。これらのオフセットは、結果の矩形と対象要素の境界との間の交差の前に、ルートの境界ボックス内の対応する値に追加されます。

このプロパティが返す文字列は、 {{domxref("IntersectionObserver")}} がインスタンス化されたときに指定された文字列と一致しない場合があります
例えば、結果は常に、入力が少ない場合でも 4 つの要素が含まれています。

オブジェクトのインスタンス化時に `rootMargin` が指定されていない場合、既定では文字列 `"0px 0px 0px 0px"` となります。これは、ルート要素の変更されていない境界矩形と対象の境界線との交点を計算することを意味します。
[交差の計算方法](/ja/docs/Web/API/Intersection_Observer_API#交差の計算方法)では、 `rootMargin` がどのように使用されるか、より詳細に説明しています。

## 仕様書

{{Specifications}}

## ブラウザーの互換性

{{Compat}}
---
title: "HTMLFormElement: reset イベント"
short-title: reset
slug: Web/API/HTMLFormElement/reset_event
l10n:
  sourceCommit: a3d9f61a8990ba7b53bda9748d1f26a9e9810b18
---

{{APIRef}}

**`reset`** イベントは {{HTMLElement("form")}} がリセットされたときに発行されます。

## 構文

このイベント名を {{domxref("EventTarget.addEventListener", "addEventListener()")}} 等のメソッドで使用するか、イベントハンドラープロパティを使用するかしてください。

```js
addEventListener("reset", (event) => {});

onreset = (event) => {};
```

## イベント型

一般的な {{domxref("Event")}} です。

## 例

この例は {{domxref("EventTarget.addEventListener()")}} を使用してフォームがリセットされるのを、実行されたときに現在の {{domxref("Event.timeStamp")}} をログ出力します。

### HTML

```html
<form id="form">
  <label>Test field: <input type="text" /></label>
  <br /><br />
  <button type="reset">Reset form</button>
</form>
<p id="log"></p>
```

### JavaScript

```js
f


	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	var flushers []flushingMetricList
	for _, intv := range []time.Duration{
		time.Second,
		time.Minute,
	} {
		flusher := NewMockflushingMetricList(ctrl)
		flusher.EXPECT().ID().Return(standardMetricListID{resolution: intv}.toMetricListID()).AnyTimes()
		flushers = append(flushers, flusher)
	}

	mgr, _ := testFlushManager(t, ctrl)
	mgr.state = flushManagerOpen
	mgr.buckets = []*flushBucket{
		{
			bucketID: standardMetricListID{resolution: time.Second}.toMetricListID(),
			interval: time.Second,
			flushers: []flushingMetricList{flushers[0]},
		},
	}
	require.Equal(t, errBucketNotFound, mgr.Unregister(flushers[1]))
}

func TestFlushManagerUnregisterFlusherNotFound(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	mgr, _ := testFlushManager(t, ctrl)
	mgr.state = flushManagerOpen
	mgr.buckets = []*flushBucket{
		{
			bucketID: standardMetricListID{resolution: time.Second}.toMetricListID(),
			interval: time.Second,
			flushers: []flushingMetricList{NewMockflushingMetricList(ctrl)},
		},
	}

	flusher2 := NewMockflushingMetricList(ctrl)
	flusher2.EXPECT().ID().Return(standardMetricListID{resolution: time.Second}.toMetricListID()).AnyTimes()
	require.Equal(t, errFlusherNotFound, mgr.Unregister(flusher2))
}

func TestFlushManagerUnregisterSuccess(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	var flushers []flushingMetricList
	for _, intv := range []time.Duration{
		time.Second,
		time.Minute,
		time.Second,
		time.Second,
	} {
		flusher := NewMockflushingMetricList(ctrl)
		flusher.EXPECT().ID().Return(standardMetricListID{resolution: intv}.toMetricListID()).AnyTimes()
		flusher.EXPECT().FlushInterval().Return(intv).AnyTimes()
		flushers = append(flushers, flusher)
	}

	mgr, _ := testFlushManager(t, ctrl)
	mgr.state = flushManagerOpen
	mgr.buckets = []*flushBucket{
		{
			bucketID: standardMetricListID{resolution: time.Second}.toMetricListID(),
			interval: time.Second,
			flushers: []flushingMetricList{flushers[0], flushers[2], flushers[3]},
		},
		{
			bucketID: standardMetricListID{resolution: time.Minute}.toMetricListID(),
			interval: time.Minute,
			flushers: []flushingMetricList{flushers[1]},
		},
	}
	require.NoError(t, mgr.Unregister(flushers[0]))
	require.NoError(t, mgr.Unregister(flushers[2]))

	found := false
	for _, b := range mgr.buckets {
		if b.interval == time.Second {
			found = true
			require.Equal(t, []flushingMetricList{flushers[3]}, b.flushers)
		}
	}
	require.True(t, found)
}

func TestFlushManagerStatus(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	leaderMgr := NewMockroleBasedFlushManager(ctrl)
	leaderMgr.EXPECT().CanLead().Return(false).AnyTimes()
	followerMgr := NewMockroleBasedFlushManager(ctrl)
	followerM