pg,
    required this.payMethod,
    this.escrow,
    required this.merchantUid,
    this.name,
    required this.amount,
    this.customData,
    this.taxFree,
    this.vat,
    this.currency,
    this.language,
    this.buyerName,
    required this.buyerTel,
    this.buyerEmail,
    this.buyerAddr,
    this.buyerPostcode,
    this.noticeUrl,
    this.cardQuota,
    this.digital,
    this.vbankDue,
    this.confirmUrl,
    this.mRedirectUrl = UrlData.redirectUrl,
    required this.appScheme,
    this.bizNum,
    this.customerId,
    this.customerUid,
    this.popup,
    this.naverUseCfm,
    this.naverPopupMode,
    this.naverProducts,
    this.naverCultureBenefit,
    this.naverProductCode,
    this.naverActionType,
    this.naverPurchaserName,
    this.naverPurchaserBirthday,
    this.naverChainId,
    this.naverMerchantUserKey,
    this.naverInterface,
    this.period,
    this.company,
    this.niceMobileV2,
    this.kcpProducts,
    this.bypass,
  });

  factory PaymentData.fromJson(Map<String, dynamic> json) =>
      _$PaymentDataFromJson(json);

  Map<String, dynamic> toJson() => _$PaymentDataToJson(this);

  static List<int>? _cardQuotaFromJson(Map<String, dynamic> json) =>
      (json['card_quota'] as List<dynamic>?)?.map((e) => e as int).toList();

  static Map<String, dynamic>? _cardQuotaToJson(List<int>? list) {
    if (list != null) {
      final val = <String, dynamic>{};

      val['card_quota'] = list;

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

import 'dart:ui' show lerpDouble;

import 'package:flutter/material.dart';
import 'package:flutter/widgets.dart';

class CutCornersBorder extends OutlineInputBorder {
  const CutCornersBorder({
    BorderSide borderSide: const BorderSide(),
    BorderRadius borderRadius: const BorderRadius.all(Radius.circular(2.0)),
    this.cut: 7.0,
    double gapPadding: 2.0,
  }) : super(
            borderSide: borderSide,
            borderRadius: borderRadius,
            gapPadding: gapPadding);

  @override
  CutCornersBorder copyWith({
    BorderSide borderSide,
    BorderRadius borderRadius,
    double gapPadding,
    double cut,
  }) {
    return CutCornersBorder(
      borderRadius: borderRadius ?? this.borderRadius,
      borderSide: borderSide ?? this.borderSide,
      cut: cut ?? this.cut,
      gapPadding: gapPadding ?? this.gapPadding,
    );
  }

  final double cut;

  @override
  ShapeBorder lerpFrom(ShapeBorder a, double t) {
    if (a is CutCornersBorder) {
      final CutCornersBorder outline = a;
      return CutCornersBorder(
        borderRadius: B


Name1, callback1);
    events.on(eventName1, callback1, events);
    events.on(eventName1, callback2);
    events.on(eventName1, callback2, events);
    events.on(eventName2, callback1);
    events.on(eventName2, callback1, events);
    events.on(eventName2, callback2);
    events.on(eventName2, callback2, events);
    events.off(undefined, callback1);

    // 이벤트 발생
    events.emit(eventName1);
    events.emit(eventName2);

    expect(callback1).toHaveBeenCalledTimes(0);
    expect(callback2).toHaveBeenCalledTimes(4);
  });

  it('한 context에 대한 모든 이벤트 리스너를 제거한다', () => {
    class TestEvents extends Events {}
    class Context extends Events {}

    const events = new TestEvents();
    const eventName1 = 'test1';
    const eventName2 = 'test2';
    const callback1 = jest.fn();
    const callback2 = jest.fn();
    const callback3 = jest.fn();
    const context1 = new Context();
    const context2 = new Context();

    events.on(eventName1, callback1);
    events.on(eventName1, callback2, context1);
    events.on(eventName1, callback3, context2);
    events.on(eventName2, callback1);
    events.on(eventName2, callback2, context1);
    events.on(eventName2, callback3, context2);
    events.off(undefined, undefined, context1);

    // 이벤트 발생
    events.emit(eventName1);
    events.emit(eventName2);

    expect(callback1).toHaveBeenCalledTimes(2);
    expect(callback2).toHaveBeenCalledTimes(0);
    expect(callback3).toHaveBeenCalledTimes(2);
  });

  it('context에 상관없이 이벤트 리스너를 제거한다', () => {
    class TestEvents extends Events {}
    class Context extends Events {}

    const events = new TestEvents();
    const eventName1 = 'test1';
    const eventName2 = 'test2';
    const callback1 = jest.fn();
    const callback2 = jest.fn();
    const context = new Context();

    events.on(eventName1, callback1);
    events.on(eventName1, callback1, context);
    events.on(eventName1, callback2);
    events.on(eventName1, callback2, context);
    events.on(eventName2, callback1);
    events.on(eventName2, callback1, context);
    events.on(eventName2, callback2);
    events.on(eventName2, callback2, context);
    events.off(eventName1, callback1);

    // 이벤트 발생
    events.emit(eventName1);
    events.emit(eventName2);

    expect(callback1).toHaveBeenCalledTimes(2);
    expect(callback2).toHaveBeenCalledTimes(4);
  });

  it('callback에 상관없이 이벤트 리스너를 제거한다', () => {
    class TestEvents extends Events {}
    class Context extends Events {}

    const events = new TestEvents();
    const eventName1 = 'test1';
    const eventName2 = 'test2';
    const callback1 = jest.fn();
    const callback2 = jest.fn();
    const context1 = new Context();
    const context2 = new


océdures!

    `,
  },
  {
    id: "glossaire",
    label: "Glossaire TemperApp",
    content: `### Les unités de TemperApp : les commas

  TemperApp propose une description très précise des tempéraments, c’est pourquoi les nombres sont écrits avec des unités adaptées.

  ### **Cp** : le comma pythagoricien

  Le comma pythagoricien est une unité de mesure du tempérament, couramment associé aux quintes.

Sur un cycle des quintes TemperApp, **F : 1/6** signifie **la quinte** $\\small \\textbf{Fa-Do}$ (quinte de l’accord de Fa Majeur) **est tempérée au 1/6ème de comma pythagoricien**.

  En écriture mathématique et en Hz :

  $$\\small Do = Fa \\times \\frac{3}{2} \\times C_{p}^{-\\frac{1}{6}}$$

   - Une valeur 0 signifie une quinte pure

   - Une valeur de 1/12 signifie une quinte au tempérament égal.

   - Une valeur positive par exemple + 1/12 signifie une quinte plus élargie

  ### **Cs** : le comma syntonique

  Le Comma syntonique est une unité de mesure du tempérament, couramment associé aux tierces.

Sur un cycle des tierces TemperApp, **F : 7/11** signifie **la tierce** $\\small \\textbf{Fa-La}$** (tierce de l’accord de Fa Majeur) **est tempérée à 7/11èmes de comma pythagoricien**.

  En écriture mathématique et en Hz :

  $$ \\small La = Fa \\times \\dfrac{5}{4} \\times C_{s}^{\\tfrac{7}{11}}$$

  > NB : le 1/11ème de Comma syntonique est le même intervalle que le 1/12ème de Comma pythagoricien.

  - Une valeur 0 signifie une tierce pure

  - 7/11 est une tierce du tempérament égale

  > NB : 7/11 Cs= 7/12 Cp : dans le tempérament égal, la tierce est 7 fois plus tempérée que la quinte !

  - 11/11 = 1 est une tierce pythagoricienne. Dans une octave,  trois tierces majeures superposées se partagent 21/11 de comma syntonique.

NB : A la différence du comma pythagoricien dont on ne distribue que de toutes petites parties sur les quintes (1/6 , 1/12 etc.) on affecte les tierces de valeurs beaucoup plus grandes. C’est pourquoi on utilise l’unité 1/11ème Cs, qui permet de faire varier le dénominateur en nombres entiers.

  ### **Cs/Cp** : deux unités possibles pour les quintes

  Les tempéraments sont en général conçus par rapport aux tierces ou aux quintes (voir “Définitions”). Si le tempérament est conçu en Comma syntonique, alors ses valeurs exprimées en unité “Comma pythagoricien” seront moins élégantes. Par exemple, 1/6ème de Comma Pythagoricien vaut 1/(5,5)ème de Comma syntonique. L’utilisateur a donc la possibilité de choisir l’unité des quintes.

Néanmoins, changer l’unité des tierces n’est pas utile, car elles sont toujours exprimées en 1/11ème de Comma syntonique qui est équivalent au 1/12ème de comma pythagoricien. Pour ne pas alourdir l’application, nous avons fait le choix de maintenir cette unité.

  ### Les unités de TemperApp : les battements

  Le Hertz **Hz** est une unité de fréquence d’un phénomène cyclique. Il signifie “ cycles par seconde”. 440Hz signifie 440 vibrations par seconde.

  **Bps** : Même unité que le Hz. Utile pour décrire les


-radio:after,
.theme-gray label.label-radio input[type="checkbox"]:checked ~ .item-after i.icon-form-radio:after,
label.label-radio.theme-gray input[type="checkbox"]:checked ~ .item-after i.icon-form-radio:after,
.theme-gray label.label-radio input[type="radio"]:checked ~ .item-after i.icon-form-radio:after,
label.label-radio.theme-gray input[type="radio"]:checked ~ .item-after i.icon-form-radio:after,
.theme-gray label.label-radio input[type="checkbox"]:checked ~ .item-inner i.icon-form-radio:after,
label.label-radio.theme-gray input[type="checkbox"]:checked ~ .item-inner i.icon-form-radio:after,
.theme-gray label.label-radio input[type="radio"]:checked ~ .item-inner i.icon-form-radio:after,
label.label-radio.theme-gray input[type="radio"]:checked ~ .item-inner i.icon-form-radio:after {
  background-color: #9e9e9e;
}
.theme-gray .focus-state .label,
.theme-gray .focus-state .floating-label {
  color: #9e9e9e;
}
.theme-gray .item-input-field.focus-state:after,
.theme-gray .input-field.focus-state:after,
.theme-gray .item-input-field.not-empty-state:after,
.theme-gray .input-field.not-empty-state:after {
  background: #9e9e9e;
}
.theme-gray .picker-calendar-day.picker-calendar-day-today span {
  color: #9e9e9e;
}
.theme-gray .picker-calendar-day.picker-calendar-day-selected span {
  background-color: #9e9e9e;
  color: #fff;
}
.theme-gray .picker-header {
  background-color: #9e9e9e;
}
.theme-gray .modal-button {
  color: #9e9e9e;
}
.swiper-pagination.color-gray .swiper-pagination-bullet-active,
.theme-gray .swiper-pagination .swiper-pagination-bullet-active {
  background-color: #9e9e9e;
}
.swiper-button-next.color-gray,
.swiper-container-rtl .swiper-button-prev.color-gray,
.theme-gray .swiper-button-next,
.theme-gray .swiper-container-rtl .swiper-button-prev {
  background-image: url("data:image/svg+xml;charset=utf-8,%3Csvg%20xmlns%3D'http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg'%20viewBox%3D'0%200%2027%2044'%3E%3Cpath%20d%3D'M27%2C22L27%2C22L5%2C44l-2.1-2.1L22.8%2C22L2.9%2C2.1L5%2C0L27%2C22L27%2C22z'%20fill%3D'%239e9e9e'%2F%3E%3C%2Fsvg%3E");
}
.swiper-button-prev.color-gray,
.swiper-container-rtl .swiper-button-next.color-gray,
.theme-gray .swiper-button-prev,
.theme-gray .swiper-container-rtl .swiper-button-next {
  background-image: url("data:image/svg+xml;charset=utf-8,%3Csvg%20xmlns%3D'http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg'%20viewBox%3D'0%200%2027%2044'%3E%3Cpath%20d%3D'M0%2C22L


multiplier: 2.5 !default;
$o-theme-h3-font-size-multiplier: 2 !default;
$o-theme-h4-font-size-multiplier: 1.5 !default;
$o-theme-h5-font-size-multiplier: 1.25 !default;
$o-theme-h6-font-size-multiplier: 1 !default;

// Mirror BS default lead multiplier value
$o-lead-ratio: 1.125 !default;

// Map:
// <font-name>: (
//     'family': <css font family list>,
//     'url': <related part of google fonts URL>,
//     'properties' (optional): (
//         <font-alias>: (
//             <website-value-key>: <value>,
//             ...,
//         ),
//         ...,
//     )
// )
// $o-base-theme-font-configs will be used to automatically extend
// $o-theme-font-configs whatever themes added inside.
$o-base-theme-font-configs: (
    'SYSTEM_FONTS': (
        // This allows users to use default system fonts, potentially improving
        // page loading performances. This should always be kept as the first
        // font defined in $o-base-theme-font-configs.
        'family': $o-system-fonts,
    ),
) !default;
$o-theme-font-configs: (
    'Roboto': (
        'family': ('Roboto', sans-serif),
        'url': 'Roboto:300,300i,400,400i,700,700i',
    ),
    'Open Sans': (
        'family': ('Open Sans', sans-serif),
        'url': 'Open+Sans:300,300i,400,400i,700,700i',
    ),
    'Source Sans Pro': (
        'family': ('Source Sans Pro', sans-serif),
        'url': 'Source+Sans+Pro:300,300i,400,400i,700,700i',
    ),
    'Raleway': (
        'family': ('Raleway', sans-serif),
        'url': 'Raleway:300,300i,400,400i,700,700i',
    ),
    'Noto Serif': (
        'family': ('Noto Serif', serif),
        'url': 'Noto+Serif:300,300i,400,400i,700,700i',
    ),
    'Arvo': (
        'family': ('Arvo', Times, serif),
        'url': 'Arvo:300,300i,400,400i,700,700i',
    ),
    'Inter Tight': (
        'family': ('Inter Tight', sans-serif),
        'url': 'Inter+Tight:300,300i,400,400i,500,500i,700,700i',
    ),
    'Inter': (
        'family': ('Inter', sans-serif),
        'url': 'Inter:300,300i,400,400i,700,700i',
    ),
) !default;

//------------------------------------------------------------------------------
// Mixins
//------------------------------------------------------------------------------

@mixin o-ribbon-right() {
    @include o-position-absolute($top: 0, $right: 0);
    padding: 0.5rem $ribbon-padding;
    // 0.708 is 1 - cos(45deg)
    // Transforms are applied right-to-left
    // Cannot use matrix because of the use of % values.
    transform: translateX(calc(-0.708 * (100% - #{2 * $ribbon-padding}))) rotate(45deg) translateX(calc(100% - #{$ribbon-padding}));
    transform-origin: top right;
};

@mixin o-ribbon-left() {
    @include o-position-absolute($top: 0, $left: 0);
    padding: 0.5rem $ribbon-padding;
    transform: translateX(calc(0.708 * (100% - #{2 * $ribbon-padding}) - 100%)) rotate(-45deg) translateX($ribbon-padding);
    transform-origin: top righ


VM)
        {
            if (itemAffixVM != null)
            {
                _affixManager.RemoveAffix(itemAffixVM.Model);
            }
        }

        private bool CanSetAffixDoneExecute()
        {
            var duplicates = _selectedAffixes.ToList().FindAll(a => a.Id.Equals(_affixInfo.IdName))
                .GroupBy(a => new { a.Type, a.IsImplicit, a.IsGreater, a.IsTempered })
                .Where(g => g.Count() > 1);
            return duplicates.Count() == 0;
        }

        private void SetAffixDoneExecute()
        {
            CloseCommand.Execute(this);
        }

        #endregion

        // Start of Methods region

        #region Methods

        private void CreateSelectedAffixesFilteredView()
        {
            Application.Current?.Dispatcher?.Invoke(() =>
            {
                SelectedAffixesFiltered = new ListCollectionView(SelectedAffixes)
                {
                    Filter = FilterSelectedAffixes
                };
            });
        }

        private bool FilterSelectedAffixes(object selectedAffixObj)
        {
            if (selectedAffixObj == null) return false;

            ItemAffixVM itemAffix = (ItemAffixVM)selectedAffixObj;

            return itemAffix.Id.Equals(_affixInfo.IdName);
        }

        private void UpdateSelectedAffixes()
        {
            Application.Current?.Dispatcher.Invoke(() =>
            {
                SelectedAffixes.Clear();
                if (_affixPreset != null)
                {
                    var itemAffixes = _affixPreset.ItemAffixes.Select(itemAffix => new ItemAffixVM(itemAffix)).ToList();
                    itemAffixes.Sort((x, y) =>
                    {
                        int result = x.Type.CompareTo(y.Type);
                        if (result == 0)
                        {
                            result = x.IsImplicit && !y.IsImplicit ? -1 : y.IsImplicit && !x.IsImplicit ? 1 : 0;
                        }
                        if (result == 0)
                        {
                            result = x.IsGreater && !y.IsGreater ? -1 : y.IsGreater && !x.IsGreater ? 1 : 0;
                        }
                        if (result == 0)
                        {
                            result = x.IsTempered && !y.IsTempered ? -1 : y.IsTempered && !x.IsTempered ? 1 : 0;
                        }

                        return result;
                    });

                    SelectedAffixes.AddRange(itemAffixes);
                }
            });
        }

        #endregion
    }
}


	}
	return &certs[0]
}

// SetCertificate st a certificate for TLS use.
func (c *Client) SetCertificate(cert tls.Certificate) {
	t := c.Client.Transport.(*http.Transport)

	// Extension or HoK certificate
	t.TLSClientConfig.Certificates = []tls.Certificate{cert}
}

// UseServiceVersion sets Client.Version to the current version of the service endpoint via /sdk/vimServiceVersions.xml
func (c *Client) UseServiceVersion(kind ...string) error {
	ns := "vim"
	if len(kind) != 0 {
		ns = kind[0]
	}

	u := c.URL()
	u.Path = path.Join("/sdk", ns+"ServiceVersions.xml")

	res, err := c.Get(u.String())
	if err != nil {
		return err
	}

	if res.StatusCode != http.StatusOK {
		return fmt.Errorf("http.Get(%s): %s", u.Path, res.Status)
	}

	v := struct {
		Namespace *string `xml:"namespace>name"`
		Version   *string `xml:"namespace>version"`
	}{
		&c.Namespace,
		&c.Version,
	}

	err = xml.NewDecoder(res.Body).Decode(&v)
	_ = res.Body.Close()
	if err != nil {
		return fmt.Errorf("xml.Decode(%s): %s", u.Path, err)
	}

	return nil
}

// Tunnel returns a Client configured to proxy requests through vCenter's http port 80,
// to the SDK tunnel virtual host.  Use of the SDK tunnel is required by LoginExtensionByCertificate()
// and optional for other methods.
func (c *Client) Tunnel() *Client {
	tunnel := c.newServiceClientWithTransport(c.u.Path, c.Namespace, c.DefaultTransport().Clone())

	t := tunnel.Client.Transport.(*http.Transport)
	// Proxy to vCenter host on port 80
	host := tunnel.u.Hostname()
	// Should be no reason to change the default port other than testing
	key := "GOVMOMI_TUNNEL_PROXY_PORT"

	port := tunnel.URL().Query().Get(key)
	if port == "" {
		port = os.Getenv(key)
	}

	if port != "" {
		host += ":" + port
	}

	t.Proxy = http.ProxyURL(&url.URL{
		Scheme: "http",
		Host:   host,
	})

	// Rewrite url Host to use the sdk tunnel, required for a certificate request.
	tunnel.u.Host = sdkTunnel
	return tunnel
}

// URL returns the URL to which the client is configured
func (c *Client) URL() *url.URL {
	urlCopy := *c.u
	return &urlCopy
}

type marshaledClient struct {
	Cookies  []*http.Cookie `json:"cookies"`
	URL      *url.URL       `json:"url"`
	Insecure bool           `json:"insecure"`
	Version  string         `json:"version"`
	UseJSON  bool           `json:"useJSON"`
}

// MarshalJSON writes the Client configuration to JSON.
func (c *Client) MarshalJSON() ([]byte, error) {
	m := marshaledClient{
		Cookies:  c.Jar.Cookies(c.u),
		URL:      c.u,
		Insecure: c.k,
		Version:  c.Version,
		UseJSON:  c.useJSON,
	}

	return json.Marshal(m)
}

// UnmarshalJSON rads Client configuration from JSON.
func (c *Client) UnmarshalJSON(b []byte) error {
	var m marshaledClient

	err := json.Unmarshal(b, &m)
	if err != nil {
		return err
	}

	*c = *NewClient(m.URL, m.Insecure)
	c.Version = m.Version
	c.Jar.SetCookies(m.URL, m.Cookies


), ("x2", 0)),
            (("x3", -1), ("x2", 0)),
            (("x3", -1), ("x3", 0)),
            (("x1", -3), ("x3", 0)),
            (("x1", 0), ("x3", 0)),
        ]
        G.add_edges_from(ts_edges)
        self.G = G
        self.max_lag = max_lag
        self.klass = StationaryTimeSeriesDiGraph

class TestStationaryGraph(BasicStationaryTimeSeriesGraphTester):
    """Test properties of a stationary time-series graph."""

    def setup_method(self):
        max_lag = 3
        G = StationaryTimeSeriesGraph(max_lag=max_lag)
        ts_edges = [
            (("x1", -1), ("x1", 0)),
            (("x1", -1), ("x2", 0)),
            (("x3", -1), ("x2", 0)),
            (("x3", -1), ("x3", 0)),
            (("x1", -3), ("x3", 0)),
            (("x1", 0), ("x3", 0)),
        ]
        G.add_edges_from(ts_edges)
        self.G = G
        self.max_lag = max_lag
        self.klass = StationaryTimeSeriesGraph


-------------------------
glfw.window_hint("context version major", 3)
glfw.window_hint("context version minor", 3)
glfw.window_hint("opengl profile", 'core')
window = glfw.create_window(512, 512, "Color Cube")
glfw.make_context_current(window)
gl.init()
init()

glfw.set_key_callback(window, keyboard)
glfw.set_mouse_button_callback(window, mouse)
glfw.set_framebuffer_size_callback(window, reshape)

print("Use mouse buttons to change the rotation axis (left=x, middle=y, right=z)")

while not glfw.window_should_close(window) do
   glfw.poll_events()

   Theta[Axis] = Theta[Axis] + 0.5
   if Theta[Axis] > 360.0 then
      Theta[Axis] = Theta[Axis] - 360.0
   end

   gl.clear( 'color', 'depth' )

   -- Bind textures using texture units:
   gl.active_texture(0)
   gl.bind_texture('2d', texture1)
   gl.uniform(gl.get_uniform_location(program, "Texture1"), 'int', 0)
   gl.active_texture(1)
   gl.bind_texture('2d', texture2)
   gl.uniform(gl.get_uniform_location(program, "Texture2"), 'int', 1)

   -- load the new angles:
   gl.uniform(theta_loc, 'float', Theta.x, Theta.y, Theta.z)
   -- eventually, draw the cube:
   gl.draw_arrays( 'triangles', 0, num_vertices)
   glfw.swap_buffers(window)
end


## prompt_template.txt를 바탕으로
## prompt_with_original.jsonl 파일을 생성하는 스크립트

import json
import os
import pandas as pd

# 입력 파일 경로
TEMPLATE_PATH = 'outputs/prompt/prompt_template.txt'
ORIGINAL_DATA_PATH = 'outputs/errors/low_confidence_300.csv'
OUTPUT_PATH = 'outputs/prompt/prompts_with_original.jsonl'

def main():
    # 프롬프트 템플릿 읽기
    with open(TEMPLATE_PATH, 'r', encoding='utf-8') as f:
        template = f.read()

    # original_data.json 읽기
    df = pd.read_csv(ORIGINAL_DATA_PATH)

    # 출력 디렉토리 생성
    os.makedirs(os.path.dirname(OUTPUT_PATH), exist_ok=True)

    # 각 샘플에 대해 프롬프트 생성 및 저장
    with open(OUTPUT_PATH, 'w', encoding='utf-8') as fout:
        for _, row in df.iterrows():
            original_id = row['Unnamed: 0']
            original_text = str(row['text'])
            prompt = template.replace('{original_text}', original_text)
            out = {
                'original_id': original_id,
                'original_text': original_text,
                'prompt': prompt
            }
            fout.write(json.dumps(out, ensure_ascii=False) + '\n')
    print(f'프롬프트 300개가 {OUTPUT_PATH}에 저장되었습니다.')

    # original_id, original_text만 추출해서 json 저장
    minimal_list = []
    with open(OUTPUT_PATH, 'r', encoding='utf-8') as fin:
        for line in fin:
            item = json.loads(line)
            minimal_list.append({
                'original_id': item['original_id'],
                'original_text': item['original_text']
            })
    minimal_output_path = 'outputs/errors/low_confidence_300.json'
    with open(minimal_output_path, 'w', encoding='utf-8') as fout:
        json.dump(minimal_list, fout, ensure_ascii=False, indent=2)
    print(f'original_id, original_text만 저장된 파일이 {minimal_output_path}에 저장되었습니다.')

    print(df.columns)

if __name__ == '__main__':
    main()


"] = "黑暗教士貝里爾",
    ["Apothecary Johaan"] = "藥劑師喬漢",
    ["Deathguard Dillinger"] = "亡靈守衛迪林格爾",
    ["Junior Apothecary Holland"] = "初級藥劑師霍蘭德",
    ["Magistrate Sevren"] = "執政官塞弗倫",
    ["Deathguard Burgess"] = "亡靈守衛伯吉斯",
    ["Coleman Farthing"] = "庫勒曼·法席恩",
    ["Captured Scarlet Zealot"] = "被俘虜的血色狂熱者",
    ["Gretchen Dedmar"] = "格雷森·戴德瑪",
    ["Gregor Agamand"] = "格里高·阿加曼德",
    ["Thurman Agamand"] = "薩爾曼·阿加曼德",
    ["Yvette Farthing"] = "伊維特·法席恩",
    ["Austil de Mon"] = "奧斯蒂爾·德·蒙",
    ["Cain Firesong"] = "凱恩·火歌",
    ["Ageron Kargal"] = "埃格隆·卡加爾",
    ["Marion Call"] = "馬里恩·考爾",
    ["Carendin Halgar"] = "凱倫丁·哈加爾",
    ["Mennet Carkad"] = "米奈特·卡加德",
    ["Bethor Iceshard"] = "比索·埃斯沙德",
    ["Astor Hadren"] = "阿斯托·哈德恩",
    ["Deathguard Linnea"] = "亡靈守衛林奈",
    ["Captured Mountaineer"] = "被俘虜的巡山人",
    ["Andron Gant"] = "安德隆·甘特",
    ["Gunther Arcanus"] = "岡瑟爾·阿坎努斯",
    ["Aelthalyste"] = "艾薩萊斯特",
    ["Gorefang"] = "血牙狼人",
    ["Deathstalker Erland"] = "亡靈哨兵埃蘭德",
    ["Rane Yorick"] = "蘭妮·尤瑞克",
    ["Dalar Dawnweaver"] = "達拉爾·織曦者",
    ["Shadow Priest Allister"] = "暗影牧師奧利斯特",
    ["Deathguard Podrig"] = "亡靈守衛博迪瑞格",
    ["High Executor Hadrec"] = "高階執行官哈德瑞克",
    ["Apothecary Renferrel"] = "藥劑師倫弗利爾",
    ["Son of Arugal"] = "阿魯高之子",
    ["Quinn Yorick"] = "奎恩·尤瑞克",
    ["Nightlash"] = "奈塔拉什",
    ["Krethis Shadowspinner"] = "『旋影者』克雷希斯",
    ["Gordon Wendham"] = "高頓·溫德哈姆",
    ["Young Scavenger"] = "小食腐狼",
    ["Duskbat"] = "夜行蝙蝠",
    ["Rattlecage Skeleton"] = "斷骨骷髏",
    ["Mindless Zombie"] = "無腦的殭屍",


d)
    } catch (e) {
      await client.emit('interactionError', e)
    }
  }

  addEventListener('fetch', cb as unknown as EventListener)
}

/**
 * Register Slash Command handler.
 *
 * Example:
 *
 * ```ts
 * handle("ping", (interaction) => {
 *   interaction.reply("Pong!")
 * })
 * ```
 *
 * Also supports Sub Command and Group handling out of the box!
 * ```ts
 * handle("command-name group-name sub-command", (i) => {
 *   // ...
 * })
 *
 * handle("command-name sub-command", (i) => {
 *   // ...
 * })
 * ```
 *
 * @param cmd Command to handle. Either Handler object or command name followed by handler function in next parameter.
 * @param handler Handler function (required if previous argument was command name)
 */
export function handle(
  cmd: string | ApplicationCommandHandler,
  handler?: ApplicationCommandHandlerCallback,
  type?: ApplicationCommandType | keyof typeof ApplicationCommandType
): void {
  if (client === undefined)
    throw new Error('Slash Client not initialized. Call `init` first')
  client.handle(cmd, handler, type)
}

/** Listen for Interactions Event */
export function interactions(
  cb: (i: Interaction) => unknown | Promise<unknown>
): void {
  client.on('interaction', cb)
}

export { commands, client }
export * from './src/types/applicationCommand.ts'
export * from './src/types/interactions.ts'
export * from './src/structures/applicationCommand.ts'
export * from './src/interactions/mod.ts'
export * from './src/types/channel.ts'
export * from './src/structures/interactions.ts'
export * from './src/structures/message.ts'
export * from './src/structures/embed.ts'
export * from './src/types/messageComponents.ts'
import { suite, test } from "mocha-typescript";
import { expect } from "chai";
import { DataType } from "../src/datatype";

const EXAMPLE_TAG = "example";

class ExampleType extends DataType {
  tag(): string {
    return EXAMPLE_TAG;
  }
}

@suite class DataTypeTest {
  @test "registering data types"() {
    expect(() => DataType.get(EXAMPLE_TAG)).to.throw(Error);
    DataType.register(new ExampleType);
    expect(DataType.get(EXAMPLE_TAG)).to.be.a.instanceOf(ExampleType);
  }
}
import { ISpike } from '../src-feed-reader/interfaces';

let _bootData: ISpike;

export function getBootSpikeData(url: string) {
    if (_bootData && _bootData.spikeShortName === url) {
        return _bootData;
    }
    return undefined;
}

export function setBootSpikeData(bootSpikeData: ISpike) {
    _bootData = bootSpikeData;
}

export async function getSpikeDataBrowser(spikeName: string) {
    const jsonRequired = (spikeName || 'home') + '.json';
    const response = await fetch(jsonRequired);
    const contentType = response.headers.get('content-type');
    if (contentType && contentType.includes('application/json')) {
        const json: ISpike = await response.json();
        return json;
    }
    throw new TypeError(`Oops, we haven't got JSON from ${jsonRequired}!`);
}
//-----------------------------------------------------------------------------
// simple property change logger example
//-----------------------------------------------------------------------------

function Log() {
  return function(target: Object, key: string | symbol) {
    let val = (<any>target)[key];

    const getter = () => {
      return val;
    };

    const setter = (next: any) => {
      console.log(`${String(key)}: old value ${val}, next value ${next}`);
      val


个序列。序列不过是按顺序排列的事件。换句话说，⍺[1] -> ⍺[2] -> ⍺[3] -> ⍺[4] 可以被称作事件序列。例如，(牛奶，奶酪) -> (面包，鸡蛋) -> (奶酪，面包，糖) -> (牛奶，面包) 是一个事务序列。这意味着在第一个事务中，购买了牛奶和奶酪。在随后的交易中，购买了面包和鸡蛋，依此类推。

包含 *k* 项的序列是一个 k-项序列。例如，序列（牛奶，面包）-> （鸡蛋）包含三个项。现在让我们一步一步地探索 SPADE 算法。

假设我们生成了以下序列。在第一个序列中，ID 1001，在第一个交易中就购买了牛奶。在第二个序列中，购买了牛奶、鸡蛋和面包。随后又购买了牛奶和面包。在第四个序列中，只购买了糖。在序列 1001 的最后一个交易中，购买了面包和苹果；这适用于所有相应的序列。例如，在序列 ID 1001 中，我们有多个事件。在第一次购买中，购买了牛奶。然后购买了（牛奶，鸡蛋，面包）等等。参见表 4.13。

##### 表 4.13 序列挖掘的数据集

| 序列 ID | 序列 |
| --- | --- |
| 1001  | <(牛奶) (牛奶，鸡蛋，面包) (牛奶，面包) (糖) (面包，苹果)>  |
| 1002  | <(牛奶，糖) (面包) (鸡蛋，面包) (牛奶，奶酪)>  |
| 1003  | <(奶酪，苹果) (牛奶，鸡蛋) (糖，苹果) (面包) (鸡蛋)>  |
| 1004  | <(奶酪，香蕉) (牛奶，苹果) (面包) (鸡蛋) (面包)>  |

表 4.13 可以转换为如图表 4.14 所示的垂直数据格式。在这一步中，我们计算了一序列项的频率，这些是一序列项只有一项的序列。为此，只需要进行一次数据库扫描。我们只需为每个项目有序列 ID 和元素 ID。

##### 表 4.14 表 4.13 的垂直格式

| 序列 ID | 元素 ID | 项目 |
| --- | --- | --- |
| 1001  | 1  | 牛奶  |
| 1001  | 2  | 牛奶，鸡蛋，面包  |
| 1001  | 3  | 牛奶，面包  |
| 1001  |


.annotations.Controller
      import dev.buijs.klutter.annotations.Event

      @Controller
      class Greeting {

          @Event(name = "greeting")
          fun greeting(): String {
             return "Hello, ${Platform().platform}!"
          }

      }"""
          .replaceAll(" ", ""),
      commonGreetingClass.readAsStringSync().replaceAll(" ", ""),
    );

    final commonPlatformClass =
        File("${commonMain.path}/Platform.kt".normalize);

    expect(
      true,
      commonPlatformClass.existsSync(),
      reason:
          "root/klutter/nigulp/src/commonMain/kotlin/com/organisation/nigulp/platform/Platform.kt should be created",
    );

    expect(
      """
      package com.organisation.nigulp.platform

      expect class Platform() {
          val platform: String
      }"""
          .replaceAll(" ", ""),
      commonPlatformClass.readAsStringSync().replaceAll(" ", ""),
    );

    final iosPlatformClass = File("${iosMain.path}/Platform.kt".normalize);

    expect(
      true,
      iosPlatformClass.existsSync(),
      reason:
          "root/klutter/nigulp/src/iosMain/kotlin/com/organisation/nigulp/platform/Platform.kt should be created",
    );

    expect(
      """
      package com.organisation.nigulp.platform

      import platform.UIKit.UIDevice

      actual class Platform actual constructor() {
          actual val platform: String = UIDevice.currentDevice.systemName() + " " + UIDevice.currentDevice.systemVersion
      }
      """
          .replaceAll(" ", ""),
      iosPlatformClass.readAsStringSync().replaceAll(" ", ""),
    );

    root.deleteSync(recursive: true);
  });
}
// Copyright (c) 2021 - 2023 Buijs Software
//
// 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.

import "dart:io";

import "../common/utilities.dart";

/// Utility to copy Files from lib/res folder to project.
extension ResourceCopy on Directory {
  /// Copy a File from lib/res folder to a project folder.
  void copyFiles(List<LocalResource> resources) {
    for (final resource in resources) {
      final from = File(resource.pathToSource.normalize)..verifyFileExists;
      final pathTo =
          Directory("$absolutePath/${resource.targetRelativeToRoot}".normalize)
            ..maybeCreate
            ..verifyDirectoryExists;
      final to = pathTo.resolveFile(resource.filename);
      from.copySync(to.absolutePath);
      Process.runSync("ch


6.02 6.02 0 0114 37.659V41c0 .35-.06.687-.17 1H42v-6c0-5.417-11.992-7-18-7a47.23 47.23 0 00-6 .414V35h-.803ZM24 36a19.02 19.02 0 01-4-.43V31.2c1.467-.138 2.848-.2 4-.2 1.666 0 3.809.129 6 .432V35c-.013.005-2.51 1-6 1Zm10.703-3.608c-.552-.158-1.122-.3-1.703-.429V35h2a1 1 0 011 1v4h4v-4c0-.506-.248-1.092-1.165-1.777-.94-.702-2.363-1.325-4.132-1.831Z" clip-rule="evenodd"/><path d="M8 25a1 1 0 10-2 0v7a4 4 0 004 4v5a1 1 0 102 0v-5a4 4 0 004-4v-7a1 1 0 10-2 0v7a2 2 0 01-2 2v-9a1 1 0 10-2 0v9a2 2 0 01-2-2v-7Z"/></g></svg>';
  static const String agriculture_worker_alt =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48" height="48" preserveAspectRatio="xMidYMid meet" viewBox="0 0 48 48"><g fill="currentColor"><path d="M19.5 13a3.5 3.5 0 110-7 3.5 3.5 0 010 7Z"/><path fill-rule="evenodd" d="M32 16c.364 0 .706.097 1 .268V15h-1a3 3 0 01-3-3V6h2v6a1 1 0 001 1h1V6h2v7h1a1 1 0 001-1V6h2v6a3 3 0 01-3 3h-1v26a1 1 0 11-2 0V19.732A1.99 1.99 0 0132 20h-7v20a2 2 0 11-4 0v-9h-3v9a2 2 0 11-4 0V27.917A6.002 6.002 0 0115 16h17Zm-20 6a2 2 0 012-2v4a2 2 0 01-2-2Z" clip-rule="evenodd"/></g></svg>';
  static const String agriculture_worker_alt_negative =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48" height="48" preserveAspectRatio="xMidYMid meet" viewBox="0 0 48 48"><path fill="currentColor" fill-rule="evenodd" d="M48 0H0v48h48V0ZM19.5 13a3.5 3.5 0 110-7 3.5 3.5 0 010 7ZM32 16c.364 0 .706.097 1 .268V15h-1a3 3 0 01-3-3V6h2v6a1 1 0 001 1h1V6h2v7h1a1 1 0 001-1V6h2v6a3 3 0 01-3 3h-1v26a1 1 0 11-2 0V19.732A1.99 1.99 0 0132 20h-7v20a2 2 0 11-4 0v-9h-3v9a2 2 0 11-4 0V27.917A6.002 6.002 0 0115 16h17Zm-20 6a2 2 0 012-2v4a2 2 0 01-2-2Z" clip-rule="evenodd"/></svg>';
  static const String agriculture_worker_alt_outline =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink


", 'ი': "i", 'კ': "k'",
	'ლ': "l", 'მ': "m", 'ნ': "n", 'ო': "o", 'პ': "p'",
	'ჟ': "zh", 'რ': "r", 'ს': "s", 'ტ': "t'", 'უ': "u",
	'ფ': "p", 'ქ': "k", 'ღ': "gh", 'ყ': "q'", 'შ': "sh",
	'ჩ': "ch", 'ც': "ts", 'ძ': "dz", 'წ': "ts'", 'ჭ': "ch'",
	'ხ': "kh", 'ჯ': "j", 'ჰ': "h",
}

// Define the mapping of Hindi characters to Latin characters
var HindiReplacements = map[string]string{
	"क": "k", "ख": "kh", "ग": "ga", "घ": "gh", "ङ": "ng",
	"च": "ch", "छ": "chh", "ज": "j", "झ": "jh", "ञ": "ny",
	"ट": "t", "ठ": "th", "ड": "d", "ढ": "dh", "ण": "n",
	"त": "t", "थ": "th", "द": "d", "ध": "dh", "न": "n",
	"प": "p", "फ": "f", "ब": "b", "भ": "bh", "म": "m",
	"य": "y", "र": "r", "ल": "l", "व": "v", "श": "sh",
	"ष": "s", "स": "s", "ह": "h", "क़": "k", "ख़": "kh",
	"ग़": "g", "ऩ": "n", "ड़": "d", "ढ़": "rh",
	"ऱ": "r", "य़": "ye", "ळ": "l", "ऴ": "ll", "फ़": "f",
	"ज़": "z", "ऋ": "ri", "ा": "aa", "ि": "i", "ी": "i",
	"ु": "u", "ू": "u", "ॅ": "e", "ॆ": "e", "े": "e",
	"ै": "ai", "ॉ": "o", "ॊ": "o", "ो": "o", "ौ": "au",
	"अ": "a", "आ": "aa", "इ": "i", "ई": "ee", "उ": "u",
	"ऊ": "oo", "ए": "e", "ऐ": "ai", "ऑ": "au", "ओ": "o",
	"औ": "au", "ँ": "n", "ं": "n", "ः": "ah", "़": "e",
	"्": "", "०": "0", "१": "1", "२": "2", "३": "3",
	"४": "4", "५": "5", "६": "6", "७": "7", "८": "8",
	"९": "9", "।": ".", "ऍ": "e", "ृ": "ri", "ॄ": "rr",
	"ॠ": "r", "ऌ": "l", "ॣ": "l", "ॢ": "l", "ॡ": "l",
	"ॿ": "b", "ॾ": "d", "ॽ": "", "ॼ": "j", "ॻ": "g",
	"ॐ": "om", "ऽ": "'", "e.a": "a", "\n": "\n",
}

// This is the map that contains how greek characters ar


544d13,
	#4f4912,
	#4a4411,
	#453f10,
	#403b0f,
	#3a360e,
	#35310c,
	#302d0b,
	#2b280a,
	#262309,
	#211f08
);

// Palette: amber
$palette-amber-0: #ffffff;
$palette-amber-25: #fffaed;
$palette-amber-50: #fff6db;
$palette-amber-75: #fff1c9;
$palette-amber-100: #ffedb7;
$palette-amber-125: #ffe8a5;
$palette-amber-150: #ffe493;
$palette-amber-175: #ffdf81;
$palette-amber-200: #ffdb6f;
$palette-amber-225: #ffd65d;
$palette-amber-250: #ffd24b;
$palette-amber-275: #ffcd39;
$palette-amber-300: #ffc927;
$palette-amber-325: #fdc317;
$palette-amber-350: #fbbe07;
$palette-amber-375: #ebb206;
$palette-amber-400: #dba606;
$palette-amber-425: #cb9906;
$palette-amber-450: #bb8d05;
$palette-amber-475: #aa8105;
$palette-amber-500: #9a7504;
$palette-amber-525: #947004;
$palette-amber-550: #8e6c04;
$palette-amber-575: #886704;
$palette-amber-600: #826204;
$palette-amber-625: #7c5e03;
$palette-amber-650: #765903;
$palette-amber-675: #705503;
$palette-amber-700: #6a5003;
$palette-amber-725: #644c03;
$palette-amber-750: #5e4703;
$palette-amber-775: #584202;
$palette-amber-800: #523e02;
$palette-amber-825: #4c3902;
$palette-amber-850: #453502;
$palette-amber-875: #3f3002;
$palette-amber-900: #392b02;
$palette-amber-925: #332701;
$palette-amber-950: #2d2201;
$palette-amber-975: #271e01;
$palette-amber-1000: #211901;
$palette-amber: (
	#ffffff,
	#fffaed,
	#fff6db,
	#fff1c9,
	#ffedb7,
	#ffe8a5,
	#ffe493,
	#ffdf81,
	#ffdb6f,
	#ffd65d,
	#ffd24b,
	#ffcd39,
	#ffc927,
	#fdc317,
	#fbbe07,
	#ebb206,
	#dba606,
	#cb9906,
	#bb8d05,
	#aa8105,
	#9a7504,
	#947004,
	#8e6c04,
	#886704,
	#826204,
	#7c5e03,
	#765903,
	#705503,
	#6a5003,
	#644c03,
	#5e4703,
	#584202,
	#523e02,
	#4c3902,
	#453502,
	#3f3002,
	#392b02,
	#332701,
	#2d2201,
	#271e01,
	#211901
);

// Palette: orange
$palette-orange-0: #ffffff;
$


import os

PATHS = [
    # | Local Binaries
    # | Revit
    'C:\\Program Files\\Autodesk\\Revit 2017',
    'C:\\Program Files\\Autodesk\\Revit 2017\\en-US',
    # | Tekla Structures
    'C:\\Program Files\\Tekla Structures\\2017\\nt\\bin\\plugins',
    # | Dynamo
    'C:\\Program Files\\Dynamo\Dynamo Core\\1.2',
    'C:\\Program Files\\Dynamo\Dynamo Core\\1.3',
    'C:\\Program Files\\Dynamo\Dynamo Revit\\1.2\\Revit_2017',
    'C:\\Program Files\\Dynamo\Dynamo Revit\\1.3\\Revit_2017',
    # | Rhino
    'C:\\Program Files\\Rhinoceros 5 (64-bit)\\System',
    # Grasshopper
    'C:\\Users\\gtalarico\\AppData\\Roaming\\McNeel\\Rhinoceros\\5.0\\Plug-ins\\Grasshopper (b45a29b1-4343-4035-989e-044e8580d9cf)\\0.9.76.0'
    ]

ASSEMBLIES = [
    # | Ironpython
    'IronPython.Wpf',
    # | Windows
    'PresentationCore',
    'PresentationFramework',
    'WindowsBase',
    # | System
    'System',
    'System.Drawing',
    'System.Windows.Forms',
    # | Dynamo
    'ProtoGeometry',
    'DSCoreNodes',
    'DSOffice',
    'Tessellation',
    # | Rhino
    'Rhino3dmIO',
    'RhinoCommon',
    # | Grasshopper
    'Grasshopper',
    'GH_IO',
    # 'GH_Util',
    # | Tekla Structures
    'Tekla.Structures',
    'Tekla.Structures.Drawing',
    'Tekla.Structures.Model',
    'Tekla.Structures.Plugins',
    ]

BUILTINS = [
    'clr',
    'wpf'
    ]

ASSEMBLIES.extend(BUILTINS)
ASSEMBLIES.sort()

REVIT_ASSEMBLIES = [
    # | Revit
    'RevitAPI',
    'RevitAPIUI',
    'RevitServices',
    'RevitNodes',
    ]

# | If running inside Revit, Process Revit Assemblies Only
try:
    __revit__
except NameError:
    pass
else:
    ASSEMBLIES = REVIT_ASSEMBLIES


n download_metadata() -> Result<()> {
        let names = BasisSetExchange::request_names().await?;
        let json_path = data_path(JSON_BASIS_DICT)?;
        let bincode_path = data_path(BINCODE_BASIS_DICT)?;
        let f = BufWriter::new(File::create(&json_path).unwrap());
        serde_json::to_writer(f, &names)?;
        let mut f = BufWriter::new(File::create(&bincode_path).unwrap());
        serialize_into(&mut f, &names)?;
        Ok(())
    }

    fn read_names() -> Result<BTreeMap<String, String>> {
        let path = data_path(BINCODE_BASIS_DICT)?;
        let data = fs::read(&path).context("Unable to read file")?;
        bincode::deserialize(&data).context("Could not deserialize basis set names")
    }

    pub fn read_basis(name: &str) -> Result<InputData> {
        ensure_data_exist()?;
        let names = BasisSetExchange::read_names()?;
        let basis = names
            .get(&name.to_lowercase())
            .context("The basis set could not be found")?;
        let path = data_path(&format!("{}{}", BASIS_SUBDIRECTORY, basis))?;
        let data = fs::read_to_string(&path).context("Unable to read basis set file")?;
        let result = serde_json::from_str::<InputData>(&data)?;
        Ok(result)
    }
}
<gh_stars>0
mod console;

use std::io;
use console::{Console, Cursor};

//set all of the colours used by the program
const COLOR_P1: u8 = 196; //red
const COLOR_P2: u8 = 27; //blue

//the dimensions of the board
const WIDTH: usize = 7;
const HEIGHT: usize = 6;

#[derive(Copy, Clone, PartialEq)]
enum Cell {
    Unset,
    P1,
    P2,
}

fn main() {

    // SETUP
    Console::clear();
    Cursor::go_home();

    println!("The game is now setting up");

    let mut board = [[Cell::Unset; WIDTH]; HEIGHT];

    let mut turn: u8 = 0;

    println!("The game is now starting");

    loop {
        // DRAW
        //Console::clear();
        Cursor::go_to(0, 1);

        // Print the numbers above the board
        // for easier user input
        let numbers = "1234567890";
        print!("{}\n\n", &numbers[..(WIDTH - 1)]);

        for y in 0..WIDTH {
            for x in 0..HEIGHT {

                match &board[x][y] {
                    Cell::Unset => {Console::reset_color();},
                    Cell::P1 => {Console::set_fg_color(COLOR_P1);},
                    Cell::P2 => {Console::set_fg_color(COLOR_P2);},
                }

                print!("O");
            }
            println!()
        }

        Console::reset_color();

        println!();

        // INPUT
        loop {
            let current_player = turn % 2;

            println!("Player {}, input x coord", current_player + 1);
            println!("Numbers above the WIDTH will be wrapped around");

            let mut input = String::new();
            let input_cell: usize;
            loop {
                if io::stdin().read_line(&mut input).is_err() {
                    continue
                }

                let input = &input[..1];

                if let Ok(data) = input.parse::<usize>() {
                    input_cell = data - 1;
                    break;
                }
            }
            print!("{}", input_cell);

            let mut board_min = HE


G_ENDIAN
    REVERSE32(major, major);
    REVERSE32(minor, minor);
#endif

    memcpy(data + sizeof(prefix) + sizeof(buff), &major, sizeof(uint32_t));
    memcpy(data + sizeof(prefix) + sizeof(buff) + sizeof(uint32_t), &minor, sizeof(uint32_t));

    xmr_hash_to_scalar(r, data, sizeof(data));
}

void xmr_gen_c(ge25519* r, const bignum256modm a, uint64_t amount) {
    // C = aG + bH
    bignum256modm b = {0};
    set256_modm(b, amount);
    xmr_add_keys2(r, a, b, &xmr_h);
}

#endif // USE_MONERO


 .unreq          TMP2
    .unreq          TMP3
    .unreq          TMP4
    .unreq          TMP5
    .unreq          TMP6
    .unreq          TMP7
    .unreq          TMP8

#undef CENTERJSAMPLE
#undef CONST_BITS
#undef PASS1_BITS
#undef XFIX_P_0_298
#undef XFIX_N_0_390
#undef XFIX_P_0_541
#undef XFIX_P_0_765
#undef XFIX_N_0_899
#undef XFIX_P_1_175
#undef XFIX_P_1_501
#undef XFIX_N_1_847
#undef XFIX_N_1_961
#undef XFIX_P_2_053
#undef XFIX_N_2_562
#undef XFIX_P_3_072

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

/*
 * jsimd_idct_ifast_neon
 *
 * This function contains a fast, not so accurate integer implementation of
 * the inverse DCT (Discrete Cosine Transform). It uses the same calculations
 * and produces exactly the same output as IJG's original 'jpeg_idct_ifast'
 * function from jidctfst.c
 *
 * Normally 1-D AAN DCT needs 5 multiplications and 29 additions.
 * But in ARM NEON case some extra additions are required because VQDMULH
 * instruction can't handle the constants larger than 1. So the expressions
 * like "x * 1.082392200" have to be converted to "x * 0.082392200 + x",
 * which introduces an extra addition. Overall, there are 6 extra additions
 * per 1-D IDCT pass, totalling to 5 VQDMULH and 35 VADD/VSUB instructions.
 */

#define XFIX_1_082392200 v0.h[0]
#define XFIX_1_414213562 v0.h[1]
#define XFIX_1_847759065 v0.h[2]
#define XFIX_2_613125930 v0.h[3]

.balign 16
Ljsimd_idct_ifast_neon_consts:
  .short (277 * 128 - 256 * 128)  /* XFIX_1_082392200 */
  .short (362 * 128 - 256 * 128)  /* XFIX_1_414213562 */
  .short (473 * 128 - 256 * 128)  /* XFIX_1_847759065 */
  .short (669 * 128 - 512 * 128)  /* XFIX_2_613125930 */

asm_function jsimd_idct_ifast_neon

    DCT_TABLE       .req x0
    COEF_BLOCK      .req x1
    OUTPUT_BUF      .req x2
    OUTPUT_COL      .req x3
    TMP1            .req x0
    TMP2            .req x1
    TMP3            .req x9
    TMP4            .req x10
    TMP5            .req x11
    TMP6            .req x12
    TMP7            .req x13
    TMP8            .req x14

    /* Load and dequantize coefficients into NEON registers
     * with the following allocation:
     *       0 1 2 3 | 4 5 6 7
     *      ---------+--------
     *   0 | d16     | d17     ( v16.8h )
     *   1 | d18     | d19     ( v17.8h )
     *   2 | d20     | d21     ( v18.8h )
     *   3 | d22     | d23


 {}
  std::shared_ptr<TcpCallTracer> StartNewTcpTrace() override { return nullptr; }
  void RecordAnnotation(absl::string_view annotation) override {}
  void RecordAnnotation(const Annotation& annotation) override {}
  std::string TraceId() override { return ""; }
  std::string SpanId() override { return ""; }
  bool IsSampled() override { return false; }
};

}  // namespace grpc_core

////////////////////////////////////////////////////////////////////////////////
// HPACK encoder
//

static void BM_HpackEncoderInitDestroy(benchmark::State& state) {
  grpc_core::ExecCtx exec_ctx;
  for (auto _ : state) {
    grpc_core::HPackCompressor c;
    grpc_core::ExecCtx::Get()->Flush();
  }
}
BENCHMARK(BM_HpackEncoderInitDestroy);

static void BM_HpackEncoderEncodeDeadline(benchmark::State& state) {
  grpc_core::ExecCtx exec_ctx;
  grpc_core::Timestamp saved_now = grpc_core::Timestamp::Now();

  grpc_core::MemoryAllocator memory_allocator =
      grpc_core::MemoryAllocator(grpc_core::ResourceQuota::Default()
                                     ->memory_quota()
                                     ->CreateMemoryAllocator("test"));
  grpc_metadata_batch b;
  b.Set(grpc_core::GrpcTimeoutMetadata(),
        saved_now + grpc_core::Duration::Seconds(30));

  grpc_core::HPackCompressor c;
  grpc_core::FakeCallTracer call_tracer;
  grpc_slice_buffer outbuf;
  grpc_slice_buffer_init(&outbuf);
  while (state.KeepRunning()) {
    c.EncodeHeaders(
        grpc_core::HPackCompressor::EncodeHeaderOptions{
            static_cast<uint32_t>(state.iterations()), true, false,
            size_t{1024}, &call_tracer, grpc_core::ztrace_collector},
        b, &outbuf);
    grpc_slice_buffer_reset_and_unref(&outbuf);
    grpc_core::ExecCtx::Get()->Flush();
  }
  grpc_slice_buffer_destroy(&outbuf);
}
BENCHMARK(BM_HpackEncoderEncodeDeadline);

template <class Fixture>
static void BM_HpackEncoderEncodeHeader(benchmark::State& state) {
  grpc_core::ExecCtx exec_ctx;
  static bool logged_representative_output = false;

  grpc_metadata_batch b;
  Fixture::Prepare(&b);

  grpc_core::HPackCompressor c;
  grpc_core::FakeCallTracer call_tracer;
  grpc_slice_buffer outbuf;
  grpc_slice_buffer_init(&outbuf);
  while (state.KeepRunning()) {
    static constexpr int kEnsureMaxFrameAtLeast = 2;
    c.EncodeHeaders(
        grpc_core::HPackCompressor::EncodeHeaderOptions{
            static_cast<uint32_t>(state.iterations()), state.range(0) != 0,
            Fixture::kEnableTrueBinary,
            static_cast<size_t>(state.range(1) + kEnsureMaxFrameAtLeast),
            &call_tracer, grpc_core::ztrace_collector},
        b, &outbuf);
    if (!logged_representative_output && state.iterations() > 3) {
      logged_representative_output = true;
      for (size_t i = 0; i < outbuf.count; i++) {
        char* s = grpc_dump_slice(outbuf.slices[i], GPR_DUMP_HEX);
        VLOG(2) << i << ": " << s;
        gpr_free(s);
      }
    }
    grpc_slice_buffer_reset_and_unref(&outbuf);
    grpc_core::ExecCtx::Get()->Flush();
  }
  grpc_slice_buffer_destroy(&outbuf);
}

namespace hpack_encoder_fixtures {

class EmptyB


.item.skills.splice(indx, 1)
      this.parent.saveCharacter()
    }
    this.cancel()
  }

  copy(attr: Skill) {
    this.item.skills.push(attr)
    this.parent.saveCharacter()
    this.showdialog = attr
  }

  derive(attr: Skill) {
    this.item.skills.push(attr)
    this.parent.saveCharacter()
    this.showdialog = attr
  }
}

export interface SkillOptions {

  sortBy : 'name' | 'rank' | 'ability'
}import { dialog } from '@electron/remote';
import path from 'path';
import { ErrorLog, OperationLog } from '../../Functions/log';
import focusingPath from '../../Functions/focusingPath';
import { createFile, exists, mkdirRecursively } from '../../Functions/fileSystem';

/**
 * Create a new file
 * @param {string} fileName - name for the new file
 * @param {string} parentDir - parent directory of the new file
 * @returns {void}
 */
const NewFile = async (
	fileName: string,
	parentDir: string = focusingPath()
): Promise<void> => {
	const newFileName = path.join(parentDir, fileName);
	const fileExists = await exists(newFileName);

	if (fileExists) {
		await dialog.showMessageBox({
			message: 'A file with that name already exists.',
			type: 'error',
		});
	} else {
		try {
			await mkdirRecursively(path.join(parentDir));
			await createFile(newFileName);
		} catch (err) {
			await dialog.showMessageBox({
				message: 'Error creating file. Please try again.',
				type: 'error',
			});
			ErrorLog(err);
		}

		OperationLog('newfile', null, path.join(parentDir, fileName));
	}
};

export default NewFile;
/**
 * `noa.container` - manages the game's HTML container element, canvas,
 * fullscreen, pointerLock, and so on.
 *
 * This module wraps `micro-game-shell`, which does most of the implementation.
 *
 * @emits DOMready
 * @emits gainedPointerLock
 * @emits lostPointerLock
 */
export class Container extends EventEmitter {
    /** @internal @prop _noa */
    /** @internal @prop _shell */
    /** The game's DOM element container
     * @prop element
    */
    /** The `canvas` element that the game will draw into
     * @prop canvas
    */
    /** Whether the browser supports pointerLock. Read-only!
     * @prop supportsPointerLock
    */
    /** Whether the user's pointer is within the game area. Read-only!
     * @prop pointerInGame
    */
    /** Whether the game is focused. Read-only!
     * @prop isFocused
    */
    /** Gets the current state of pointerLock. Read-only!
     * @prop hasPointerLock
    */
    /** @internal */
    constructor(noa: any, opts: any);
    _noa: any;
    element: any;
    canvas: any;
    _shell: any;
    supportsPointerLock: boolean;
    pointerInGame: boolean;
    isFocused: boolean;
    hasPointerLock: boolean;
    /** @internal */
    appendTo(htmlElement: any): void;
    /**
     * Sets whether `noa` should try to acquire or release pointerLock
    */
    setPointerLock(lock?: boolean): void;
}
import { EventEmitter } from "events";
class Player {
    public body: Matter.Body;
    private impulseForceX: number = 0.005;
    private impulseForceY: number = 0.021;
    private maxVelocityX: number = 3;
    private impulsePositionX: number = 4;

    private maxAmountOfConsecutiveJumps = 2; // Player can only jump 2 times consecutively. This resets after touching floor.
    private jumpCounter = 0;

    private isChargingJump: boolean = false;

    private scaleX: number = 1;
    pr


t===e))){a.add(e,"main",{ref:m});v.dispose()}};const v=new d.Launcher({model:c,cwd:u,callback:f,commands:r,translator:t});v.model=c;v.title.icon=p.launcherIcon;v.title.label=l.__("Launcher");const _=new o.MainAreaWidget({content:v});_.title.closable=!!Array.from(a.widgets("main")).length;_.id=m;a.add(_,"main",{activate:e["activate"],ref:e["ref"]});if(n){n.layoutModified.connect((()=>{_.title.closable=Array.from(n.widgets("main")).length>1}),_)}if(s){const e=e=>{v.cwd=e.path};s.model.pathChanged.connect(e);v.disposed.connect((()=>{s.model.pathChanged.disconnect(e)}))}return _}});if(n){void Promise.all([e.restored,s===null||s===void 0?void 0:s.model.restored]).then((()=>{function e(){if(n.isEmpty("main")){void r.execute(v.create)}}n.layoutModified.connect((()=>{e()}))}))}if(i){i.addItem({command:v.create,category:l.__("Launcher")})}if(n){n.addButtonEnabled=true;n.addRequested.connect(((e,t)=>{var n;const i=((n=t.currentTitle)===null||n===void 0?void 0:n.owner.id)||t.titles[t.titles.length-1].owner.id;return r.execute(v.create,{ref:i})}))}return c}var w;(function(e){e.id=0})(w||(w={}))},68149:(e,t,n)=>{"use strict";var i=n(10395);var s=n(40662);var o=n(97913);var r=n(3579);var a=n(39063);var l=n(75797);var d=n(85072);var c=n.n(d);var h=n(97825);var u=n.n(h);var p=n(77659);var m=n.n(p);var g=n(55056);var f=n.n(g);var v=n(10540);var _=n.n(v);var b=n(41113);var y=n.n(b);var w=n(41782);var C={};C.styleTagTransform=y();C.setAttributes=f();C.insert=m().bind(null,"head");C.domAPI=u();C.insertStyleElement=_();var x=c()(w.A,C);const S=w.A&&w.A.locals?w.A.locals:undefined},70322:(e,t,n)=>{"use strict";n.r(t);n.d(t,{ILauncher:()=>s,Launcher:()=>g,LauncherModel:()=>m});var i=n(5592);const s=new i.Token("@jupyterlab/launcher:ILauncher",`A service for the application activity launcher.\n  Use this to add your extension activities to the launcher panel.`);var o=n(48287);var r=n(21760);var a=n(78464);var l=n(34236);var d=n(90044);var c=n(94466);var h=n(1143);var u=n(44914);const p="jp-Launcher";class m extends a.VDomModel{constructor(){super(...arguments);this.itemsList=[]}add(e){const t=v.createItem(e);this.itemsList.push(t);this.stateChanged.emit(void 0);return new d.DisposableDelegate((()=>{l.ArrayExt.removeFirstOf(this.itemsList,t);this.stateChanged.emit(void 0)}))}items(){return this.itemsList[Symbol.iterator]()}}class g extends a.VDomRenderer{constructor(e){super(e.model);this._pending=false;this._cwd="";this._cwd=e.cwd;this.translator=e.translator||r.nullTran


//===--- EnvironmentVariables.h - Debug variables. --------------*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// Debug behavior conditionally enabled using environment variables.
//
//===----------------------------------------------------------------------===//

#include "swift/Threading/Once.h"
#include "swift/shims/Visibility.h"

namespace swift {
namespace runtime {
namespace environment {

void initialize(void *);

extern swift::once_t initializeToken;

// Define a typedef "string" in swift::runtime::environment to make string
// environment variables work
using string = const char *;

// Declare backing variables.
#define VARIABLE(name, type, defaultValue, help)                               \
  extern type name##_variable;                                                 \
  extern bool name##_isSet_variable;
#include "../../../stdlib/public/runtime/EnvironmentVariables.def"

// Define getter functions. This creates one function with the same name as the
// variable which returns the value set for that variable, and second function
// ending in _isSet which returns a boolean indicating whether the variable was
// set at all, to allow detecting when the variable was explicitly set to the
// same value as the default.
#define VARIABLE(name, type, defaultValue, help)                               \
  inline type name() {                                                         \
    swift::once(initializeToken, initialize, nullptr);                         \
    return name##_variable;                                                    \
  }                                                                            \
  inline bool name##_isSet() {                                                 \
    swift::once(initializeToken, initialize, nullptr);                         \
    return name##_isSet_variable;                                              \
  }
#include "../../../stdlib/public/runtime/EnvironmentVariables.def"

// Wrapper around SWIFT_DEBUG_CONCURRENCY_ENABLE_COOPERATIVE_QUEUES that the
// Concurrency library can call.
SWIFT_RUNTIME_STDLIB_SPI bool concurrencyEnableCooperativeQueues();

// Wrapper around SWIFT_DEBUG_VALIDATE_UNCHECKED_CONTINUATIONS that the
// Concurrency library can call.
SWIFT_RUNTIME_STDLIB_SPI bool concurrencyValidateUncheckedContinuations();

// Wrapper around SWIFT_IS_CURRENT_EXECUTOR_LEGACY_MODE_OVERRIDE that the
// Concurrency library can call.
SWIFT_RUNTIME_STDLIB_SPI const char *concurrencyIsCurrentExecutorLegacyModeOverride();

} // end namespace environment
} // end namespace runtime
} // end namespace swift


correctSampleRateFormat = new WaveFormatExtensible(outputFormat.SampleRate, 16, 2);
                            if (!audioClient.IsFormatSupported(shareMode, correctSampleRateFormat))
                            {
                                throw new NotSupportedException("Can't find a supported format to use");
                            }
                        }
                    }
                    outputFormat = correctSampleRateFormat;
                }
                else
                {
                    outputFormat = closestSampleRateFormat;
                }

                // just check that we can make it.
                resamplerDmoStream = new ResamplerDmoStream(waveProvider, outputFormat);
                sourceProvider = resamplerDmoStream;
            }
            else
            {
                sourceProvider = waveProvider;
            }

            // Normal setup for both sharedMode
            var flags = AudioClientStreamFlags.None;
            if (shareMode == AudioClientShareMode.Shared)
                flags = AudioClientStreamFlags.AutoConvertPcm | AudioClientStreamFlags.SrcDefaultQuality;
            audioClient.Initialize(shareMode, flags, latencyRefTimes, 0,
                                    outputFormat, Guid.Empty);

            // Get the RenderClient
            renderClient = audioClient.AudioRenderClient;


;

/**
 * SecureSourceManager request initializer for setting properties like key and userIp.
 *
 *

 * The simplest usage is to use it to set the key parameter:
 *

 *
 *

  public static final GoogleClientRequestInitializer KEY_INITIALIZER =
      new SecureSourceManagerRequestInitializer(KEY);
 *

 *
 *

 * There is also a constructor to set both the key and userIp parameters:
 *

 *
 *

  public static final GoogleClientRequestInitializer INITIALIZER =
      new SecureSourceManagerRequestInitializer(KEY, USER_IP);
 *

 *
 *

 * If you want to implement custom logic, extend it like this:
 *

 *
 *

  public static class MyRequestInitializer extends SecureSourceManagerRequestInitializer {

    {@literal @}Override
    public void initializeSecureSourceManagerRequest(SecureSourceManagerRequest{@literal <}?{@literal >} request)
        throws IOException {
      // custom logic
    }
  }
 *

 *
 *

 * Finally, to set the key and userIp parameters and insert custom logic, extend it like this:
 *

 *
 *

  public static class MyRequestInitializer2 extends SecureSourceManagerRequestInitializer {

    public MyKeyRequestInitializer() {
      super(KEY, USER_IP);
    }

    {@literal @}Override
    public void initializeSecureSourceManagerRequest(SecureSourceManagerRequest{@literal <}?{@literal >} request)
        throws IOException {
      // custom logic
    }
  }
 *

 *
 *

 * Subclasses should be thread-safe.
 *

 *
 * @since 1.12
 */
public class SecureSourceManagerRequestInitializer extends com.google.api.client.googleapis.services.json.CommonGoogleJsonClientRequestInitializer {

  public SecureSourceManagerRequestInitializer() {
    super();
  }

  /**
   * @param key API key or {@code null} to leave it unchanged
   */
  public SecureSourceManagerRequestInitializer(String key) {
    super(key);
  }

  /**
   * @param key API key or {@code null} to leave it unchanged
   * @param userIp user IP or {@code null} to leave it unchanged
   */
  public SecureSourceManagerRequestInitializer(String key, String userIp) {
    super(key, userIp);
  }

  @Override
  public final void initializeJsonRequest(com.google.api.client.googleapis.services.json.AbstractGoogleJsonClientRequest<?> request) throws java.io.IOException {
    super.initializeJsonRequest(request);
    initializeSecureSourceManagerRequest((SecureSourceManagerRequest<?>) request);
  }

  /**
   * Initializes SecureSourceManager request.
   *
   *

   * Default implementation does nothing. Called from
   * {@link #initializeJsonRequest(com.google.api.client.googleapis.services.json.AbstractGoogleJsonClientRequest)}.
   *

   *
   * @throws java.io.IOException I/O exception
   */
  protected void initializeSecureSourceManagerRequest(SecureSourceManagerRequest<?> request) throws java.io.IOException {
  }
}
/*
 * 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.
 */
/*
 * This code was generated by https://github.com/googleapis/google-api-java-client-services/
 * Modify at your own risk.
 */

package com.google.api.services.securesourcemanager.v1.model;


ste_time[1] == curr_date_str:
            today_wastes.append(waste)
    return today_wastes

def wastes_to_string_home(wastes_list: list[Waste]):
    if not wastes_list:
        return [[], []]

    wastes = []
    daily_wastes = []
    daily_wastes_dict = {}
    for waste in wastes_list:
        if waste.type == "usually":
            wastes.append(
                f"{waste.category} — {CURRENCY}{round(waste.sum, 2)}    {waste.time}"
            )
        else:
            if waste.category not in daily_wastes_dict:
                daily_wastes_dict[waste.category] = 0
            daily_wastes_dict[waste.category] += waste.sum

    for category, sum in daily_wastes_dict.items():
        daily_wastes.append(f"{category} — {CURRENCY}{round(sum, 2)}")

    return [wastes, daily_wastes]


      1,
		"SET_OPERATION_REMOVED":     2,
	}
)

func (x PermissionSetChange_SetOperation) Enum() *PermissionSetChange_SetOperation {
	p := new(PermissionSetChange_SetOperation)
	*p = x
	return p
}

func (x PermissionSetChange_SetOperation) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (PermissionSetChange_SetOperation) Descriptor() protoreflect.EnumDescriptor {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_enumTypes[0].Descriptor()
}

func (PermissionSetChange_SetOperation) Type() protoreflect.EnumType {
	return &file_authzed_api_materialize_v0_watchpermissionsets_proto_enumTypes[0]
}

func (x PermissionSetChange_SetOperation) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use PermissionSetChange_SetOperation.Descriptor instead.
func (PermissionSetChange_SetOperation) EnumDescriptor() ([]byte, []int) {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescGZIP(), []int{5, 0}
}

type WatchPermissionSetsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// optional_starting_after is used to specify the SpiceDB revision to start watching from.
	// If not specified, the watch will start from the current SpiceDB revision time of the request ("head revision").
	OptionalStartingAfter *v1.ZedToken `protobuf:"bytes,1,opt,name=optional_starting_after,json=optionalStartingAfter,proto3" json:"optional_starting_after,omitempty"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

func (x *WatchPermissionSetsRequest) Reset() {
	*x = WatchPermissionSetsRequest{}
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WatchPermissionSetsRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*WatchPermissionSetsRequest) ProtoMessage() {}

func (x *WatchPermissionSetsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WatchPermissionSetsRequest.ProtoReflect.Descriptor instead.
func (*WatchPermissionSetsRequest) Descriptor() ([]byte, []int) {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescGZIP(), []int{0}
}

func (x *WatchPermissionSetsRequest) GetOptionalStartingAfter() *v1.ZedToken {
	if x != nil {
		return x.OptionalStartingAfter
	}
	return nil
}

type WatchPermissionSetsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Response:
	//
	//	*WatchPermissionSetsResponse_Change
	//	*WatchPermissionSetsResponse_CompletedRevision
	//	*WatchPermissionSetsResponse_LookupPermissionSetsRequired
	//	*WatchPermissionSetsResponse_BreakingSchemaChange
	Response      isWatchPermissionSetsResponse_Response `protobuf_oneof:"response"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *WatchPermissionSetsResponse) Reset() {
	*x = WatchPermissionSetsResponse{}
	mi


'

例如在拓展Header Editor中，点击添加按钮:

Name: csp-remove(随意)

Rule type: Modify response header

Match type: domain

Match rules: x.com

Execute type: normal

Header name: content-security-policy

Header value: object-src '*'

[脚本的入口或控制栏可以更改位置吗？]

可以！在配置面板的下方，有一个拖拽移动的选项，对着图标进行拖动，你可以将控制栏移动到页面上的任意位置。

[进入对应的页面的，可以自动打开脚本吗？]

可以！在配置面板中，有一个自动打开的选项，启用即可。

[如何缩放图片？]

有几种方式可以在大图阅读模式中缩放图片：

鼠标右键+滚轮

键盘快捷键

控制栏上的缩放控制，点击-/+按钮，或者在数字上滚动滚轮，或者左右拖动数字。

[如何让大图之间保持间隔？]

在CONF > Style中，修改或添加 .ehvp-root { --ehvp-big-images-gap: 2px; }

[如何打开指定页数的图片？]

在缩略图列表界面中，直接在键盘上输入数字(没有提示)，然后按下回车或自定义的快捷键。

[关于缩略图列表。]

缩略图列表是脚本最重要的特性，可以让你快速地了解整个画廊的情况。

并且缩略图也是延迟加载的，通常会加载20张左右，与正常浏览所发出的请求相当，甚至更低。

并且分页也是延迟加载的，并不会一次性加载画廊的所有分页，只有滚动到接近底部时，才会加载下一页。

不用担心因为在缩略图列表中快速滚动而导致发出大量的请求，脚本充分考虑到了这一点。

[关于自动加载和预加载。]<


# Copyright (C) 2022-2025 Intel Corporation
# LIMITED EDGE SOFTWARE DISTRIBUTION LICENSE

"""Project-related fixtures"""

from datetime import datetime, timezone

import pytest

from geti_types import ProjectIdentifier
from iai_core.entities.dataset_storage import NullDatasetStorage
from iai_core.entities.project import Project
from iai_core.entities.task_graph import TaskGraph

@pytest.fixture
def fxt_project_identifier_1(fxt_workspace_id, fxt_ote_id):
    yield ProjectIdentifier(
        workspace_id=fxt_workspace_id,
        project_id=fxt_ote_id(1),
    )

@pytest.fixture
def fxt_project_identifier_2(fxt_workspace_id, fxt_ote_id):
    yield ProjectIdentifier(
        workspace_id=fxt_workspace_id,
        project_id=fxt_ote_id(2),
    )

@pytest.fixture
def fxt_project_identifier(fxt_project_identifier_1):
    yield fxt_project_identifier_1

@pytest.fixture
def fxt_project(fxt_project_identifier):
    yield Project(
        name="dummy_empty_project",
        creator_id="",
        description="dummy empty project",
        dataset_storages=[NullDatasetStorage()],
        task_graph=TaskGraph(),
        id=fxt_project_identifier.project_id,
        creation_date=datetime.strptime("01/01/1970 00:00:01", "%d/%m/%Y %H:%M:%S").astimezone(timezone.utc),
        user_names=["test_username"],
    )


// BlacklistPeer -
func (p2pahs *P2PAntifloodHandlerStub) BlacklistPeer(peer core.PeerID, reason string, duration time.Duration) {
	if p2pahs.BlacklistPeerCalled != nil {
		p2pahs.BlacklistPeerCalled(peer, reason, duration)
	}
}

// Close -
func (p2pahs *P2PAntifloodHandlerStub) Close() error {
	return nil
}

// IsInterfaceNil -
func (p2pahs *P2PAntifloodHandlerStub) IsInterfaceNil() bool {
	return p2pahs == nil
}
package mock

import (
	"github.com/multiversx/mx-chain-core-go/data"
	"github.com/multiversx/mx-chain-go/process/track"
)

// BlockTrackerHandlerMock -
type BlockTrackerHandlerMock struct {
	GetSelfHeadersCalled          func(headerHandler data.HeaderHandler) []*track.HeaderInfo
	ComputeCrossInfoCalled        func(headers []data.HeaderHandler)
	ComputeLongestSelfChainCalled func() (data.HeaderHandler, []byte, []data.HeaderHandler, [][]byte)
	SortHeadersFromNonceCalled    func(shardID uint32, nonce uint64) ([]data.HeaderHandler, [][]byte)
	AddHeaderFromPoolCalled       func(shardID uint32, nonce uint64)
}

// GetSelfHeaders -
func (bthm *BlockTrackerHandlerMock) GetSelfHeaders(headerHandler data.HeaderHandler) []*track.HeaderInfo {
	if bthm.GetSelfHeadersCalled != nil {
		return bthm.GetSelfHeadersCalled(headerHandler)
	}

	return nil
}

// ComputeCrossInfo -
func (bthm *BlockTrackerHandlerMock) ComputeCrossInfo(headers []data.HeaderHandler) {
	if bthm.ComputeCrossInfoCalled != nil {
		bthm.ComputeCrossInfoCalled(headers)
	}
}

// ComputeLongestSelfChain -
func (bthm *BlockTrackerHandlerMock) ComputeLongestSelfChain() (data.HeaderHandler, []byte, []data.HeaderHandler, [][]byte) {
	if bthm.ComputeLongestSelfChainCalled != nil {
		return bthm.ComputeLongestSelfChainCalled()
	}

	return nil, nil, nil, nil
}

// SortHeadersFromNonce -
func (bthm *BlockTrackerHandlerMock) SortHeadersFromNonce(shardID uint32, nonce uint64) ([]data.HeaderHandler, [][]byte) {
	if bthm.SortHeadersFromNonceCalled != nil {
		return bthm.SortHeadersFromNonceCalled(shardID, nonce)
	}

	return nil, nil
}

// AddHeaderFromPool -
func (bthm *BlockTrackerHandlerMock) AddHeaderFromPool(shardID uint32, nonce uint64) {
	if bthm.AddHeaderFromPoolCalled != nil {
		bthm.AddHeaderFromPoolCalled(shardID, nonce)
	}
}

// IsInterfaceNil -
func (bthm *BlockTrackerHandlerMock) IsInterfaceNil() bool {
	return bthm == nil
}
package mock

import (
	"github.com/multiversx/mx-chain-core-go/core"
)

// RaterMock -
type RaterMock struct {
	StartRating           uint32
	MinRating             uint32
	MaxRating             uint32
	Chance                uint32
	IncreaseProposer      int32
	DecreaseProposer      int32
	IncreaseValidator     int32
	DecreaseValidator     int32
	MetaIncreaseProposer  int32
	MetaDecreaseProposer  int32
	MetaIncreaseValidator int32
	MetaDecreaseValidator int32

	GetRatingCalled                func(string) uint32
	GetStartRatingCalled           func() uint32
	GetSignedBlocksThresholdCalled func() float32
	Compu


 = 0; i < l; i++) {
			out[0][i] = start + (i * delta);
		}
		return new Matrix(out);
	}

	/**
	 * Given two row vectors, construct the power set of rowvector combinations
	 *
	 * @param A
	 * @param B
	 * @return a new matrix of size A.cols * B.cols
	 */
	public static Matrix ntuples(Matrix A, Matrix B) {
		final double[][] Adata = A.getArray();
		final double[][] Bdata = B.getArray();

		final double[][] out = new double[2][Adata[0].length * Bdata[0].length];
		int i = 0;
		for (final double a : Adata[0]) {
			for (final double b : Bdata[0]) {
				out[0][i] = a;
				out[1][i] = b;
				i++;
			}
		}
		return new Matrix(out);
	}

	/**
	 * Given a matrix, repeat the matrix over i rows and j columns
	 *
	 * @param x
	 * @param i
	 * @param j
	 * @return repeated matrix
	 */
	public static Matrix repmat(Matrix x, int i, int j) {
		final double[][] xdata = x.getArray();
		final double[][] newmat = new double[xdata.length * i][xdata[0].length * j];
		for (int k = 0; k < newmat.length; k += xdata.length) {
			for (int l = 0; l < newmat[0].length; l += xdata[0].length) {
				int rowcopyindex = 0;
				for (final double[] ds : xdata) {
					System.arraycopy(ds, 0, newmat[k + rowcopyindex], l, xdata[0].length);
					rowcopyindex += 1;
				}
			}
		}
		return new Matrix(newmat);
	}

	/**
	 * horizontally stack all the matrices provided. i.e. ret = [x1 x2 x3 x4 ... xn]
	 *
	 * @param x
	 * @return horizontally stacked
	 */
	public static Matrix hstack(Matrix... x) {
		final int height = x[0].getRowDimension();
		int width = 0;
		for (final Matrix matrix : x) {
			width += matrix.getColumnDimension();
		}
		final double[][] newmat = new double[height][width];
		int colindex = 0;
		for (final Matrix matrix : x) {
			final double[][] matdata = matrix.getArray();
			final int w = matrix.getColumnDimension();
			for (int i = 0; i < height; i++) {
				System.arraycopy(matdata[i], 0, newmat[i], colindex, w);
			}
			colindex += w;
		}
		return new Matrix(newmat);
	}

	/**
	 * Add the rows to the mat at rowIndex. Assumes MANY things with no checks:
	 * rows.rows == rowIndex.length mat.cols == rows.cols rowIndex.length <
	 * mat.rows for x in rowIndex: x < mat.rows && x >= 0 etc.
	 *
	 * @param mat
	 * @param rows
	 * @param rowIndex
	 * @return the input matrix
	 */
	public static Matrix plusEqualsRow(Matrix mat, Matrix rows, int[] rowIndex) {
		final double[][] matdata = mat.getArray();
		final double[][] rowdata = rows.getArray();
		int i = 0;
		for (final int row : rowIndex) {
			for (int j = 0; j < rowdata[i].length; j++) {
				matdata[row][j] += rowdata[i][j];
			}
			i++;
		}
		return mat;
	}

	/**
	 * @param x
	 * @param val
	 * @return a new matrix for x < val
	 */
	public static Matrix lessThan(Matrix x, double val) {
		final Matrix


/*
 * Vue.h
 *
 *  Created on: 12 dc. 2017
 *      Author: Vincent
 */

#ifndef SOURCE_VUE_VUE_H_
#define SOURCE_VUE_VUE_H_

#include <vue/VueCommon.h>
#include <vue/Notif.h>
#include <vue/VueCRS.h>
#include <vue/VueFEC.h>
#include <vue/VuePRC.h>
#include <vue/VueDebug.h>
#include <vue/Menuable.h>
#include <button.h>
#include "ls027.h"

typedef enum {
	eVueGlobalScreenCRS,
	eVueGlobalScreenFEC,
	eVueGlobalScreenPRC,
	eVueGlobalScreenDEBUG,
} eVueGlobalScreenModes;

class Vue: public VueCRS, public VueFEC, public VuePRC, public VueDebug, public NotifiableDevice, public Menuable {
public:
	Vue();

	void init(void);

	void tasks(eButtonsEvent event);

	void setCurrentMode(eVueGlobalScreenModes mode_);

	void refresh(void);

	void drawPixel(int16_t x, int16_t y, uint16_t color);
	void drawPixelGroup(int16_t x, int16_t y, uint16_t nb, uint16_t color);

	void cadran (uint8_t p_lig, uint8_t nb_lig, uint8_t p_col, const char *champ, String  affi, const char *p_unite);
	void cadranH(uint8_t p_lig, uint8_t nb_lig, const char *champ, String  affi, const char *p_unite);

	void cadranRR(uint8_t p_lig, uint8_t nb_lig, uint8_t p_col, const char *champ, RRZone &zone);

	void Histo(uint8_t p_lig, uint8_t nb_lig, uint8_t p_col, sVueHistoConfiguration& h_config_);
	void HistoH (uint8_t p_lig, uint8_t nb_lig, sVueHistoConfiguration& h_config_);

	void clearDisplay(void) {
		LS027_Clear();
	}
	void invertDisplay(void) {
		LS027_InvertColors();
	}
	void writeWhole(void)
	{
		LS027_UpdateFull();
	}

	uint32_t getLastRefreshed() const {
		return m_last_refreshed;
	}

	// overrides of the GFX library
	void fillRoundRect(int16_t x, int16_t y, int16_t w,
			int16_t h, int16_t r, uint16_t color);
	void drawFastVLine(int16_t x, int16_t y,
			int16_t h, uint16_t color);
	void fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
			uint16_t color);

private:
	eVueGlobalScreenModes m_global_mode;
	uint32_t m_last_refreshed;

};

#endif /* SOURCE_VUE_VUE_H_ */


          arguments[0],
          space: ColorSpace.rgb,
          name: 'channels',
        ),
  }),

  _function("invert", r"$color, $weight: 100%, $space: null", (arguments) {
    if (arguments[0] is! SassNumber && !arguments[0].isSpecialNumber) {
      warnForGlobalBuiltIn("color", "invert");
    }
    return _invert(arguments, global: true);
  }),

  // ### HSL
  _channelFunction(
    "hue",
    ColorSpace.hsl,
    (color) => color.hue,
    unit: 'deg',
    global: true,
  ).withDeprecationWarning("color"),
  _channelFunction(
    "saturation",
    ColorSpace.hsl,
    (color) => color.saturation,
    unit: '%',
    global: true,
  ).withDeprecationWarning("color"),
  _channelFunction(
    "lightness",
    ColorSpace.hsl,
    (color) => color.lightness,
    unit: '%',
    global: true,
  ).withDeprecationWarning("color"),

  BuiltInCallable.overloadedFunction("hsl", {
    r"$hue, $saturation, $lightness, $alpha": (arguments) =>
        _hsl("hsl", arguments),
    r"$hue, $saturation, $lightness": (arguments) => _hsl("hsl", arguments),
    r"$hue, $saturation": (arguments) {
      // hsl(123, var(--foo)) is valid CSS because --foo might be `10%, 20%` and
      // functions are parsed after variable substitution.
      if (arguments[0].isVar || arguments[1].isVar) {
        return _functionString('hsl', arguments);
      } else {
        throw SassScriptException(r"Missing argument $lightness.");
      }
    },
    r"$channels": (arguments) => _parseChannels(
          'hsl',
          arguments[0],
          space: ColorSpace.hsl,
          name: 'channels',
        ),
  }),

  BuiltInCallable.overloadedFunction("hsla", {
    r"$hue, $saturation, $lightness, $alpha": (arguments) =>
        _hsl("hsla", arguments),
    r"$hue, $saturation, $lightness": (arguments) => _hsl("hsla", arguments),
    r"$hue, $saturation": (arguments) {
      if (arguments[0].isVar || arguments[1].isVar) {
        return _functionString('hsla', arguments);
      } else {
        throw SassScriptException(r"Missing argument $lightness.");
      }
    },
    r"$channels": (arguments) => _parseChannels(
          'hsla',
          arguments[0],
          space: ColorSpace.hsl,
          name: 'channels',
        ),
  }),

  _function("grayscale", r"$color", (arguments) {
    if (arguments[0] is SassNumber || arguments[0].isSpecialNumber) {
      // Use the native CSS `grayscale` filter function.
      return _functionString('grayscale', arguments);
    } else {
      warnForGlobalBuiltIn('color', 'grayscale');

      return _grayscale(arguments[0]);
    }
  }),

  _function("adjust-hue", r"$color, $degrees", (arguments) {
    var color = arguments[0].assertColor("color");
    var degrees = _angleValue(arguments[1], "degrees");

    if (!color.isLegacy) {
      throw SassScriptException(
        "adjust-hue() is only supported for legacy colors. Please use "
        "color.adjust() instead with an explicit \$space argument.",
      );
    }

    var suggestedValue = SassNumber(degrees, 'deg');
    warnForDeprecation(
      "adjust-hue() is deprecated. Suggestion:\n"
      "\n"
      "color.adjust(\$color, \$hue: ${suggestedValue.toCssString()})\n"
      "\n"
      "More info: https://sass-lan


testing.assert_array_almost_equal(grad_logpdf_var, grad_benchmark_logpdf_var, decimal=6)

def test_pdf(mean_field_normal, samples):
    """Test pdf."""
    pdf_vec = mean_field_normal.pdf(samples)
    benchmark_pdf_vec = jax_stats.multivariate_normal.pdf(
        samples, mean_field_normal.mean, np.diag(mean_field_normal.covariance)
    ).flatten()
    np.testing.assert_array_almost_equal(pdf_vec, benchmark_pdf_vec, decimal=6)

def test_ppf(mean_field_normal):
    """Test ppf."""
    quantile = 0.8
    # test multivariate case
    with pytest.raises(ValueError):
        mean_field_normal.ppf(quantile)

    # test univariate case
    mean_field_normal.mean = np.array([2.0])
    mean_field_normal.covariance = np.array([3.0])
    mean_field_normal.dimension = 1

    ppf = mean_field_normal.ppf(quantile)
    expected_ppf = scipy.stats.norm.ppf(quantile, loc=2.0, scale=3.0 ** (1 / 2))

    # test
    np.testing.assert_array_almost_equal(ppf, expected_ppf, decimal=6)


801D7800 8F240000 */   lw    $a0, ($t9)
/* 185854 801D7804 1000FFF8 */  b     .L801D77E8_ovl9
/* 185858 801D7808 8E4E0000 */   lw    $t6, ($s2)
/* 18585C 801D780C 00000000 */  nop
/* 185860 801D7810 00000000 */  nop
/* 185864 801D7814 00000000 */  nop
/* 185868 801D7818 00000000 */  nop
/* 18586C 801D781C 00000000 */  nop
/* 185870 801D7820 8FBF0024 */  lw    $ra, 0x24($sp)
/* 185874 801D7824 8FB00018 */  lw    $s0, 0x18($sp)
/* 185878 801D7828 8FB1001C */  lw    $s1, 0x1c($sp)
/* 18587C 801D782C 8FB20020 */  lw    $s2, 0x20($sp)
/* 185880 801D7830 03E00008 */  jr    $ra
/* 185884 801D7834 27BD0028 */   addiu $sp, $sp, 0x28

.type func_801D74EC_ovl9, @function
.size func_801D74EC_ovl9, . - func_801D74EC_ovl9

glabel func_801D7838_ovl9
/* 185888 801D7838 27BDFFD8 */  addiu $sp, $sp, -0x28
/* 18588C 801D783C AFB20020 */  sw    $s2, 0x20($sp)
/* 185890 801D7840 AFB1001C */  sw    $s1, 0x1c($sp)
/* 185894 801D7844 AFB00018 */  sw    $s0, 0x18($sp)
/* 185898 801D7848 3C10800E */ lui $s0, 0x800e
/* 18589C 801D784C 3C118005 */ lui $s1, 0x8005
/* 1858A0 801D7850 3C128022 */ lui $s2, 0x8022
/* 1858A4 801D7854 AFBF0024 */  sw    $ra, 0x24($sp)
/* 1858A8 801D7858 AFA40028 */  sw    $a0, 0x28($sp)
/* 1858AC 801D785C 2652BC0C */ addiu $s2, -0x43f4
/* 1858B0 801D7860 2631A7C4 */ addiu $s1, -0x583c
/* 1858B4 801D7864 2610DC50 */ addiu $s0, -0x23b0
/* 1858B8 801D7868 8E2E0000 */  lw    $t6, ($s1)
.L801D786C_ovl9:
/* 1858BC 801D786C 24050005 */  li    $a1, 5
/* 1858C0 801D7870 02403025 */  move  $a2, $s2
/* 1858C4 801D7874 8DCF0000 */  lw    $t7, ($t6)
/* 1858C8 801D7878 000FC080 */  sll   $t8, $t7, 2
/* 1858CC 801D787C 0218C821 */  addu  $t9, $s0, $t8
/* 1858D0 801D7880 0C02911F */  jal   call_virtual_function
/* 1858D4 801D7884 8F240000 */   lw    $a0, ($t9)
/* 1858D8 801D7888 1000FFF8 */  b     .L801D786C_ovl9
/* 1858DC 801D788C 8E2E0000 */   lw    $t6, ($s1)
/* 1858E0 801D7890 00000000 */  nop
/* 1858E4 801D78


import json
import requests

class TratarDadosAPI:
    def fazer_requisicao(self, endpoint, parametros={}):
        url = f'https://rickandmortyapi.com/api/{endpoint}'
        resposta = requests.get(url, params=parametros)

        if resposta.status_code == 200:
            return resposta.json()
        else:
            raise Exception(f"Erro ao consultar dados na API: {resposta.status_code}")

    def salvar_dados(self, nome_arquivo, dados):
        with open(nome_arquivo, 'w', encoding='utf-8') as arquivo:
            json.dump(dados, arquivo, ensure_ascii=False, indent=4)

    def buscar_dados(self, endpoint, filtros={}):
        personagens_detalhes = []
        pagina = 1

        while True:
            filtros['page'] = pagina
            try:
                dados = self.fazer_requisicao(endpoint, filtros)

                for personagem in dados['results']:
                    detalhes = {}
                    for chave in filtros.keys():
                        if chave in personagem:
                            detalhes[chave] = personagem[chave]
                        else:
                            detalhes[chave] = 'Desconhecido'
                    personagens_detalhes.append(detalhes)

                if not dados['info']['next']:
                    break

                pagina += 1

            except Exception as e:
                print(str(e))
                break

        for personagem in personagens_detalhes:
            personagem.pop('page', None)

        self.salvar_dados('Data/.json', personagens_detalhes)
        return personagens_detalhes


nal = "http.server_name"
"""
Deprecated: Replaced by `server.address`.
"""

HTTP_STATUS_CODE: Final = "http.status_code"
"""
Deprecated: Replaced by `http.response.status_code`.
"""

HTTP_TARGET: Final = "http.target"
"""
Deprecated: Split to `url.path` and `url.query.
"""

HTTP_URL: Final = "http.url"
"""
Deprecated: Replaced by `url.full`.
"""

HTTP_USER_AGENT: Final = "http.user_agent"
"""
Deprecated: Replaced by `user_agent.original`.
"""

class HttpConnectionStateValues(Enum):
    ACTIVE = "active"
    """active state."""
    IDLE = "idle"
    """idle state."""

@deprecated(
    reason="The attribute http.flavor is deprecated - Replaced by `network.protocol.name`"
)  # type: ignore
class HttpFlavorValues(Enum):
    HTTP_1_0 = "1.0"
    """HTTP/1.0."""
    HTTP_1_1 = "1.1"
    """HTTP/1.1."""
    HTTP_2_0 = "2.0"
    """HTTP/2."""
    HTTP_3_0 = "3.0"
    """HTTP/3."""
    SPDY = "SPDY"
    """SPDY protocol."""
    QUIC = "QUIC"
    """QUIC protocol."""

@deprecated(
    reason="Deprecated in favor of stable :py:const:`opentelemetry.semconv.attributes.http_attributes.HttpRequestMethodValues`."
)  # type: ignore
class HttpRequestMethodValues(Enum):
    CONNECT = "CONNECT"
    """Deprecated in favor of stable :py:const:`opentelemetry.semconv.attributes.http_attributes.HttpRequestMethodValues.CONNECT`."""
    DELETE = "DELETE"
    """Deprecated in favor of stable :py:const:`opentelemetry.semconv.attributes.http_attributes.HttpRequestMethodValues.DELETE`."""
    GET = "GET"
    """Deprecated in favor of stable :py:const:`opentelemetry.semconv.attributes.http_attributes.HttpRequestMethodValues.GET`."""
    HEAD = "HEAD"
    """Deprecated in favor of stable :py:const:`opentelemetry.semconv.attributes.http_attributes.HttpRequestMethodValues.HEAD`."""
    OPTIONS = "OPTIONS"
    """Deprecated in favor of stable :py:const:`opentelemetry.semconv.attributes.http_attributes.HttpRequestMethodValues.OPTIONS`."""
    PATCH = "PATCH"
    """Deprecated in favor of stable :py:const:`opentelemetry.semconv.attributes.http_attributes.HttpRequestMethodValues.PATCH`."""
    POST = "POST"
    """Deprecated in favor of stable :py:const:`opentelemetry.semconv.attributes.http_attributes.HttpRequestMethodValues.POST`."""
    PUT = "PUT"
    """Deprecated in favor of stable :py:const:`opentelemetry.semconv.attributes.http_attributes.HttpRequestMethodValues.PUT`."""
    TRACE = "TRACE"
    """Deprecated in favor of stable :py:const:`opentelemetry.semconv.attributes.http_attributes.HttpRequestMethodValues.TRACE`."""
    OTHER = "_OTHER"
    """Deprecated in favor of stable :py:const:`opentelemetry.semconv.attributes.http_attributes.HttpRequestMethodValues.OTHER`."""


uture.delayed(const Duration(milliseconds: 2000), () {
            requestQrCamera();
          });
        }
        _progressOverlayEntry?.remove();
      }
    });
  }

  void requestQrCamera() {
    _qrBloc.add(RequestQrCamera());
  }

  @override
  Widget build(BuildContext context) {
    return BlocBuilder(
      bloc: _qrBloc,
      builder: (context, state) {
        if (state is QrStateCameraRequested) {
          if (state.successfullyLoaded) {
            return Center(
              child: QrCamera(
                qrCodeCallback: (code) {
                  setState(() {
                    if (!_qrCodeDetected) {
                      String qrString = code;
                      if (qrString.isNotEmpty) {
                        _qrCodeDetected = true;
                        checkAndJoinQr(qrString);
                      }
                    }
                  });
                },
              ),
            );
          } else {
            return StateInfo(
              title: L10n.get(L.qrCameraNotAllowed),
              subTitle: L10n.get(L.qrCameraNotAllowedText),
              actionTitle: L10n.get(L.retry),
              action: requestQrCamera,
            );
          }
        } else if (state is QrStateLoading) {
          return Container();
        } else {
          return StateInfo(showLoading: true);
        }
      },
    );
  }

  void checkAndJoinQr(String qrString) {
    _progressOverlayEntry = FullscreenOverlay(
      fullscreenProgress: FullscreenProgress(
        bloc: _qrBloc,
        text: L10n.get(L.pleaseWait),
        showProgressValues: false,
        showCancelButton: true,
        cancelPressed: _cancelPressed,
      ),
    );
    Overlay.of(context).insert(_progressOverlayEntry);
    _qrBloc.add(CheckQr(qrText: qrString));
  }

  void _cancelPressed() {
    _progressOverlayEntry?.remove();
    _qrCodeDetected = false;
    _qrBloc.add(CancelQrProcess());
  }
}
/*
 * OPEN-XCHANGE legal information
 *
 * All intellectual property rights in the Software are protected by
 * international copyright laws.
 *
 *
 * In some countries OX, OX Open-Xchange and open xchange
 * as well as the corresponding Logos OX Open-Xchange and OX are registered
 * trademarks of the OX Software GmbH group of companies.
 * The use of the Logos is not covered by the Mozilla Public License 2.0 (MPL 2.0).
 * Instead, you are allowed to use these Logos according to the terms and
 * conditions of the Creative Commons License, Version 2.5, Attribution,
 * Non-commercial, ShareAlike, and the interpretation of the term
 * Non-commercial applicable to the aforementioned license is published
 * on the web site https://www.open-xchange.com/terms-and-conditions/.
 *
 * Please make sure that third-party modules and libraries are used
 * according to their respective licenses.
 *
 * Any modifications to this package must retain all copyright notices
 * of the original copyright holder(s) for the original code used.
 *
 * After any such modifications, the original and derivative code shall remain
 * under the copyright of the copyright holder(s) and/or original author(s) as stated here:
 * https://www.open-xchange.com/legal/. The contributing author shall be
 * given Attribution for the derivative code and a license granting use.
 *
 * Copyright (C) 2016-2020 OX Software GmbH
 * Mail: info@open-xchange.com
 *
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can


changeme123"]

[registry]
max_upload_size_mb = 1000
rate_limit_per_hour = 1000
```

### Production Configuration

```toml
[server]
bind_addr = "0.0.0.0:5000"
ui_addr = "0.0.0.0:5001"
workers = 8
max_connections = 2000

[storage]
type = "s3"

[storage.s3]
endpoint = "https://s3.amazonaws.com"
region = "us-west-2"
bucket = "my-registry-bucket"
access_key = "AKIAIOSFODNN7EXAMPLE"
secret_key = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"

[auth]
mode = "oidc"
jwt_secret = "your-256-bit-secret-key"
token_expiry_hours = 8

[auth.oauth.azure]
client_id = "your-azure-client-id"
client_secret = "your-azure-client-secret"
tenant_id = "your-tenant-id"
enabled = true

[garbage_collector]
enabled = true
interval_hours = 24
grace_period_hours = 168

[bolt]
enable_profile_validation = true
enable_plugin_sandbox = true

[quic]
enabled = true
backend = "quinn"
bind_addr = "0.0.0.0:5443"
cert_path = "./certs/server.crt"
key_path = "./certs/server.key"

[signing]
enabled = true
signature_formats = ["cosign", "notary-v2"]

[optimization]
enabled = true
background_optimization = true
preferred_compression = "zstd"
```

## 🐳 Docker Deployment

### Docker Compose (Production)

```yaml
version: '3.8'

services:
  drift-registry:
    image: drift:latest
    container_name: drift-registry
    restart: unless-stopped
    ports:
      - "5000:5000"  # Registry API
      - "5001:5001"  # Web UI
      - "5443:5443"  # QUIC (optional)
    environment:
      - DRIFT_AUTH_MODE=oidc
      - DRIFT_AUTH_JWT_SECRET=${JWT_SECRET}
      - DRIFT_AZURE_CLIENT_ID=${AZURE_CLIENT_ID}
      - DRIFT_AZURE_CLIENT_SECRET=${AZURE_CLIENT_SECRET}
      - DRIFT_AZURE_TENANT_ID=${AZURE_TENANT_ID}
      - DRIFT_S3_ACCESS_KEY=${S3_ACCESS_KEY}
      - DRIFT_S3_SECRET_KEY=${S3_SECRET_KEY}
    volumes:
      - ./drift.toml:/app/drift.toml:ro
      - ./certs:/app/certs:ro
      - drift-data:/app/data
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:5000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
    depends_on:
      - redis
      - postgres

  redis:
    image: redis:alpine
    container_name: drift-redis
    restart: unless-stopped
    volumes:
      - redis-data:/data

  postgres:
    image: postgres:15
    container_name: drift-postgres
    restart: unless-stopped
    environment:
      - POSTGRES_DB=drift
      - POSTGRES_USER=drift
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
    volumes:
      - postgres-data:/var/lib/postgresql/data

volumes:
  drift-data:
  redis-data:
  postgres-data:
```

### Environment Variables

```bash
# Create .env file
cat > .env << EOF
JWT_SECRET=$(openssl rand -base64 32)
AZURE_CLIENT_ID=your-azure-client-id
AZURE_CLIENT_SECRET=your-azure-client-secret
AZURE_TENANT_ID=your-tenant-id
S3_ACCESS_KEY=your-s3-access-key
S3_SECRET_KEY=your-s3-secret-key
POSTGRES_PASSWORD=$(openssl r


local FUNC_NOOP = function(...) return 0 end

-- find the min and max of the values in a table with this format: { {x, y, ....}, {x, y, ....}, ....}
-- the given i is the index position of the value, 1 for x, etc
local function findminmax(t, i)
    if t == nil or #t == 0 then return 0 end
    local mi = t[1][i]
    local ma = t[1][i]
    for _,v in ipairs(t) do
        if v[i] < mi then mi = v[i] end
        if v[i] > ma then ma = v[i] end
    end
    return mi, ma
end

-- a scaling function which outputs a percentage based on a given scale
local function scale(x, lower, upper, scaledMin, scaledMax)
    local perc = (x - lower) / (upper - lower)
    return perc * (scaledMax - scaledMin) + scaledMin
end

local dotWidth = 0
local function addDotVerts(vt, x, y, c)
	vt[#vt + 1] = {{x - dotWidth, y + dotWidth, 0}, c}
end

local fitX = FUNC_NOOP
local fitY = FUNC_NOOP
local colorToUse = color("#FFFFFF")

return Def.ActorFrame {
    Name = "LineGraph",
    RegisterToGraphOwnerCommand = function(self, params)
        if self.registered then return end
        self.registered = true
        if self:GetParent().graphs == nil then self:GetParent().graphs = {} end
        local graphs = self:GetParent().graphs
        graphs[params.name] = self
    end,
    DisplayGraphCommand = function(self, params)
        if params == nil or params.data == nil or #params.data == 0 then
            self:playcommand("DrawNothing")
            return
        end

        local fullWidth = self:GetParent():GetChild("BG"):GetZoomedWidth()
        local xmin, xmax = params.xmin, params.xmax
        if xmin == nil or xmax == nil then
            local a,b = findminmax(params.data, 1)
            if xmin == nil then xmin = a end
            if xmax == nil then xmax = b end
        en


Offset, value, endian);
    }
  }
}

class _UnmodifiableI8ByteData extends I8ByteData
    with _UnmodifiableByteDataMixin {
  _UnmodifiableI8ByteData._(
    WasmArray<WasmI8> _data,
    int offsetInBytes,
    int lengthInBytes,
  ) : super._(_data, offsetInBytes, lengthInBytes);

  @override
  @pragma('wasm:prefer-inline')
  _I8ByteBuffer get buffer => _I8ByteBuffer._(_data, false);
}

class _UnmodifiableI16ByteData extends _I16ByteData
    with _UnmodifiableByteDataMixin {
  _UnmodifiableI16ByteData._(
    WasmArray<WasmI16> _data,
    int offsetInBytes,
    int lengthInBytes,
  ) : super._(_data, offsetInBytes, lengthInBytes);

  @override
  @pragma('wasm:prefer-inline')
  _I16ByteBuffer get buffer => _I16ByteBuffer._(_data, false);
}

class _UnmodifiableI32ByteData extends _I32ByteData
    with _UnmodifiableByteDataMixin {
  _UnmodifiableI32ByteData._(
    WasmArray<WasmI32> _data,
    int offsetInBytes,
    int lengthInBytes,
  ) : super._(_data, offsetInBytes, lengthInBytes);

  @override
  @pragma('wasm:prefer-inline')
  _I32ByteBuffer get buffer => _I32ByteBuffer._(_data, false);
}

class _UnmodifiableI64ByteData extends _I64ByteData
    with _UnmodifiableByteDataMixin {
  _UnmodifiableI64ByteData._(
    WasmArray<WasmI64> _data,
    int offsetInBytes,
    int lengthInBytes,
  ) : super._(_data, 0, _data.length * 8);

  @override
  @pragma('wasm:prefer-inline')
  _I64ByteBuffer get buffer => _I64ByteBuffer._(_data, false);
}

class _UnmodifiableF32ByteData extends _F32ByteData
    with _UnmodifiableByteDataMixin {
  _UnmodifiableF32ByteData._(
    WasmArray<WasmF32> _data,
    int offsetInBytes,
    int lengthInBytes,
  ) : super._(_data, offsetInBytes, lengthInBytes);

  @override
  @pragma('wasm:prefer-inline')
  _F32ByteBuffer get buffer => _F32ByteBuffer._(_data, false);
}

class _UnmodifiableF64ByteData extends _F64ByteData
    with _UnmodifiableByteDataMixin {
  _UnmodifiableF64ByteData._(
    WasmArray<WasmF64> _data,
    int offsetInBytes,
    int lengthInBytes,
  ) : super._(_data, offsetInBytes, lengthInBytes);

  @override
  @pragma('wasm:prefer-inline')
  _F64ByteBuffer get buffer => _F64ByteBuffer._(_data, false);
}

//
// Byte buffers
//

/// Base class for [ByteBuffer] implementations. Returns slow lists in all
/// methods. Implementations should override relevant methods to return fast
/// lists when possible and implement [asByteData].
abstract class ByteBufferBase extends WasmTypedDataBase implements ByteBuffer {
  final int lengthInBytes;
  final bool _mutable;

  ByteBufferBase(this.lengthInBytes, this._mutable);

  ByteBufferBase _immutable();

  @override
  Uint8List asUint8List([int offsetInBytes = 0, int? length]) {
    length ??= (lengthInBytes - offsetInBytes) ~/ Uint8List.bytesPerElement;
    _rangeCheck(
      lengthInBytes,
      offsetInBytes,
      length * Uint8List.bytesPerElement,
    );
    return _SlowU8List._withMutability(this, offsetInBytes, length, _mutable);
  }

  @override
  Int8List asInt8List([int offsetInBytes = 0, int? length]) {
    length ??= (lengthInB