 gin.H{
			"code": -1000,
			"msg":  "不是有效的SQL文件！",
			"data": "",
		})
		return
	}

	//执行SQL文件
	_, err := model.DbLogInsert(sql_name)

	if err != nil {
		c.JSON(200, gin.H{
			"code": 500,
			"msg":  "SQL文件执行失败，请检查日志！",
			"data": "",
		})
		return
	} else {
		c.JSON(200, gin.H{
			"code": 200,
			"msg":  "success",
			"data": "",
		})
	}
}

// 创建数据库文件,当start的时候必定先执行此函数
func Create_db_file() {
	// 创建文件，在此之前检查目录是否存在
	// 检查文件夹是否存在
	db_dir := "data/db"

	if _, err := os.Stat(db_dir); os.IsNotExist(err) {
		// 创建文件夹
		err := os.Mkdir(db_dir, 0755)
		if err != nil {
			fmt.Println(err)
			return
		}
	}

	//数据库文件路径
	db_file := "data/db/zdir.db3"
	//判断文件是否存在，存在就不再创建
	_, err := os.Stat(db_file)

	//连接数据库
	model.InitDB()

	//如果文件存在，则不再创建，但需要连接数据库
	if err == nil {
		fmt.Println("The database file already exists, skip this step.")
		return
	}

	//文件不存在，则创建文件并导入初始数据
	//导入默认的数据库文件，初始数据库的时候不存在zdir.db3会自动创建
	model.ImportDefaultSQL()
	fmt.Println("Database file created successfully!")
}
package sshclient

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"net"
	"os"
	"os/exec"
	"path"
	"sync"
	"syscall"
	"testing"
	"time"
	"unsafe"

	"github.com/creack/pty"
	"github.com/gliderlabs/ssh"
	"github.com/pkg/sftp"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/stretchr/testify/suite"
)

func TestDailWithPasswd(t *testing.T) {
	user := "test"
	passwd := "test"
	listener := newLocalListener(t)
	addr := listener.Addr().String()

	srv := newTestServer(t, listener, user, passwd)
	defer srv.Shutdown(context.Background())

	cli, err := DialWithPasswd(addr, user, passwd)
	defer cli.Close()
	assert.NoError(t, err)
}

func newTestTerminalHandler(t *testing.T) ssh.Handler {
	return func(s ssh.Session) {
		ptyReq, winCh, isPty := s.Pty()
		if isPty {
			cmd := exec.Command("bash")
			cmd.Env = append(cmd.Env, fmt.Sprintf("TERM=%s", ptyReq.Term))
			close := func() {
				_, err := cmd.Process.Wait()
				s.Write([]byte{0})
				assert.NoError(t, err)
			}
			ptmx, err := pty.Start(cmd)
			assert.NoError(t, err)
			defer func() { _ = ptmx.Close() }() // Best effort.

			go func() {
				for win := range winCh {
					syscall.Syscall(syscall.SYS_IOCTL, ptmx.Fd(), uintptr(syscall.TIOCSWINSZ),
						uintptr(unsafe.Po


gdmlld0JveD0iMCAwIDI0IDI0IiBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLXdpZHRoPSIyIiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIGNsYXNzPSJsdWNpZGUgbHVjaWRlLWNha2UiPjxwYXRoIGQ9Ik0yMCAyMXYtOGEyIDIgMCAwIDAtMi0ySDZhMiAyIDAgMCAwLTIgMnY4Ii8+PHBhdGggZD0iTTQgMTZzLjUtMSAyLTEgMi41IDIgNCAyIDIuNS0yIDQtMiAyLjUgMiA0IDIgMi0xIDItMSIvPjxwYXRoIGQ9Ik0yIDIxaDIwIi8+PHBhdGggZD0iTTcgOHYzIi8+PHBhdGggZD0iTTEyIDh2MyIvPjxwYXRoIGQ9Ik0xNyA4djMiLz48cGF0aCBkPSJNNyA0aDAuMDEiLz48cGF0aCBkPSJNMTIgNGgwLjAxIi8+PHBhdGggZD0iTTE3IDRoMC4wMSIvPjwvc3ZnPg==");
  mask-size: contain;
  -webkit-mask-image: url("data:image/svg+xml,base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgdmlld0JveD0iMCAwIDI0IDI0IiBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLXdpZHRoPSIyIiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIGNsYXNzPSJsdWNpZGUgbHVjaWRlLWNha2UiPjxwYXRoIGQ9Ik0yMCAyMXYtOGEyIDIgMCAwIDAtMi0ySDZhMiAyIDAgMCAwLTIgMnY4Ii8+PHBhdGggZD0iTTQgMTZzLjUtMSAyLTEgMi41IDIgNCAyIDIuNS0yIDQtMiAyLjUgMiA0IDIgMi0xIDItMSIvPjxwYXRoIGQ9Ik0yIDIxaDIwIi8+PHBhdGggZD0iTTcgOHYzIi8+PHBhdGggZD0iTTEyIDh2MyIvPjxwYXRoIGQ9Ik0xNyA4djMiLz48cGF0aCBkPSJNNyA0aDAuMDEiLz48cGF0aCBkPSJNMTIgNGgwLjAxIi8+PHBhdGggZD0iTTE3IDRoMC4wMSIvPjwvc3ZnPg==");
  -webkit-mask-size: contain;
  background-color: var(--color-purple);
  left: 0px;
}
body [data-task="w"] > input[type="checkbox"]:checked:before,
body [data-task="w"] > p > input[type="checkbox"]:checked:before,
body [data-task="w"][type="checkbox"]:checked:before {
  color: var(--color-purple);
  margin: 0 3px;
  position: absolute;
  left: calc(var(--checkbox-size) * 1);
  font-weight: bold;
}

body:not(.is-mobile) .modal-container {
  animation: fadeIn 0.1s ease;
}
body:not(.is-mobile) .modal button {
  position: relative;
}
body:not(.is-mobile) .modal:not(.mod-settings):not(.mod-community-modal) {
  animation: var(--anim-duration-fast) fadeInDown;
  padding: 1em;
}
body:not(.is-mobile)
  .modal:not(.mod-settings):not(.mod-community-modal)
  .modal-close-button {
  display: none;
}
body:not(.is-mobile)
  .modal:not(.mod-settings):not(.mod-community-modal)
  .mod


jo6U2l6ZQAxLjAzS0JCZtQvXwAAAFx0RVh0VGh1bWI6OlVSSQBmaWxlOi8vL2hvbWUvZnRwLzE1MjAvZWFzeWljb24uY24vZWFzeWljb24uY24vY2RuLWltZy5lYXN5aWNvbi5jbi9wbmcvMTcvMTc4Ni5wbmcRsze7AAAAAElFTkSuQmCC);
}

notify-gp .notify-show {
    opacity: 1;
    transform: scaleY(1);
}

notify-gp .notify-hide {
    opacity: 0;
    transform: scaleY(0);
}

notify-gp .notify-success {
    color: rgba(118, 255, 3, .8);
}

notify-gp .notify-warning {
    color: rgba(255, 238, 88, 1);
}

notify-gp .notify-error {
    color: rgba(239, 83, 80, 1);
}

notify-gp .notify-modal {
    flex-flow: column nowrap;
    align-items: flex-start;

    height: auto;
    max-height: 200px;

    box-shadow: 0 2px 2px 0 rgba(0,0,0,0.14), 0 1px 5px 0 rgba(0,0,0,0.12), 0 3px 1px -2px rgba(0,0,0,0.2);
}

notify-gp .notify-modal .notify-modal-content {
    margin-top: 5px;
    font-size: 13px;
    white-space: normal;
}

notify-gp .notify-modal .notify-modal-content a {
    margin: 0;
    padding: 0;

    color: inherit;

    font-size: inherit;
    text-decoration: underline;

    cursor: pointer;
}

notify-gp .notify-modal .notify-modal-content a:hover,
notify-gp .notify-modal .notify-modal-content a:active,
notify-gp .notify-modal .notify-modal-content a:visited,
notify-gp .notify-modal .notify-modal-content a:focus {
    color: inherit;
}

notify-gp .notify-snackbar {
    position: fixed;
    bottom: 0;
    left: 50%;
    transform-origin: left bottom 0px;
}

.notify-position-left-top-corner {
    align-items: flex-start;

    margin: 0 0 0 15px;

    left: 0;
    right: initial;
}

.notify-position-left-bottom-corner {
    flex-flow: column-reverse wrap-reverse;

    margin: 0 0 15px 15px;

    right: initial;
    top: initial;

    left: 0;
    bottom: 0;
}

.notify-position-right-bottom-corner {
    flex-flow: column-reverse wrap-reverse;
    align-items: flex-start;

    margin: 0 15px 15px 0;

    top: initial;
    left: initial;

    bottom: 0;
    right: 0;
}

.hide {
    display: none;
}

.row {
    display: flex;
    flex-direction: row;
}

.space {
    width: 30px;
}

.box-large {
    padding-top:30px;
}

.header {
    background-color: #8BC34A;
}

.editor {


�

2014年9月26日 山东省第十二届人民代表大会常务委员会第十次会议批准

<!-- INFO END -->

第一条 为了加强城市建设档案管理，发挥城市建设档案在城市规划、建设、管理中的作用，根据《中华人民共和国档案法》、《建设工程质量管理条例》等法律法规，结合本市实际，制定本规定。

第二条 本规定适用于本市行政区域内城市建设档案（以下简称城建档案）的管理。

第三条 本规定所称城建档案是指在城市规划、建设和管理中直接形成的有保存价值的文字、图表、图片、声像等纸质、电子和其他载体形式的历史记录。

第四条 市城乡建设主管部门负责本市城建档案的统一管理工作。

县（市、区）城乡建设主管部门负责本辖区城建档案的管理工作。

第五条 市城建档案管理机构具体负责市辖区（长清区除外）城建档案和市级以上重点建设工程城建档案的接收、收集、保管和利用。

县（市）、长清区城建档案管理机构具体负责本辖区城建档案的接收、收集、保管和利用。

市、县（市、区）档案管理部门应当依法加强对本辖区城建档案管理工作的监督和指导。

第六条 城建档案管理机构应当接收、收集下列城建档案:

（一）各类城市建设工程档案:

1.工业、民用建筑工程；

2.市政基础设施工程；

3.公用基础设施工程；

4.城市交通基础设施工程；

5.园林绿化、风景名胜建设工程；

6.市容环境卫生设施建设工程；

7.城市防洪、抗震和环境保护、人防工程；

8.军事工程档案资料中，除军事禁区和军事管理区以外的穿越市区的地下管线走向和有关隐蔽工程的位置图；

9．其他具有保存价值的城市建设工程档案；

（二）城乡规划、城乡建设、城市管理、市政公用、园林绿化等城市建设各专业管理部门形成的，具有永久保存价值的业务管理和技术档案；

（三）有关城市


}for(const e of null!==(a=t.groupby)&&void 0!==a?a:[]){var a;n.add(e)}return n.size+C(i).length===0?null:new Sf(e,n,i)}merge(e){return D(this.dimensions,e.dimensions)?(function(e,t){for(const i of C(t)){const o=t[i];for(const t of C(o)){var n;i in e?e[i][t]=new Set([...null!==(n=e[i][t])&&void 0!==n?n:[],...o[t]]):e[i]={[t]:o[t]}}}}(this.measures,e.measures),!0):(function(){Pi.debug(...arguments)}("different dimensions, cannot merge"),!1)}addDimensions(e){e.forEach(this.dimensions.add,this.dimensions)}dependentFields(){return new Set([...this.dimensions,...C(this.measures)])}producedFields(){const e=new Set;for(const t of C(this.measures))for(const n of C(this.measures[t])){const i=this.measures[t][n];0===i.size?e.add("".concat(n,"_").concat(t)):i.forEach(e.add,e)}return e}hash(){return"Aggregate ".concat(h({dimensions:this.dimensions,measures:this.measures}))}assemble(){const e=[],t=[],n=[];for(const i of C(this.measures))for(const o of C(this.measures[i]))for(const r of this.measures[i][o])n.push(r),e.push(o),t.push("*"===i?null:R(i));return{type:"aggregate",groupby:[...this.dimensions].map(R),ops:e,fields:t,as:n}}}class Df extends Hl{constructor(e,n,i,o){super(e),this.model=n,this.name=i,this.data=o,Ln(this,"column",void 0),Ln(this,"row",void 0),Ln(this,"facet",void 0),Ln(this,"childModel",void 0);for(const e of Re){const i=n.facet[e];if(i){const{bin:o,sort:r}=i;this[e]={name:n.getName("".concat(e,"_domain")),fields:[ka(i),...an(o)?[ka(i,{binSuffix:"end"})]:[]],...Jr(r)?{sortField:r}:t.isArray(r)?{sortIndexField:Dd(i,e)}:{}}}}this.childModel=n.child}hash(){let e="Facet";for(const t of Re)this[t]&&(e+=" ".concat(t.charAt(0),":").concat(h(this[t])));return e}get fields(){const e=[];for(const n of Re){var t;null!==(t=this[n])&&void 0!==t&&t.fields&&e.push(...this[n].fields)}return e}dependentFields(){const e=new Set(this.fields);for(const t of Re)this[t]&&(this[t].sortField&&e.add(this[t].sortField.field),this[t].sortIndexField&&e.add(this[t].sortIndexField));return e}producedFields(){return new Set}getSource(){return this.name}getChildIndependentFieldsWithStep(){const e={};for(const t of Dt){const n=this.childModel.component.scales[t];if(n&&!n.merged){const i=n.get("type"),o=n.get("range");if(qo(i)&&hn(o)){const n=gp(hp(


)
          as _i6.Stream<bool>);

  @override
  _i6.Future<void> cancelStripeSubscription() =>
      (super.noSuchMethod(
            Invocation.method(#cancelStripeSubscription, []),
            returnValue: _i6.Future<void>.value(),
            returnValueForMissingStub: _i6.Future<void>.value(),
          )
          as _i6.Future<void>);

  @override
  _i6.Future<bool> showLetParentsBuyButton() =>
      (super.noSuchMethod(
            Invocation.method(#showLetParentsBuyButton, []),
            returnValue: _i6.Future<bool>.value(false),
            returnValueForMissingStub: _i6.Future<bool>.value(false),
          )
          as _i6.Future<bool>);

  @override
  _i6.Future<String?> getPlusWebsiteBuyToken() =>
      (super.noSuchMethod(
            Invocation.method(#getPlusWebsiteBuyToken, []),
            returnValue: _i6.Future<String?>.value(),
            returnValueForMissingStub: _i6.Future<String?>.value(),
          )
          as _i6.Future<String?>);

  @override
  void dispose() => super.noSuchMethod(
    Invocation.method(#dispose, []),
    returnValueForMissingStub: null,
  );
}
// Copyright (c) 2024 Sharezone UG (haftungsbeschränkt)
// Licensed under the EUPL-1.2-or-later.
//
// You may obtain a copy of the Licence at:
// https://joinup.ec.europa.eu/software/page/eupl
//
// SPDX-License-Identifier: EUPL-1.2

// ignore_for_file: invalid_use_of_visible_for_testing_member

import 'package:clock/clock.dart';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:golden_toolkit/golden_toolkit.dart';
import 'package:sharezone_widgets/sharezone_widgets.dart';

import '../../../test/homework/homework_dialog_test.dart';
import '../../../test/homework/homework_dialog_test.mocks.dart';
import '../../../test/timetable/timetable_dialog_test.mocks.dart';
import '../../../test/timetable/timetable_dialog_tester.dart';

void main() {
  group('event add dialog', () {
    late MockEventDialogApi api;
    late MockSharezoneGateway sharezoneGateway;
    late MockCourseGateway courseGateway;
    late MockSharezoneContext sharezoneContext;

    setUp(() {
      sharezoneGateway = MockSharezoneGateway();
      courseGateway = MockCourseGateway();
      sharezoneContext = MockSharezoneContext();
      api = MockEventDialogApi();
    });

    TimetableDialogTester createDialogTester(WidgetTester tester) {
      return TimetableDialogTester(
        tester: tester,
        api: api,
        sharezoneContext: sharezoneContext,
        courseGateway: courseGateway,
        sharezoneGateway: sharezoneGateway,
      );
    }

    var lightTheme = (data: getLightTheme(), name: 'light');
    var darkTheme = (data: getDarkTheme(), name: 'dark');

    for (var testConfig in [
      (isExam: true, theme: lightTheme),
      (isExam: true, theme: darkTheme),
      (isExam: false, theme: lightTheme),
      (isExam: false, theme: darkTheme),
    ]) {
      testGoldens(
        'renders empty event dialog as expected (${testConfig.theme.name}, isExam: ${testConfig.isExam})',
        (tester) async {
          final dt = createDialogTester(tester);
          dt.addCourse(courseWith(id: 'fooId', name: 'Foo course'));

          await withClock(Clock.fixed(DateTime(2


key, value: $value}';
  }
}
import 'package:zikzak_inappwebview_internal_annotations/zikzak_inappwebview_internal_annotations.dart';

import '../in_app_webview/platform_webview.dart';
import '../types/in_app_webview_hit_test_result.dart';
import 'context_menu_item.dart';
import 'context_menu_settings.dart';

part 'context_menu.g.dart';

///Class that represents the WebView context menu. It used by [PlatformWebViewCreationParams.contextMenu].
@SupportedPlatforms(platforms: [
  AndroidPlatform(
      note:
          'To make it work properly on Android, JavaScript should be enabled!'),
  IOSPlatform()
])
@ExchangeableObject()
class ContextMenu_ {
  ///Event fired when the context menu for this WebView is being built.
  ///
  ///[hitTestResult] represents the hit result for hitting an HTML elements.
  final void Function(InAppWebViewHitTestResult_ hitTestResult)?
      onCreateContextMenu;

  ///Event fired when the context menu for this WebView is being hidden.
  final void Function()? onHideContextMenu;

  ///Event fired when a context menu item has been clicked.
  ///
  ///[contextMenuItemClicked] represents the [ContextMenuItem] clicked.
  final void Function(ContextMenuItem_ contextMenuItemClicked)?
      onContextMenuActionItemClicked;

  ///Use [settings] instead
  @Deprecated("Use settings instead")
  final ContextMenuOptions? options;

  ///Context menu settings.
  final ContextMenuSettings_? settings;

  ///List of the custom [ContextMenuItem].
  final List<ContextMenuItem_> menuItems;

  @ExchangeableObjectConstructor()
  ContextMenu_(
      {this.menuItems = const [],
      this.onCreateContextMenu,
      this.onHideContextMenu,
      @Deprecated("Use settings instead") this.options,
      this.settings,
      this.onContextMenuActionItemClicked});

  @ExchangeableObjectMethod(toMapMergeWith: true)
  // ignore: unused_element
  Map<String, dynamic> _toMapMergeWith() {
    return {
      "settings":
          (settings as ContextMenuSettings?)?.toMap() ?? options?.toMap()
    };
  }
}
// coverage:ignore-file
// GENERATED CODE - DO NOT MODIFY BY HAND
// ignore_for_file: type=lint
// ignore_for_file: unused_element, deprecated_member_use, deprecated_member_use_from_same_package, use_function_type_syntax_for_parameters, unnecessary_const, avoid_init_to_null, invalid_override_different_default_values_named, prefer_expression_function_bodies, annotate_overrides, invalid_annotation_target, unnecessary_question_mark

part of 'date_range.dart';

// **************************************************************************
// FreezedGenerator
// **************************************************************************

T _$identity<T>(T value) => value;

final _privateConstructorUsedError = UnsupportedError(
    'It seems like you constructed your class using `MyClass._()`. This constructor is only meant to be used by freezed and you are not supposed to need it nor use it.\nPlease check the documentation here for more information: https://github.com/rrousselGit/freezed#adding-getters-and-methods-to-our-models');

DateRange _$DateRangeFromJson(Map<String, dynamic> json) {
  return _DateRange.fromJson(json);
}

/// @nodoc
mixin _$DateRange {
  DateTime get end => throw _privateConstructorUsedError;
  DateTime get start => throw _privateConstructorUsedError;

  /// Serializes this DateRange to a JSON map.
  Map<String, dynamic> toJson() => throw _privateConstructorUsedError;

  /// Create a copy of DateRange
  /// with the given fields replaced by the non-null parameter values.
  @JsonKey(includeFromJson: false, includeToJson: false)
  $DateRangeCopyWith<DateRange> get copyWith =>
      throw _privateConstructorUsedError;
}

/// @nodoc
abstract class $DateRangeCopy


1.panel-group .panel-heading .accordion-toggle>[class*="icon-"]:first-child{width:16px}.accordion-style1.panel-group .panel-heading .accordion-toggle:hover>[class*="icon-"]:first-child{text-decoration:none}.accordion-style1.panel-group .panel-body,.accordion-style1.panel-group .collapse.in>.panel-body{border-top:1px solid #cdd8e3}.accordion-style1.panel-group.no-padding{padding:0}.accordion-style2.panel-group .panel{border-width:0}.accordion-style2.panel-group .panel:last-child{border-bottom-width:0}.accordion-style2.panel-group .panel+.panel{margin-top:4px}.accordion-style2.panel-group .panel .panel-body{border-top:0}.accordion-style2.panel-group .panel-heading .accordion-toggle{background-color:#edf3f7;border:2px solid #6eaed1;border-width:0 0 0 2px}.accordion-style2.panel-group .panel-heading .accordion-toggle:hover{text-decoration:none}.accordion-style2.panel-group .panel-heading .accordion-toggle.collapsed{background-color:#f3f3f3;color:#606060;border-width:0 0 0 1px;border-color:#d9d9d9}.accordion-style2.panel-group .panel-heading .accordion-toggle.collapsed:hover{background-color:#f6f6f6;color:#438eb9;text-decoration:none}.accordion-style2.panel-group .panel-body,.accordion-style2.panel-group .collapse.in>.panel-body{border-top:0}.accordion-style2.panel-group .accordion-style2.panel-group .panel{border-bottom:1px dotted #d9d9d9}.accordion-style2.panel-group .accordion-style2.panel-group .panel:last-child{border-bottom:0}.accordion-style2.panel-group .accordion-style2.panel-group .panel .panel-heading,.accordion-style2.panel-group .accordion-style2.panel-group .panel .panel-heading .accordion-toggle{background-color:transparent;border-width:0;font-size:13px;padding-top:6px;padding-bottom:8px}.accordion-style2.panel-group .accordion-style2.panel-group .panel .panel-heading{padding-top:0;padding-bottom:0}th,td,.table-bordered{border-radius:0!important}.table thead tr{color:#707070;font-weight:normal;background:#f2f2f2;background-image:-webkit-gradient(linear,left 0,left 100%,from(#f8f8f8),to(#ececec));background-image:-webkit-linear-gradient(top,#f8f8f8,0%,#ececec,100%);background-image:-moz-linear-gradient(top,#f8f8f8 0,#ececec 100%);background-image:linear-gradient(to bottom,#f8f8f8 0,#ececec 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff8f8f8',endColorstr='#ffececec',GradientType=0)}.table thead tr th{border-color:#DDD;font-weight:bold}.table thead tr th [class*="icon-"]:first-child{margin-right:2px}.table thead tr th:first-child{border-left-color:#f1f1f1}.table thead tr th:left-child{border-right-color:#f1f1f1}.table.table-bordered thead tr th{vertical-align:middle}.table.table-bordered thead tr th:first-child{border-left-color:#DDD}th.center,td.center{text-align:center}th .lbl,td .lbl{margin-bottom:0}th .lbl:only-child,td .lbl:


	// text doesn't have Content-Type by default
	if formType != "" {
		h.Set("Content-Type", formType)
	}
	// text doesn't have filename in Content-Disposition by default
	if formFileName == "" {
		h.Set("Content-Disposition",
			fmt.Sprintf(`form-data; name="%s"`, escapeQuotes(formKey)))
	} else {
		h.Set("Content-Disposition",
			fmt.Sprintf(`form-data; name="%s"; filename="%s"`,
				escapeQuotes(formKey), escapeQuotes(formFileName)))
	}
	part, err := w.Writer.CreatePart(h)
	if err != nil {
		return err
	}

	_, err = part.Write([]byte(formValue))
	return err
}

func (w *TFormDataWriter) writeCustomFile(formKey, formValue, formType, formFileName string) error {
	if w.Writer == nil {
		return errors.New("form-data writer not initialized")
	}
	fPath, err := filepath.Abs(formValue)
	if err != nil {
		return err
	}
	file, err := os.ReadFile(fPath)
	if err != nil {
		return err
	}

	if formType == "" {
		formType = inferFormType(formValue)
	}
	if formFileName == "" {
		formFileName = filepath.Base(formValue)
	}
	h := make(textproto.MIMEHeader)
	h.Set("Content-Type", formType)
	h.Set("Content-Disposition",
		fmt.Sprintf(`form-data; name="%s"; filename="%s"`,
			escapeQuotes(formKey), escapeQuotes(formFileName)))
	part, err := w.Writer.CreatePart(h)
	if err != nil {
		return err
	}

	_, err = part.Write(file)
	return err
}

func inferFormType(formValue string) string {
	extName := filepath.Ext(formValue)
	formType := mime.TypeByExtension(extName)
	if formType == "" {
		// file without extension name
		return "application/octet-stream"
	}
	if strings.HasPrefix(formType, "text") {
		// text/... types have the charset parameter set to "utf-8" by default.
		return strings.TrimSuffix(formType, "; charset=utf-8")
	}
	return formType
}

func multipartEncoder(formMap map[string]interface{}) (*TFormDataWriter, error) {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	tFormWriter := &TFormDataWriter{
		Writer:  writer,
		Payload: payload,
	}
	// e.g. formMap: {"file": "@\"$upload_file\";type=text/foo"}
	for formKey, formData := range formMap {
		formDataString := fmt.Sprintf("%v", formData)
		formItems := strings.Split(formDataString, ";")
		var isFilePath bool
		var formValue, formType, formFileName string
		for _, formItem := range formItems {
			if formItem == "" {
				continue
			}
			equalSignIndex := strings.Index(formItem, "=")
			// parse form value, e.g. @\"$upload_file\"
			if equalSignIndex == -1 {
				matchRes := regexUploadFilePath.FindStringSubmatch(formItem)
				if len(matchRes) > 1 {
					// formItem started with @, regarded as File path
					isFilePath = true
					formValue = strings.Trim(matchRes[1], "\"")
				} else {
					// formItem is not a valid File path, regarded as Text instead
					formValue = strings.TrimSuffix(strings.TrimPrefix(formItem, "\""), "\"")
				}
				continue
			}
			// parse form option, e.g. type=text/plain
			leftPart := strings.TrimSpace(formItem[:equalSignIndex])
			var rightPart string


      unit.insert_before(first);
            let mut cond = drive_cond(unit, first);
            let mut value = unit[first].args()[1];
            unit.delete_inst(first);

            // Accumulate subsequent drive conditions and values, and remove.
            for drive in drives {
                unit.insert_before(drive);
                let c = drive_cond(unit, drive);
                let v = unit[drive].args()[1];
                if cond != c {
                    cond = unit.ins().or(cond, c);
                }
                if value != v {
                    let vs = unit.ins().array(vec![value, v]);
                    value = unit.ins().mux(vs, c);
                }
                unit.delete_inst(drive);
            }

            // Build the final drive.
            unit.ins().drv_cond(target, value, delay, cond);
            modified = true;
        }
    }

    // TODO: Collapse drives with the same value and delay.
    // TODO: Build discriminator table for all drives, then build corresponding
    // mux to select driven value, and use or of all drive conditions as new
    // drive condition.

    modified
}

fn drive_cond(unit: &mut UnitBuilder, inst: Inst) -> Value {
    if unit[inst].opcode() == Opcode::DrvCond {
        unit[inst].args()[3]
    } else {
        unit.ins().const_int(IntValue::all_ones(1))
    }
}
<filename>chat_message/src/application/commands/save_message.rs
use crate::application::repos::chat_repo::ChatMessageRepository;
pub struct SaveHtmlMessageCommand{
    repo: Box<dyn ChatMessageRepository>,
}

impl SaveHtmlMessageCommand{
    fn new(repository: Box<dyn ChatMessageRepository>) -> Self {
        Self{
            repo: repository,
        }
    }
}<filename>src/game_push_fold.rs
use crate::interface::*;
use bincode::deserialize;
use once_cell::sync::Lazy;
use std::{fs::File, io::Read};

const FOLD: usize = 0;
const PUSH_CALL: usize = 1;

static WIN_FREQ_TABLE: Lazy<Vec<i32>> = Lazy::new(|| {
    let path = "static/headsup_preflop_equity.bin";
    let mut infile = File::open(path).expect(&format!("could not open '{}'", path));
    let mut buf = Vec::new();
    infile.read_to_end(&mut buf).unwrap();
    deserialize::<Vec<i32>>(&buf).unwrap()
});

pub struct PushFoldGame {
    effective_stack: f64,
}

#[derive(Clone)]
pub struct PushFoldNode {
    public_history: PublicHistory,
}

impl Game for PushFoldGame {
    type Node = PushFoldNode;

    #[inline]
    fn root() -> PushFoldNode {
        PushFoldNode {
            public_history: Vec::new(),
        }
    }

    #[inline]
    fn num_private_hands() -> usize {
        52 * 51 / 2
    }

    #[inline]
    fn evaluate(&self, node: &PushFoldNode, player: usize, pmi: &Vec<f64>) -> Vec<f64> {
        let num_hands_inv = (2. * 2.) / (52. * 51. * 50. * 49.);
        let num_board = (48 * 47 * 46 * 45 * 44) / (5 * 4 * 3 * 2);
        let num_board_inv = 1.0 / num_board as f64;

        // どちらかのプレイヤーがフォールド
        if node.public_history.last() == Some(&FOLD) {
            let pmi_sum = pmi.iter().sum::<f64>();
            let mut pmi_sum_ex = [0.0; 52];

            let mut k = 0;
            for i in 0..51 {
                for j in (i + 1)..52 {
                    pmi_sum_ex[i] += pmi[k];
                    pmi_sum_ex[j] += pmi[k];
                    k += 1;
                }
            }

            let payoff = match node.public_history.len() {
                1 => [-0.5, 0.


                manipulatedRequest.encodedBody() +
                manipulatedResponse.middle() +
                manipulatedResponse.encodedBody() +
                footer()
        )
    }

    private fun Response.middle() = ("\n```\n\n" +
        headerLine<Response>() + ":\n" +
        headerBlock() + "\n" +
        bodyLine<Response>() + " (${status.code}: ${(CONTENT_TYPE(this)?.toHeaderValue()
        .orEmpty())}):\n\n```\n"
        ).toByteArray()

    private fun Request.header() = ("## Interaction ${count.getAndIncrement()}: ${method.name} $uri\n\n" +
        headerLine<Request>() + ":\n" +
        headerBlock() + "\n" +
        bodyLine<Request>() + " (${CONTENT_TYPE(this)?.toHeaderValue() ?: ""}):\n" +
        "\n```\n").toByteArray()

    private fun footer() = "\n```\n\n".toByteArray()

    private fun HttpMessage.headerBlock() = "\n```\n${headers.joinToString("\n") {
        it.first + ": " + (it.second ?: "")
    }}\n```\n"

    private fun HttpMessage.encodedBody() =
        CONTENT_TYPE(this)
            ?.takeIf { options.isBinary(it) }
            ?.let { body.payload.array().base64EncodeArray() }
            ?: bodyString().toByteArray()
}

/**
 * Read HTTP traffic from disk in Servirtium markdown format.
 */
fun Replay.Companion.Servirtium(output: Supplier<ByteArray>, options: InteractionOptions = Defaults) = object : Replay {

    override fun requests() = output.parseInteractions { it.first }
        .map { req ->
            CONTENT_TYPE(req)
                ?.takeIf { options.isBinary(it) }
                ?.let { req.body(Body(req.bodyString().base64DecodedByteBuffer())) }
                ?: req
        }

    override fun responses() = output.parseInteractions { it.second }
        .map { req ->
            CONTENT_TYPE(req)
                .takeIf { options.isBinary(it) }
                ?.let { req.body(Body(req.bodyString().base64DecodedByteBuffer())) }
                ?: req
        }

    private fun <T : HttpMessage> Supplier<ByteArray>.parseInteractions(fn: (Pair<Request, Response>) -> T) =
        String(get())
            .split(Regex("## Interaction \\d+: "))
            .filter { it.contains("```") }
            .map {
                val sections = it.split("```").map { it.byteInputStream().reader().readLines() }

                val requestString = listOf(
                    listOf(sections[0][0] + " " + HTTP_1_1),
                    sections[1].dropWhile(String::isBlank) + "\r\n",
                    listOf(sections[3].dropWhile(String::isBlank).joinToString("\n"))
                ).flatten().joinToString("\r\n")

                val req = Request.parse(requestString)

                val resp = Response.parse(
                    listOf(
                        listOf(HTTP_1_1 +
                            " " +
                            sections[6].first { it.startsWith(bodyLine<Response>()) }.split('(', ':')[1] +
                            " "
                        ),
                        sections[5].dropWhile(String::isBlank) + "\r\n",
                        listOf(sections[7].dropWhile(String::isBlank).joinToString("\n"))
                    ).flatten().joinToString("\r\n")
                )
                req to resp
            }
            .map(fn)
            .asSequence()
}

private inline fun <reified T : HttpMessage> headerLine() = """### ${T::class.java.simpleName} headers recorded for playback"""
private inline fun <reified T : HttpMessage> bodyLine() = """### ${T::class.java.sim


{"육즙이 많은 범고래 스튜", nil, {"학살자 브무르글브름이 육즙이 많은 범고래 지방덩어리 7개를 구해달라고 부탁했습니다. 다 모으면 겨울지느러미 은신처에 있는 그에게 돌아가야 합니다."}},
[11565] = {"여벌 위장복", nil, {"멀록왕 므르글므르글의 여벌 위장복을 겨울지느러미 은신처에 있는 멀록왕 므르글므르글에게 돌려줘야 합니다."}},
[11566] = {"항복... 은 없다!", nil, {"겨울지느러미 은신처에 있는 멀록왕 므르글므르글이 클랙시무스의 집게발을 가져와 달라고 부탁했습니다."}},
[11567] = {"크발디르의 고대 갑옷", nil, {"크발디르의 고대 갑옷을 되찾은 다음 울부짖는 협만의 방패 언덕에 있는 카마구아의 오르푸스에게 전달해야 합니다."}},
[11568] = {"다시 안식으로", nil, {"방패 언덕의 파헤쳐진 무덤에서 브리쿨 유물 보따리를 사용해 이술도프의 얼어붙은 심장, 애시리테스의 방패, 폭풍 강타 지팡이와 크발디르의 고대 갑옷을 되돌려놔야 합니다.\n\n임무를 마치면 고대 승강장에 있는 카마구아의 오르푸스에게 돌아가십시오."}},
[11569] = {"열쇠지기 우름그르글", nil, {"겨울지느러미 동굴에 있는 글르글르글르가 우름그르글의 열쇠를 찾아와 달라고 부탁했습니다."}},
[11570] = {"겨울지느러미 동굴에서 탈출", nil, {"루르글브르를 안전한 곳까지 호위한 다음 겨울지느러미 은신처에 있는 멀록왕 므르글므르글에게 그 소식을 알려줘야 합니다."}},
[11571] = {"의사소통법 익�


#region
using System.Text.Json.Serialization;
using Vonage.Common.Serialization;
#endregion

namespace Vonage.Messages.WhatsApp;

/// <summary>
///     Represents a request to send a template message on Viber.
/// </summary>
public class WhatsAppTemplateRequest : WhatsAppMessageBase
{
    /// <summary>
    ///     The message template.
    /// </summary>
    [JsonPropertyOrder(10)]
    public MessageTemplate Template { get; set; }

    /// <summary>
    ///     The WhatsApp configuration.
    /// </summary>
    [J


MFI.getMaxCallFrameSize(), MaxAlign);
  MFI.setMaxCallFrameSize(MaxCFA);

  FrameSize = MaxCFA + alignTo(FrameSize, MaxAlign);
  MFI.setStackSize(FrameSize);

  bool AlignStack = (MaxAlign > getStackAlignment());

  // Get the number of bytes to allocate from the FrameInfo.
  unsigned NumBytes = MFI.getStackSize();
  unsigned SP = HRI.getStackRegister();
  unsigned MaxCF = MFI.getMaxCallFrameSize();
  MachineBasicBlock::iterator InsertPt = MBB.begin();

  SmallVector<MachineInstr *, 4> AdjustRegs;
  for (auto &MBB : MF)
    for (auto &MI : MBB)
      if (MI.getOpcode() == Hexagon::PS_alloca)
        AdjustRegs.push_back(&MI);

  for (auto MI : AdjustRegs) {
    assert((MI->getOpcode() == Hexagon::PS_alloca) && "Expected alloca");
    expandAlloca(MI, HII, SP, MaxCF);
    MI->eraseFromParent();
  }

  DebugLoc dl = MBB.findDebugLoc(InsertPt);

  if (hasFP(MF)) {
    insertAllocframe(MBB, InsertPt, NumBytes);
    if (AlignStack) {
      BuildMI(MBB, InsertPt, dl, HII.get(Hexagon::A2_andir), SP)
          .addReg(SP)
          .addImm(-int64_t(MaxAlign));
    }
    // If the stack-checking is enabled, and we spilled the callee-saved
    // registers inline (i.e. did not use a spill function), then call
    // the stack checker directly.
    if (EnableStackOVFSanitizer && !PrologueStubs)
      BuildMI(MBB, InsertPt, dl, HII.get(Hexagon::PS_call_stk))
             .addExternalSymbol("__runtime_stack_check");
  } else if (NumBytes > 0) {
    assert(alignTo(NumBytes, 8) == NumBytes);
    BuildMI(MBB, InsertPt, dl, HII.get(Hexagon::A2_addi), SP)
      .addReg(SP)
      .addImm(-int(NumBytes));
  }
}

void HexagonFrameLowering::insertEpilogueInBlock(MachineBasicBlock &MBB) const {
  MachineFunction &MF = *MBB.getParent();
  auto &HST = MF.getSubtarget<HexagonSubtarget>();
  auto &HII = *HST.getInstrInfo();
  auto &HRI = *HST.getRegisterInfo();
  unsigned SP = HRI.getStackRegister();

  MachineBasicBlock::iterator InsertPt = MBB.getFirstTerminator();
  DebugLoc dl = MBB.findDebugLoc(InsertPt);

  if (!hasFP(MF)) {
    MachineFrameInfo &MFI = MF.getFrameInfo();
    if (unsigned NumBytes = MFI.getStackSize()) {
      BuildMI(MBB, InsertPt, dl, HII.get(Hexagon::A2_addi), SP)
        .addReg(SP)
        .addImm(NumBytes);
    }
    return;
  }

  MachineInstr *RetI = getReturn(MBB);
  unsigned RetOpc = RetI ? RetI->getOpcode() : 0;

  // Handle EH_RETURN.
  if (RetOpc == Hexagon::EH_RETURN_JMPR) {
    BuildMI(MBB, InsertPt, dl, HII.get(Hexagon::L2_deallocframe))
        .addDef(Hexagon::D15)
        .addReg(Hexagon::R30);
    BuildMI(MBB, InsertPt, dl, HII.get(Hexagon::A2_add), SP)
        .addReg(SP)
        .addReg(Hexagon::R28);
    return;
  }

  // Check for RESTORE_DEALLOC_RET* tail call. Don't emit an extra dealloc-
  // frame instruction if we encounter it.
  if (RetOpc == Hexagon::RESTORE_DEALLOC_RET_JMP_V4 ||
      RetOpc == Hexagon::RESTORE_DEALLOC_RET_JMP_V4_PIC ||
      RetOpc == Hexagon::RESTORE_DEALLOC_RET_JMP_V4_EXT ||


                                        "minecraft:white_wool" => Voxel::colored(2, 0),
                                        "minecraft:grey_wool" => Voxel::colored(2, 1),
                                        "minecraft:green_wool" => Voxel::colored(2, 2),
                                        "minecraft:black_wool" => Voxel::colored(2, 3),
                                        "minecraft:blue_wool" => Voxel::colored(2, 4),
                                        "minecraft:brown_wool" => Voxel::colored(2, 5),
                                        "minecraft:cyan_wool" => Voxel::colored(2, 6),
                                        "minecraft:light_blue_wool" => Voxel::colored(2, 7),
                                        "minecraft:light_grey_wool" => Voxel::colored(2, 8),
                                        "minecraft:lime_wool" => Voxel::colored(2, 9),
                                        "minecraft:magenta_wool" => Voxel::colored(2, 10),
                                        "minecraft:orange_wool" => Voxel::colored(2, 11),
                                        "minecraft:pink_wool" => Voxel::colored(2, 12),
                                        "minecraft:purple_wool" => Voxel::colored(2, 13),
                                        "minecraft:red_wool" => Voxel::colored(2, 14),
                                        "minecraft:yellow_wool" => Voxel::colored(2, 15),
                                        "minecraft:grass_block" => Voxel::colored(0, 0),
                                        "minecraft:leaves" => Voxel::colored(1, 0),
                                        "minecraft:leaves2" => Voxel::colored(1, 0),
                                        _ => Voxel::with_id(1),
                                    };
                                    mutator.set(
                                        x + chunk_x as u32 * 16 + region_x as u32 * 512,
                                        y,
                                        z + chunk_z as u32 * 16 + region_y as u32 * 512,
                                        8192,
                                        voxel,
                                    );
                                }
                            }
                        }
                    }
                })
                .unwrap();
            println!("Region loaded: {} {}", region_x, region_y);
        };
        for x in -7..=5 {
            for y in -6..=4 {
                load_region(x, y);
            }
        }
        let file = std::fs::File::create("./test.oct").unwrap();
        let mut bufwriter = BufWriter::new(file);
        octree.write(&mut bufwriter).unwrap();
    });

    let mut bundle = RaytracerCameraBundle::default();
    bundle.transform.translation = Vec3::new(0.0, 0.0, 0.0);
    bundle.transform.look_at(Vec3::new(1.0, 1.0, 1.0), Vec3::Y);
    commands.spawn().insert_bundle(bundle).insert(FlyCamera {
        accel: 0.01,
        max_speed: 0.05,
        sensitivity: 1.0,
        ..Default::default()
    });
}

fn run(mut sunlight: ResMut<SunLight>, time: Res<Time>) {
    let (sin, cos) = (time.seconds_since_startup() * 2.0).sin_cos();
    sunlight.dir = Vec3::new(sin as f32 * 10.0, -15.0, cos as f32 * 10.0).normalize();
}
#![warn(
    // Lint g


271052;--color-scale-pink-0: #ffdaec;--color-scale-pink-1: #ffbedd;--color-scale-pink-2: #ff9bce;--color-scale-pink-3: #f778ba;--color-scale-pink-4: #db61a2;--color-scale-pink-5: #bf4b8a;--color-scale-pink-6: #9e3670;--color-scale-pink-7: #7d2457;--color-scale-pink-8: #5e103e;--color-scale-pink-9: #42062a;--color-scale-coral-0: #FFDDD2;--color-scale-coral-1: #FFC2B2;--color-scale-coral-2: #FFA28B;--color-scale-coral-3: #F78166;--color-scale-coral-4: #EA6045;--color-scale-coral-5: #CF462D;--color-scale-coral-6: #AC3220;--color-scale-coral-7: #872012;--color-scale-coral-8: #640D04;--color-scale-coral-9: #460701}}

/*# sourceMappingURL=dark_colorblind-b3e12335d5ff.css.map*/
    :root,[data-color-mode=light][data-light-theme=light],[data-color-mode=dark][data-dark-theme=light]{/*! */}:root,[data-color-mode=light][data-light-theme=light],[data-color-mode=dark][data-dark-theme=light]{--color-canvas-default-transparent: rgba(255,255,255,0);--color-page-header-bg: #f6f8fa;--color-marketing-icon-primary: #218bff;--color-marketing-icon-secondary: #54aeff;--color-diff-blob-addition-num-text: #24292f;--color-diff-blob-addition-fg: #24292f;--color-diff-blob-addition-num-bg: #CCFFD8;--color-diff-blob-addition-line-bg: #E6FFEC;--color-diff-blob-addition-word-bg: #ABF2BC;--color-diff-blob-deletion-num-text: #24292f;--color-diff-blob-deletion-fg: #24292f;--color-diff-blob-deletion-num-bg: #FFD7D5;--color-diff-blob-deletion-line-bg: #FFEBE9;--color-diff-blob-deletion-word-bg: rgba(255,129,130,0.4);--color-diff-blob-hunk-num-bg: rgba(84,174,255,0.4);--color-diff-blob-expander-icon: #57606a;--color-diff-blob-selected-line-highlight-mix-blend-mode: multiply;--color-diffstat-deletion-border: rgba(27,31,36,0.15);--color-diffstat-addition-border: rgba(27,31,36,0.15);--color-diffstat-addition-bg: #2da44e;--color-search-keyword-hl: #fff8c5;--color-prettylights-syntax-comment: #6e7781;--color-prettylights-syntax-constant: #0550ae;--color-prettylights-syntax-entity: #8250df;--color-prettylights-syntax-storage-modifier-import: #24292f;--color-prettylights-syntax-entity-tag: #116329;--color-prettylights-syntax-keyword: #cf222e;--color-prettylights-syntax-string: #0a3069;--color-prettylights-syntax-variable: #953800;--color-prettylights-syntax-brackethighlighter-unmatched: #82071e;--color-prettylights-syntax-invalid-illegal-text: #f6f8fa;--color-prettylights-syntax-invalid-illegal-bg: #82071e;--color-prettylights-syntax-carriage-return-text: #f6f8fa;--color-prettylights


// COPYRIGHT (C) Tom. ALL RIGHTS RESERVED.
// THE AntdUI PROJECT IS AN WINFORM LIBRARY LICENSED UNDER THE Apache-2.0 License.
// 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.
// GITCODE: https://gitcode.com/AntdUI/AntdUI
// GITEE: https://gitee.com/AntdUI/AntdUI
// GITHUB: https://github.com/AntdUI/AntdUI
// CSDN: https://blog.csdn.net/v_132
// QQ: 17379620

using System.Collections.Generic;
using System.Windows.Forms;

namespace Demo.Controls
{
    public partial class Dropdown : UserControl
    {
        Form form;
        public Dropdown(Form _form)
        {
            form = _form;
            InitializeComponent();
            button17.Items.Add(new AntdUI.SelectItem(Properties.Resources.bg1, " Hannibal"));
            dropdown1.Items.AddRange(new AntdUI.SelectItem[]
            {
                new AntdUI.SelectItem("one st menu item"),
                new AntdUI.SelectItem("


function( self, a )
  local si, ei, k, v = a:find( "([^=]+)=(.*)$" )
  if not k or not v then
    print( sf( "Error: invalid syntax in '%s'", a ) )
    return
  end
  local opt = self:_find_option( k )
  if not opt then
    print( sf( "Error: invalid option '%s'", k ) )
    return
  end
  local optv = opt.validator( v, opt.data )
  if optv == nil then
    print( sf( "Error: invalid value '%s' for option '%s'", v, k ) )
    return
  end
  return k, optv
end

-- Show help fo


uthy();
  });
});
///<reference path="pqueue.ts"/>
module ShortestPaths {
    export declare class Edge {
        source: number;
        target: number;
        length: number;
    }

    export function dijkstra(n: number, es: Edge[], start: number): number[] {
        return dijkstraNeighbours(getNeighbours(n, es), start);
    }

    export function johnsons(n: number, es: Edge[]): number[][] {
        var D = new Array(n), N = getNeighbours(n, es);
        for (var i = 0; i < n; ++i) {
            D[i] = dijkstraNeighbours(N, i);
        }
        return D;
    }

    class Neighbour {
        constructor(public id: number, public distance: number) {}
    }

    class Node {
        constructor(public id: number) {
            this.neighbours = [];
        }
        neighbours: Neighbour[];
        d: number;
        q: PairingHeap<Node>;
    }

    function getNeighbours(n: number, es: Edge[]): Node[] {
        var neighbours = new Array(n);
        var i = n; while (i--) neighbours[i] = new Node(i);

        i = es.length; while (i--) {
            var e = es[i];
            var u: number = e.source, v: number = e.target;
            var d = typeof e.length !== 'undefined' ? e.length : 1;
            neighbours[u].neighbours.push(new Neighbour(v, d));
            neighbours[v].neighbours.push(new Neighbour(u, d));
        }
        return neighbours;
    };

    function dijkstraNeighbours(neighbours: Node[], start: number): number[] {
        var q = new PriorityQueue<Node>((a, b) => a.d <= b.d),
            i = neighbours.length,
            d: number[] = new Array(i);
        while (i--) {
            var node: Node = neighbours[i];
            node.d = i === start ? 0 : Number.MAX_VALUE;
            node.q = q.push(node);
        }
        while (!q.empty()) {
            // console.log(q.toString(function (u) { return u.id + "=" + (u.d === Number.MAX_VALUE ? "\u221E" : u.d) }));
            var u = q.pop();
            d[u.id] = u.d;
            i = u.neighbours.length; while (i--) {
                var neighbour = u.neighbours[i];
                var v = neighbours[neighbour.id];
                var t = u.d + neighbour.distance;
                if (u.d !== Number.MAX_VALUE && v.d > t) {
                    v.d = t;
                    v.q = q.reduceKey(v.q, v);
                }
            }
        }
        return d;
    }
}import { expect } from "chai";
import "mocha";
import { DataFrame } from "data-forge";
import "../index";

describe("data-forge-plot - dataframe configuration", () => {

    it("plot dataframe with no configuration", ()  => {

        const series = new DataFrame({ index: [1, 2, 3], values: [{ A: 10 }, { A: 20 }, { A: 30 } ] });
        const plotAPI = series.plot();
        expect(plotAPI.serialize()).to.eql({
            data: {
                columnOrder: [
                    "A",
                    "__index__",
                ],
                columns: {
                    A: "number",
                    __index__: "number",
                },


.Run("withInt", func(t *testing.T) {
		t.Parallel()
		i, err := test.WithInt(impl.AsTestCustomIface(), 3).Int(ctx)
		require.NoError(t, err)
		require.Equal(t, 3, i)
	})
	t.Run("intList", func(t *testing.T) {
		t.Parallel()
		ints, err := test.IntList(ctx, impl.AsTestCustomIface())
		require.NoError(t, err)
		require.Equal(t, []int{1, 2}, ints)
	})
	t.Run("withIntList", func(t *testing.T) {
		t.Parallel()
		ints, err := test.WithIntList(impl.AsTestCustomIface(), []int{3, 4}).IntList(ctx)
		require.NoError(t, err)
		require.Equal(t, []int{3, 4}, ints)
	})

	t.Run("bool", func(t *testing.T) {
		t.Parallel()
		b, err := test.Bool(ctx, impl.AsTestCustomIface())
		require.NoError(t, err)
		require.Equal(t, true, b)
	})
	t.Run("withBool", func(t *testing.T) {
		t.Parallel()
		b, err := test.WithBool(impl.AsTestCustomIface(), false).Bool(ctx)
		require.NoError(t, err)
		require.Equal(t, false, b)
	})
	t.Run("boolList", func(t *testing.T) {
		t.Parallel()
		bools, err := test.BoolList(ctx, impl.AsTestCustomIface())
		require.NoError(t, err)
		require.Equal(t, []bool{true, false}, bools)
	})
	t.Run("withBoolList", func(t *testing.T) {
		t.Parallel()
		bools, err := test.WithBoolList(impl.AsTestCustomIface(), []bool{false, true}).BoolList(ctx)
		require.NoError(t, err)
		require.Equal(t, []bool{false, true}, bools)
	})

	t.Run("withMany", func(t *testing.T) {
		t.Parallel()
		iface := test.
			WithStr(impl.AsTestCustomIface(), "c").
			WithInt(3).
			WithBool(true)

		str, err := iface.Str(ctx)
		require.NoError(t, err)
		require.Equal(t, "c", str)

		i, err := iface.Int(ctx)
		require.NoError(t, err)
		require.Equal(t, 3, i)

		b, err := iface.Bool(ctx)
		require.NoError(t, err)
		require.Equal(t, true, b)
	})

	t.Run("obj", func(t *testing.T) {
		t.Parallel()
		dir := test.Obj(impl.AsTestCustomIface())
		dirEnts, err := dir.Entries(ctx)
		require.NoError(t, err)
		require.Contains(t, dirEnts, "file1")
	})

	t.Run("withObj", func(t *testing.T) {
		t.Parallel()
		dir := test.WithObj(impl.AsTestCustomIface(), dirs[1]).Obj()
		dirEnts, err := dir.Entries(ctx)
		require.NoError(t, err)
		require.Contains(t, dirEnts, "file2")
	})

	t.Run("objList", func(t *testing.T) {
		t.Parallel()
		dirs, err := test.ObjList(ctx, impl.AsTestCustomIface())
		require.NoError(t, err)
		require.Len(t, dirs, 2)
		dirEnts1, err := dirs[0].Entries(ctx)
		require.NoError(t, err)
		req


       return Response({'access': str(new_access_token), 'refresh': str(new_refresh_token)}, status=status.HTTP_200_OK)
        except ValidationError as e:
            exception_log(e, __file__)
            return Response({"info": 'REFRESH_TOKEN_VALIDATION_ERROR', "details": e.detail}, status=status.HTTP_400_BAD_REQUEST)
        except TokenError as e:
            exception_log(e, __file__)
            return Response({"info": "INVALID_REFRESH_TOKEN", "details": str(e)}, status=status.HTTP_400_BAD_REQUEST)
        except Exception as e:
            exception_log(e, __file__)
            return Response({"info": "ERROR_REFRESHING_TOKEN", "details": str(e)}, status=status.HTTP_400_BAD_REQUEST)


#pragma once

// @generated by torchgen/gen.py from NativeFunction.h

#include <c10/core/Scalar.h>
#include <c10/core/Storage.h>
#include <c10/core/TensorOptions.h>
#include <c10/util/Deprecated.h>
#include <c10/util/Optional.h>
#include <c10/core/QScheme.h>
#include <ATen/core/Reduction.h>
#include <ATen/core/Tensor.h>
#include <tuple>
#include <vector>

namespace at {
namespace native {
TORCH_API at::Tensor logsumexp(const at::Tensor & self, at::IntArrayRef dim, bool keepdim=false);
TORCH_API at::Tensor & logsumexp_out(const at::Tensor & self, at::IntArrayRef dim, bool keepdim, at::Tensor & out);
TORCH_API at::Tensor logsumexp(const at::Tensor & self, at::DimnameList dim, bool keepdim=false);
TORCH_API at::Tensor & logsumexp_out(const at::Tensor & self, at::DimnameList dim, bool keepdim, at::Tensor & out);
} // namespace native
} // namespace at


1790 ${`\u001b[${32}m${`PUSH`}\u001b[${39}m`} [${stageFrom}, ${stageTo}, ${JSON.stringify(
                      stageAdd,
                      null,
                      4,
                    )}]`,
                  );

                // We're not done yet. We are currently located on a potential
                // break point,
                // countCharactersPerLine -
                // (stageTo - stageFrom - whatToAddLength) - 1 ===
                // resolvedOpts.lineLengthLimit ?

                if (
                  countCharactersPerLine -
                    (stageTo - stageFrom - whatToAddLength) -
                    1 ===
                  resolvedOpts.lineLengthLimit
                ) {
                  DEV &&
                    console.log(`1810 ${`\u001b[${34}m${`██`}\u001b[${39}m`}`);
                  finalIndexesToDelete.push(i, i, lineEnding);
                  DEV &&
                    console.log(
                      `1814 ${`\u001b[${32}m${`PUSH`}\u001b[${39}m`} [${i}, ${i}, ${JSON.stringify(
                        lineEnding,
                        null,
                        0,
                      )}]`,
                    );
                  countCharactersPerLine = 0;
                  DEV &&
                    console.log(
                      `1823 ${`\u001b[${31}m${`RESET`}\u001b[${39}m`} countCharactersPerLine = 0`,
                    );
                }

                // reset
                stageFrom = null;
                stageTo = null;
                stageAdd = null;
                DEV && console.log(`1831 RESET all stage vars`);
              }
            } else {
              DEV && console.log(`1834 BUT NO STAGED FOUND`);
              //
              finalIndexesToDelete.push(i, i, lineEnding);
              DEV &&
                console.log(
                  `1839 ${`\u001b[${32}m${`PUSH`}\u001b[${39}m`} [${i}, ${i}, ${JSON.stringify(
                    lineEnding,
                    null,
                    0,
                  )}]`,
                );
              countCharactersPerLine = 0;
              DEV &&
                console.log(
                  `1848 ${`\u001b[${31}m${`RESET`}\u001b[${39}m`} countCharactersPerLine = 0`,
                );
            }
          } else if (
            str[i + 1] &&
            CHARS_BREAK_ON_THE_RIGHT_OF_THEM.includes(str[i]) &&
            isStr(tagName) &&
            Array.isArray(resolvedOpts.mindTheInlineTags) &&
            resolvedOpts.mindTheInlineTags.length &&
            !resolvedOpts.mindTheInlineTags.includes(tagName)
          ) {
            // ██ 2.
            //
            DEV &&
              console.log(
                `1863 ${`\u001b[${36}m${`██ LIMIT (${resolvedOpts.lineLengthLimit}) EXCEEDED`}\u001b[${39}m`} break on the right of this character`,
              );
            if (
              stageFrom !== null &&
              stageTo !== null &&
              (stageFrom !== stageTo || stageAdd?.length)
            ) {
              DEV && console.log(`1870 FOUND STAGED`);
            } else {
              DEV && console.log(`1872 BUT NO STAGED FOUND`);
              //
              finalIndexesToDelete.push(i + 1, i + 1, lineEnding);
              DEV &&
                console.log(
                  `1877 ${`\u001b[${32}m${`PUSH`}\u001b[${39}m`} [${i + 1}, ${
                    i + 1
                  }, ${JSON.stringify(lineEnding, null, 0)}]`,
                );
              countCharactersPerLine = 0;
              DEV &&
                console.log(
                  `1884 ${`\u001b[${31}m${`RESET`}\u001b[${39}m`} countCharactersPerLine = 0`,
                );
            }


bPageQueryDTO.builder()
                .page(1)
                .pageSize(1)
                .driverId(userId)
                .statusList(List.of(DriverJobStatus.PROCESSING))
                .build();
        PageResponse<DriverJobDTO> pageResponse = driverJobFeign.pageQuery(pageQueryDTO);
        if (CollUtil.isEmpty(pageResponse.getItems())) {
            return true;
        }

        //3. 对关联的运输任务上报位置
        return trackFeign.uploadFromTruck(pageResponse.getItems().get(0).getTransportTaskId(), Double.parseDouble(lng), Double.parseDouble(lat));
    }
}
package com.sl.ms.web.driver.vo.response;

import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.time.LocalDateTime;
import java.util.List;

/**
 * 司机作业单详情
 * @author ZJL
 */
@Data
@ApiModel("司机作业单详情")
public class DriverJobDetailVO {

    @ApiModelProperty(value = "司机作业单id")
    private String id;

    @ApiModelProperty(value = "起始机构id")
    private String startAgencyId;

    @ApiModelProperty(value = "起始省份")
    private String startProvince;

    @ApiModelProperty(value = "起始市")
    private String startCity;

    @ApiModelProperty(value = "起始机构详细地址")
    private String startAddress;

    @ApiModelProperty(value = "目的机构id")
    private String endAgencyId;

    @ApiModelProperty(value = "目的省份")
    private String endProvince;

    @ApiModelProperty(value = "目的市")
    private String endAddress;

    @ApiModelProperty(value = "目的机构详细地址")
    private String endCity;

    @ApiModelProperty(value = "作业状态，1为待提货）、2为在途）、3为改派）、4为已交付）、5为已作废")
    private Integer status;

    @ApiModelProperty(value = "司机id")
    private String driverId;

    @ApiModelProperty(value = "运输任务id")
    private String transportTaskId;

    @ApiModelProperty(value = "提货对接人")
    private String startHandover;

    @ApiModelProperty(value = "提货对接人电话")
    private String startHandoverPhone;

    @ApiModelProperty(value = "交付对接人")
    private String finishHandover;

    @ApiModelProperty(value = "交付对接人电话")
    private String finishHandoverPhone;

    @ApiModelProperty(value = "计划发车时间")
    @JsonFormat(
            pattern = "yyyy-MM-dd HH:mm:ss"
    )
    private LocalDateTime planDepartureTime;

    @ApiModelProperty(value = "实际发车时间")
    @JsonFormat(
            pattern = "yyyy-MM-dd HH:mm:ss"
    )
    private LocalDateTime actualDepartureTime;

    @ApiModelProperty(value = "计划到达时间")
    @JsonFormat(
            pattern = "yyyy-MM-dd HH:mm:ss"
    )
    private LocalDateTime planArrivalTime;

    @ApiModelProperty(value = "实际到达时间")
    @JsonFormat(
            pattern = "yyyy-MM-dd HH:mm:ss"
    )
    private LocalDateTime actualArrivalTime;

    @ApiModelProperty(value


        return stat > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) stat;
    }

    public double getCurrentMulti() {
        return (double) getFullAttribute(0) / data.STR;

    }

    public int getMaxBody() {
        return JRMCoreH.stat(data.player, 2, data.Powertype, 2, data.CON, data.Race, data.Class, 0);
    }

    public int getMaxStamina() {
        return JRMCoreH.stat(data.player, 2, data.Powertype, 3, data.CON, data.Race, data.Class, 0);
    }

    public int getMaxKi() {
        return JRMCoreH.stat(data.player, 5, data.Powertype, 5, data.SPI, data.Race, data.Class, JRMCoreH.SklLvl_KiBs(data.Skills.split(","), 1));
    }

    public int getMaxFusionBody() {
        int con = data.CON;
        if (isFused()) {
            EntityPlayer spectator = getSpectatorEntity();
            if (spectator != null) {
                DBCData specData = DBCData.get(spectator);
                con = Math.min(data.CON, specData.CON) * 2;
            }
        }
        return JRMCoreH.stat(data.player, 2, data.Powertype, 2, con, data.Race, data.Class, 0);
    }

    public int getMaxFusionStamina() {
        int con = data.CON;
        if (isFused()) {
            EntityPlayer spectator = getSpectatorEntity();
            if (spectator != null) {
                DBCData specData = DBCData.get(spectator);
                con = Math.min(data.CON, specData.CON) * 2;
            }
        }
        return JRMCoreH.stat(data.player, 2, data.Powertype, 3, con, data.Race, data.Class, 0);
    }

    public int getMaxFusionKi() {
        int spi = data.SPI;
        if (isFused()) {
            EntityPlayer spectator = getSpectatorEntity();
            if (spectator != null) {
                DBCData specData = DBCData.get(spectator);
                spi = Math.min(data.SPI, specData.SPI) * 2;
            }
        }
        return JRMCoreH.stat(data.player, 5, data.Powertype, 5, spi, data.Race, data.Class, JRMCoreH.SklLvl_KiBs(data.player, 1));
    }

    public float getCurrentBodyPercentage() {
        if (isFused())
            return (data.Body * 100) / (float) getMaxFusionBody();

        return (data.Body * 100) / (float) getMaxBody();
    }

    // Negative Values will Drain instead
    public void restoreKiPercent(float percToRestore) {
        int maxKi = isFused() ? getMaxFusionKi() : getMaxKi();
        int toAdd = (int) (maxKi * (percToRestore / 100));

        data.Ki = ValueUtil.clamp(data.Ki + toAdd, 0, maxKi);
        data.getRawCompound().setInteger("jrmcEnrgy", data.Ki);
    }

    public void restoreKiFlat(int amountToRestore) {
        int maxKi = isFused() ? getMaxFusionKi() : getMaxKi();
        data.Ki = ValueUtil.clamp(data.Ki + amountToRestore, 0, maxKi);
        data.getRawCompound().setInteger("jrmcEnrgy", data.Ki);
    }

    public void restoreHealthPercent(float percToRestore) {
        int maxBody = isFused() ? getMaxFusionBody() : getMaxBody();
        int toAdd = (int) (maxBody * (percToRestore / 100));

        data.Body = ValueUtil.clamp(data.Body + toAdd, 0, maxBody);
        data.getRawCompoun


 'Font Awesome 5 Brands';
  font-weight: 400; }

.fa.fa-etsy {
  font-family: 'Font Awesome 5 Brands';
  font-weight: 400; }

.fa.fa-imdb {
  font-family: 'Font Awesome 5 Brands';
  font-weight: 400; }

.fa.fa-ravelry {
  font-family: 'Font Awesome 5 Brands';
  font-weight: 400; }

.fa.fa-eercast {
  font-family: 'Font Awesome 5 Brands';
  font-weight: 400; }

.fa.fa-eercast:before {
  content: "\f2da"; }

.fa.fa-snowflake-o {
  font-family: 'Font Awesome 5 Free';
  font-weight: 400; }

.fa.fa-snowflake-o:before {
  content: "\f2dc"; }

.fa.fa-superpowers {
  font-family: 'Font Awesome 5 Brands';
  font-weight: 400; }

.fa.fa-wpexplorer {
  font-family: 'Font Awesome 5 Brands';
  font-weight: 400; }

.fa.fa-cab:before {
  content: "\f1ba"; }
/**
 * ====================================================================
 * @title: Eclipse MoonRise UI Theme (standalone)
 * @author: Andrea Guarinoni
 * @version: 0.8.9
 * @target-platform: WIN
 * @style-type: Main
 * ====================================================================
 */
/* @import url("moonrise-ui-standalone.css"); */
/* @import url("moonrise-ui_[WIN-patch].css"); */

/* [Eclipse Bug 423744]:
 * Importing a local resource throws a MalformedURLException because the
 * resource directory is hard-coded to point to 'platform:/plugin/org.eclipse.platform/'
 * Basic workaround for stylesheet imports: copy-pasting the whole content of the file that should be imported */

/* >>>>>>>>>>>>> content of 'moonrise-ui-standalone.css' >>>>>>>>>>>>>>>>>> */

	/**
	 * ====================================================================
	 * @title: Eclipse MoonRise UI Theme (standalone)
	 * @author: Andrea Guarinoni
	 * @version: 0.8.9
	 * @target-platform: Generic
	 * @style-type: Main
	 * ====================================================================
	 */

	.MTrimmedWindow.topLevel {
	    margin-top: 4px;
	    margin-bottom: 2px;
	    margin-left: 2px;
	    margin-right: 2px;
	}

	.MPartStack {
	    background-color: #313538;
	    color: #f7f8f8;
	    swt-tab-renderer: url('bundleclass://org.eclipse.e4.ui.workbench.renderers.swt/org.eclipse.e4.ui.workbench.renderers.swt.CTabRendering');

	    swt-tab-height: 32px;

	    padding: 1px 6px 6px 6px; /* top left bottom right */
	    swt-tab-outline: #3B4042; /* border color for selected tab */
	    swt-outer-keyline-color: #515658; /* border color for whole tabs container */
	    swt-unselected-tabs-color: #515658 #464649 #313538 99% 100%; /* title background for unselected tab */
	    swt-selected-tab-fill: #313538; /* title background for selected tab (gradient bottom color) */

	    swt-shadow-color: #0b0b0b;
	    swt-shadow-visible: true;

	    swt-mru-visible: true;

	    swt-corner-radius: 16px;
	}

	.MPartStack.active {
	    background-color: #292929;   /* ignored (<2>) */
	    swt-inner-keyline-color: #FFFFFF;
	    swt-tab-outline: #484848; /* border color for selected tab */
	    swt-outer-keyline-color: #4B4C4F; /* border color for whole tabs container */
	    swt-unselected-tabs-color: #494A4D #404043 #27


A2D24  38 C1 00 0C */	addi r6, r1, 0xc
/* 800A70C8 000A2D28  3B E0 FF FF */	li r31, -1
/* 800A70CC 000A2D2C  38 A0 00 03 */	li r5, 3
/* 800A70D0 000A2D30  48 1A CD BD */	bl func_80253E8C
/* 800A70D4 000A2D34  80 61 00 0C */	lwz r3, 0xc(r1)
/* 800A70D8 000A2D38  38 03 FF E3 */	addi r0, r3, -29
/* 800A70DC 000A2D3C  28 00 00 07 */	cmplwi r0, 7
/* 800A70E0 000A2D40  41 81 01 A0 */	bgt lbl_800A7280
/* 800A70E4 000A2D44  3C 60 80 41 */	lis r3, lbl_8040F280@ha
/* 800A70E8 000A2D48  54 00 10 3A */	slwi r0, r0, 2
/* 800A70EC 000A2D4C  38 63 F2 80 */	addi r3, r3, lbl_8040F280@l
/* 800A70F0 000A2D50  7C 63 00 2E */	lwzx r3, r3, r0
/* 800A70F4 000A2D54  7C 69 03 A6 */	mtctr r3
/* 800A70F8 000A2D58  4E 80 04 20 */	bctr
/* 800A70FC 000A2D5C  7F A3 EB 78 */	mr r3, r29
/* 800A7100 000A2D60  7F C4 F3 78 */	mr r4, r30
/* 800A7104 000A2D64  38 A0 00 02 */	li r5, 2
/* 800A7108 000A2D68  38 C0 30 A1 */	li r6, 0x30a1
/* 800A710C 000A2D6C  48 1A CD A9 */	bl func_80253EB4
/* 800A7110 000A2D70  48 00 01 70 */	b lbl_800A7280
/* 800A7114 000A2D74  7F A3 EB 78 */	mr r3, r29
/* 800A7118 000A2D78  7F C4 F3 78 */	mr r4, r30
/* 800A711C 000A2D7C  38 A0 00 02 */	li r5, 2
/* 800A7120 000A2D80  38 C0 30 A2 */	li r6, 0x30a2
/* 800A7124 000A2D84  48 1A CD 91 */	bl func_80253EB4
/* 800A7128 000A2D88  48 00 01 58 */	b lbl_800A7280
/* 800A712C 000A2D8C  3C 60 51 EC */	lis r3, 0x51EB851F@ha
/* 800A7130 000A2D90  A0 1C 00 8A */	lhz r0, 0x8a(r28)
/* 800A7134 000A2D94  38 63 85 1F */	addi r3, r3, 0x51EB851F@l
/* 800A7138 000A2D98  3B E0 00 00 */	li r31, 0
/* 800A713C 000A2D9C  7C 03 00 96 */	mulhw r0, r3, r0
/* 800A7140 000A2DA0  38 60 00 17 */	li r3, 0x17
/* 800A7144 000A2DA4  7C 00 2E 70 */	srawi r0, r0, 5
/* 800A7148 000A2DA8  54 04 0F FE */	srwi r4, r0, 0x1f
/* 800A714C 000A2DAC  7C 80 22 14 */	add r4, r0, r4
/* 800A7150 000A2DB0


pi)"},	{0x15ed,R"(pa)"},	{0x15ee,R"(p)"},	{0x15ef,R"(gu)"},	{0x15f0,R"(go)"},	{0x15f1,R"(ge)"},	{0x15f2,R"(gee)"},
		{0x15f3,R"(gi)"},	{0x15f4,R"(ga)"},	{0x15f5,R"(khu)"},	{0x15f6,R"(kho)"},	{0x15f7,R"(khe)"},	{0x15f8,R"(khee)"},	{0x15f9,R"(khi)"},	{0x15fa,R"(kha)"},
		{0x15fb,R"(kku)"},	{0x15fc,R"(kko)"},	{0x15fd,R"(kke)"},	{0x15fe,R"(kkee)"},
		{0x1600,R"(kka)"},	{0x1601,R"(kk)"},	{0x1602,R"(nu)"},	{0x1603,R"(no)"},
		{0x1604,R"(ne)"},	{0x1605,R"(nee)"},	{0x1606,R"(ni)"},	{0x1607,R"(na)"},	{0x1608,R"(mu)"},	{0x1609,R"(mo)"},	{0x160a,R"(me)"},	{0x160b,R"(mee)"},
		{0x160c,R"(mi)"},	{0x160d,R"(ma)"},	{0x160e,R"(yu)"},	{0x160f,R"(yo)"},	{0x1610,R"(ye)"},	{0x1611,R"(yee)"},	{0x1612,R"(yi)"},	{0x1613,R"(ya)"},
		{0x1614,R"(ju)"},	{0x1615,R"(ju)"},	{0x1616,R"(jo)"},	{0x1617,R"(je)"},	{0x1618,R"(jee)"},	{0x1619,R"(ji)"},	{0x161a,R"(ji)"},	{0x161b,R"(ja)"},
		{0x161c,R"(jju)"},	{0x161d,R"(jjo)"},	{0x161e,R"(jje)"},	{0x161f,R"(jjee)"},	{0x1620,R"(jji)"},	{0x1621,R"(jja)"},	{0x1622,R"(lu)"},	{0x1623,R"(lo)"},
		{0x1624,R"(le)"},	{0x1625,R"(lee)"},	{0x1626,R"(li)"},	{0x1627,R"(la)"},	{0x1628,R"(dlu)"},	{0x1629,R"(dlo)"},	{0x162a,R"(dle)"},	{0x162b,R"(dlee)"},
		{0x162c,R"(dli)"},	{0x162d,R"(dla)"},	{0x162e,R"(lhu)"},	{0x162f,R"(lho)"},	{0x1630,R"(lhe)"},	{0x1631,R"(lhee)"},	{0x1632,R"(lhi)"},	{0x1633,R"(lha)"},
		{0x1634,R"(tlhu)"},	{0x1635,R"(tlho)"},	{0x1636,R"(tlhe)"},	{0x1637,R"(tlhee)"},	{0x1638,R"(tlhi)"},	{0x1639,R"(tlha)"},	{0x163a,


 logrusx.New("discarding config logger", "", logrusx.UseLogger(l)),
		Koanf:             koanf.NewWithConf(koanf.Conf{Delim: Delimiter, StrictMerge: true}),
	}

	for _, m := range modifiers {
		m(p)
	}

	providers, err := p.createProviders(ctx)
	if err != nil {
		return nil, err
	}

	p.providers = providers

	k, err := p.newKoanf()
	if err != nil {
		return nil, err
	}

	p.replaceKoanf(k)
	return p, nil
}

func (p *Provider) SkipValidation() bool {
	return p.skipValidation
}

func (p *Provider) createProviders(ctx context.Context) (providers []koanf.Provider, err error) {
	defaultsProvider, err := NewKoanfSchemaDefaults(p.schema, p.validator)
	if err != nil {
		return nil, err
	}
	providers = append(providers, defaultsProvider)

	// Workaround for https://github.com/knadh/koanf/pull/47
	for _, t := range p.baseValues {
		providers = append(providers, NewKoanfConfmap([]tuple{t}))
	}

	paths := p.files
	if p.flags != nil {
		p, _ := p.flags.GetStringSlice(FlagConfig)
		paths = append(paths, p...)
	}

	p.logger.WithField("files", paths).Debug("Adding config files.")

	c := make(watcherx.EventChannel)

	defer func() {
		if err == nil && len(paths) > 0 {
			go p.watchForFileChanges(ctx, c)
		}
	}()
	for _, path := range paths {
		fp, err := NewKoanfFile(path)
		if err != nil {
			return nil, err
		}

		if _, err := fp.WatchChannel(ctx, c); err != nil {
			return nil, err
		}

		providers = append(providers, fp)
	}

	providers = append(providers, p.userProviders...)

	if p.flags != nil {
		pp, err := NewPFlagProvider(p.schema, p.validator, p.flags, p.Koanf)
		if err != nil {
			return nil, err
		}
		providers = append(providers, pp)
	}

	if !p.disableEnvLoading {
		envProvider, err := NewKoanfEnv("", p.schema, p.validator)
		if err != nil {
			return nil, err
		}
		providers = append(providers, envProvider)
	}

	// Workaround for https://github.com/knadh/koanf/pull/47
	for _, t := range p.forcedValues {
		providers = append(providers, NewKoanfConfmap([]tuple{t}))
	}

	return providers, nil
}

func (p *Provider) replaceKoanf(k *koanf.Koanf) {
	p.Koanf = k
}

func (p *Provider) validate(k *koanf.Koanf) error {
	if p.skipValidation {
		return nil
	}

	out, err := k.Marshal(json.Parser())
	if err != nil {
		return errors.WithStack(err)
	}
	if err := p.validator.Validate(bytes.NewReader(out)); err != nil {
		p.onValidationError(k, err)
		return err
	}

	return nil
}

// newKoanf creates a new koanf instance with all the updated config
//
// This is unfortunately required due to several limitations / bugs in koanf:
//
// - https://github.com/knadh/koanf/issues/77
// - https://github.com/knadh/koanf/pull/47
func (p *Provider) newKoanf() (_ *koanf.Koanf, err error) {
	k := ko


List.push(todo);
  }

  //Get all todos
  getTodos(): ITodo[] {
    return this.TodoList;
  }

}
import mongoose from "mongoose";

interface TodoI {
    title: string;
    description: string;
}

interface TodoDocument extends mongoose.Document {
    title: string;
    description: string;
}

const todoSchema = new mongoose.Schema({
    title: {
        type: String,
        require: true,
    },
    description: {
        type: String,
        require: false,
    },
});

interface todoModelInterface extends mongoose.Model<TodoDocument> {
    set(x: TodoI): TodoDocument;
}

todoSchema.statics.set = (x: TodoI) => {
    return new Todo(x);
}

const Todo = mongoose.model<TodoDocument, todoModelInterface>('Todo', todoSchema);

Todo.set({
    title: "Some title",
    description: "Some description",
});

export { Todo }
// Method for Generating random password
export default function generatePassword(): string {
      const alphaCaps = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
      const alphaSmall = "abcdefghijklmnopqrstuvwxyz";
      const specialChars = "!%&@#$^*?_~";
      const numbers = "1234567890";
      let password = '';
      password = [alphaCaps, alphaSmall, specialChars, numbers].reduce((acc, cur)=>
        acc += createString(cur, 2), password);
      return password;
    }
    const createString = (stringSource, strlength) : string => {
      let temp = "";
      for( let i=0; i<strlength; i++) {
        const index = Math.floor(Math.random() * stringSource.length);
        temp += stringSource.charAt(index);
      }
      return temp;
}
import { expect, tap } from '@pushrocks/tapbundle';
import * as smartfuzzy from '../ts/index';

let testSmartfuzzy: smartfuzzy.Smartfuzzy;

tap.test('should create an instance of Smartfuzzy', async () => {
  testSmartfuzzy = new smartfuzzy.Smartfuzzy([
    'Sony',
    'Deutsche Bahn',
    'Apple Inc.',
    "Trader Joe's"
  ]);
  expect(testSmartfuzzy).to.be.instanceof(smartfuzzy.Smartfuzzy);
});

tap.test('should compute a score', async () => {
  const result = testSmartfuzzy.getChangeScoreForString('Apple');
  console.log(result);
});

tap.test('should get closest match', async () => {
  const result = testSmartfuzzy.getClosestMatchForString('Apple');
  console.log(result);
});

tap.test('should sort objects', async () => {
  class Car {
    constructor(public brand: string) {}
  }

  let testObjectSorter: smartfuzzy.ObjectSorter<Car>;

  testObjectSorter = new smartfuzzy.ObjectSorter([
    new Car('BMW'),
    new Car('Mercedes Benz'),
    new Car('Volvo')
  ]);

  const result = testObjectSorter.sort('Volvo', ['brand']);
  console.log(result);
});

tap.start();
export const pipe = <A, B, C>(f: (a: A) => B, g: (b: B) => C) => (a: A): C =>
  g(f(a));

export const pipe3 = <A, B, C, D>(
  f: (a: A) => B,
  g: (b: B) => C,
  h: (c: C) => D,
) => (a: A): D => h(g(f(a)));

export const pipe4 = <A, B, C, D, E>(
  f: (a: A) => B,
  g: (b: B) => C,
  h: (c: C) => D,


t Call url with url fragment gets url extracted`() {
        doTest(
            url = "$VALID_CALL_URL_WITH_PARAM#fragment",
            expectedResult = "$VALID_CALL_URL_WITH_PARAM#fragment?$EXTRA_PARAMS"
        )
    }

    @Test
    fun `Element Call url with url fragment with params gets url extracted`() {
        doTest(
            url = "$VALID_CALL_URL_WITH_PARAM#fragment?otherParam=maybe",
            expectedResult = "$VALID_CALL_URL_WITH_PARAM#fragment?otherParam=maybe&$EXTRA_PARAMS"
        )
    }

    @Test
    fun `Element Call url with url fragment with other params gets url extracted`() {
        doTest(
            url = "$VALID_CALL_URL_WITH_PARAM#?otherParam=maybe",
            expectedResult = "$VALID_CALL_URL_WITH_PARAM#?otherParam=maybe&$EXTRA_PARAMS"
        )
    }

    @Test
    fun `Element Call url with empty fragment`() {
        doTest(
            url = "$VALID_CALL_URL_WITH_PARAM#",
            expectedResult = "$VALID_CALL_URL_WITH_PARAM#?$EXTRA_PARAMS"
        )
    }

    @Test
    fun `Element Call url with empty fragment query`() {
        doTest(
            url = "$VALID_CALL_URL_WITH_PARAM#?",
            expectedResult = "$VALID_CALL_URL_WITH_PARAM#?$EXTRA_PARAMS"
        )
    }

    private fun doTest(url: String, expectedResult: String?) {
        // Test direct parsing
        assertThat(callIntentDataParser.parse(url)).isEqualTo(expectedResult)

        // Test embedded url, scheme 1
        val encodedUrl = URLEncoder.encode(url, "utf-8")
        val urlScheme1 = "element://call?url=$encodedUrl"
        assertThat(callIntentDataParser.parse(urlScheme1)).isEqualTo(expectedResult)

        // Test embedded url, scheme 2
        val urlScheme2 = "io.element.call:/?url=$encodedUrl"
        assertThat(callIntentDataParser.parse(urlScheme2)).isEqualTo(expectedResult)
    }

    companion object {
        const val VALID_CALL_URL_WITH_PARAM = "https://call.element.io/some-actual-call?with=parameters"
        const val EXTRA_PARAMS = "appPrompt=false&confineToRoom=true"
    }
}
/*
 * Copyright 2024 New Vector Ltd.
 *
 * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 * Please see LICENSE files in the repository root for full details.
 */

package io.element.android.features.call.impl.services

import android.Manifest
import android.app.Service
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.content.pm.ServiceInfo
import android.os.Build
import android.os.IBinder
import androidx.core.app.NotificationChannelCompat
import androidx.core.app.NotificationCompat
import androidx.core.app.NotificationManagerCompat
import androidx.core.app.PendingIntentCompat
import androidx.core.app.ServiceCompat
import androidx.core.content.ContextCompat
import androidx.core.graphics.drawable.IconCompat
import io.element.android.features.call.impl.R
import io.element.android.features.call.impl.ui.ElementCallActivity
import io.element.android.libraries.core.extensions.runCatchingExceptions
import io.element.android.libraries.designsystem.utils.CommonDrawables
import io.element.android.libraries.push.api.notifications.ForegroundServiceType
import io.element.android.libraries.push.api.notifications.NotificationIdProvider
import timber.log.Timber

/**
 * A foreground service that shows a notification for an ongoing call while the


]

	mov_imm	x0, STM32MP_DEBUG_USART_BASE
	mov_imm	x1, STM32MP_DEBUG_USART_CLK_FRQ
	mov_imm	x2, STM32MP_UART_BAUDRATE
	b	console_stm32_core_init
endfunc plat_crash_console_init

func plat_crash_console_flush
	mov_imm	x0, STM32MP_DEBUG_USART_BASE
	b	console_stm32_core_flush
endfunc plat_crash_console_flush

func plat_crash_console_putc
	mov_imm	x1, STM32MP_DEBUG_USART_BASE
	cmp	x0, #'\n'
	b.ne	1f
	mov	x15, x30
	mov	x0, #'\r'
	bl	console_stm32_core_putc
	mov	x30, x15
	mov	x0, #'\n'
1:
	b	console_stm32_core_putc
endfunc plat_crash_console_putc

#ifdef IMAGE_BL2
	/* ---------------------------------------------
	 * void plat_report_exception(unsigned int type)
	 * Function to report a


1to4}, %ymm5, %ymm6{%k7}	 # AVX512{DQ,VL} Disp8
	vrangepd	$123, 1024(%edx){1to4}, %ymm5, %ymm6{%k7}	 # AVX512{DQ,VL}
	vrangepd	$123, -1024(%edx){1to4}, %ymm5, %ymm6{%k7}	 # AVX512{DQ,VL} Disp8
	vrangepd	$123, -1032(%edx){1to4}, %ymm5, %ymm6{%k7}	 # AVX512{DQ,VL}
	vrangeps	$0xab, %xmm4, %xmm5, %xmm6{%k7}	 # AVX512{DQ,VL}
	vrangeps	$0xab, %xmm4, %xmm5, %xmm6{%k7}{z}	 # AVX512{DQ,VL}
	vrangeps	$123, %xmm4, %xmm5, %xmm6{%k7}	 # AVX512{DQ,VL}
	vrangeps	$123, (%ecx), %xmm5, %xmm6{%k7}	 # AVX512{DQ,VL}
	vrangeps	$123, -123456(%esp,%esi,8), %xmm5, %xmm6{%k7}	 # AVX512{DQ,VL}
	vrangeps	$123, (%eax){1to4}, %xmm5, %xmm6{%k7}	 # AVX512{DQ,VL}
	vrangeps	$123, 2032(%edx), %xmm5, %xmm6{%k7}	 # AVX512{DQ,VL} Disp8
	vrangeps	$123, 2048(%edx), %xmm5, %xmm6{%k7}	 # AVX512{DQ,VL}
	vrangeps	$123, -2048(%edx), %xmm5, %xmm6{%k7}	 # AVX512{DQ,VL} Disp8
	vrangeps	$123, -2064(%edx), %xmm5, %xmm6{%k7}	 # AVX512{DQ,VL}
	vrangeps	$123, 508(%edx){1to4}, %xmm5, %xmm6{%k7}	 # AVX512{DQ,VL} Disp8
	vrangeps	$123, 512(%edx){1to4}, %xmm5, %xmm6{%k7}	 # AVX512{DQ,VL}
	vrangeps	$123, -512(%edx){1to4}, %xmm5, %xmm6{%k7}	 # AVX512{DQ,VL} Disp8
	vrangeps	$123, -516(%edx){1to4}, %xmm5, %xmm6{%k7}	 # AVX512{DQ,VL}
	vrangeps	$0xab, %ymm4, %ymm5, %ymm6{%k7}	 # AVX512{DQ,VL}
	vrangeps	$0xab, %ymm4, %ymm5, %ymm6{%k7}{z}	 # AVX512{DQ,VL}
	vrangeps	$123, %ymm4, %ymm5, %ymm6{%k7}	 # AVX512{DQ,VL}
	vrangeps	$123, (%ecx), %ymm5, %ymm6{%k7}	 # AVX512{DQ,VL}
	vrangeps	$123, -123456(%esp,%esi,8), %ymm5, %ymm6{%k7}	 # AVX512{DQ,VL}
	vrangeps	$123, (%eax){1to8}, %ymm5, %ymm6{%k7}	 # AVX512{DQ,VL}
	vrangeps	$123, 4064(%edx), %ymm5, %ymm6{%k7}	 # AVX512{DQ,VL} Disp8
	vrangeps	$123, 4096(%edx)


import matplotlib.pyplot as plt
import numpy as np
import re

# Ваши НОВЫЕ данные в виде многострочной строки
data_string = """
.Содержание суммарных липидов, [мг/г_{DW}]
| Размер      | DW, stem:[мг/г_{СМ}]
| Семена_2 мм | 34.93 ± 5.58
| Семена_4 мм | 44.35 ± 4.45
| Семена_6 мм | 57.91 ± 7.77
| Семена_7 мм | 103.61 ± 8.61
| Семена_8 мм | 106.44 ± 22.09
| Семена_9 мм | 93.91 ± 19.32
| Семена_10 мм| 38.46 ± 5.02
"""

# Списки для хранения извлеченных данных
seed_sizes = []
means = []
std_devs = []

# Обработка строк данных
lines = data_string.strip().split('\n')
y_axis_label_raw = lines[0].strip('.').strip() # Извлекаем заголовок для оси Y

# Пропускаем строки заголовков таблицы
data_lines = lines[2:]

for line in data_lines:
    parts = line.split('|')
    if len(parts) == 3: # Ожидаем три части: пустая, Размер, Значение
        size_str = parts[1].strip()
        value_str = parts[2].strip()

        # Извлечение размера семян (число перед "мм")
        match_size = re.search(r'(\d+)\s*мм', size_str)
        if match_size:
            seed_sizes.append(int(match_size.group(1)))
        else:
            print(f"Предупреждение: не удалось извлечь размер из '{size_str}'")
            continue

        # Извлечение среднего и стандартного отклонения
        mean_std_parts = value_str.split('±')
        if len(mean_std_parts) == 2:
            try:
                means.append(float(mean_std_parts[0].strip()))
                std_devs.append(float(mean_std_parts[1].strip()))
            except ValueError:
                print(f"Предупреждение: не удалось преобразовать в число значения из '{value_str}'")
                # Удаляем последний добавленный размер, если значения невалидны
                if seed_sizes: seed_sizes.pop()
                continue
        else:
            print(f"Предупреждение: не удалось извлечь среднее и ст.откл. из '{value_str}'")
            if seed_sizes: seed_sizes.pop() # Удаляем последний добавленный размер
            continue

# Сортировка данных по размеру семян (на всякий случай, если они не по порядку)
# Это важно для корректного отображения линии на графике
if seed_sizes and means and std_devs: # Проверяем, что списки не пусты
    sorted_indices = np.argsort(seed_sizes)
    seed_sizes_sorted = np.array(seed_sizes)[sorted_indices]
    means_sorted = np.array(means)[sorted_indices]
    std_devs_sorted = np.array(std_devs)[sorted_indices]

    # Форматирование метки оси Y для отображения подстрочного текста
    # Matplotlib использует LaTeX-подобный синтаксис
    y_axis_label_formatted = y_axis_label_raw.replace("_{DW}", "$_{DW}$").replace("мг/г", "мг/г ")

    # Построение графика
    plt.figure(figsize=(12, 7)) # Увеличим размер для лучшей читаемости

    plt.errorbar(seed_sizes_sorted, means_sorted, yerr=std_devs_sorted,
                 fmt='-o', # Формат: линия ('-') с маркерами ('o')
                 capsize=5, # Размер "шляпок" на усах ошибок
                 label='Содержание липидов (мг/г$_{DW}$) ± Ст. отклонение',
                 color='dodgerblue', # Изменим цвет для разнообразия
                 ecolor='lightcoral', # Цвет усов ошибок
                 elinewidth=2, # Толщина линии усов
                 markersize=8
                )

    # Настройка графика
    plt.xlabel("Размер семян (мм)")
    plt.ylabel(y_axis_label_formatted) # Используем отформатированную метку
    plt.title("Зависимость содержания суммарных липидов от размера семян")
    plt.xticks(seed_sizes_sorted) # Устанавливаем тики по оси X точно по нашим значениям
    # Попробуем автоматически определить лучшее положение легенды
    plt.legend(loc='best')
    plt.grid(True, linestyle='--', alpha=0.6) # Добавляем сетку

    # Отображение графика
    plt.tight_layout()
    plt.show()
else:
    print("Недостаточно данных для построения графика.")


        catch ( UnknownHostException e )
        {
            return null;
        }
    }

    public void resetLocalNATAddress()
    {
        JiveGlobals.deleteProperty( "org.ice4j.ice.harvest.NAT_HARVESTER_PRIVATE_ADDRESS" );
    }

    public void setStunMappingHarversterAddresses( List<String> addresses )
    {
        if (addresses == null || addresses.isEmpty() )
        {
            JiveGlobals.deleteProperty( "org.ice4j.ice.harvest.STUN_MAPPING_HARVESTER_ADDRESSES" );
        }
        else
        {
            JiveGlobals.setProperty( "org.ice4j.ice.harvest.STUN_MAPPING_HARVESTER_ADDRESSES", addresses );
        }
    }

    public List<String> getStunMappingHarversterAddresses()
    {
        return JiveGlobals.getListProperty( "org.ice4j.ice.harvest.STUN_MAPPING_HARVESTER_ADDRESSES", Collections.<String>emptyList() );
    }

    public void resetStunMappingHarversterAddresses()
    {
        JiveGlobals.deleteProperty( "org.ice4j.ice.harvest.STUN_MAPPING_HARVESTER_ADDRESSES" );
    }

    // Resolution is used in older clients (chrome < 61) while 'constraints' are used in newer clients.
    public void setResolution( int resolution )
    {
        JiveGlobals.setProperty( "org.jitsi.videobridge.ofmeet.resolution", Integer.toString( resolution ) );
    }

    public int getResolution()
    {
        return JiveGlobals.getIntProperty( "org.jitsi.videobridge.ofmeet.resolution", 720 );
    }

    public void resetResolution()
    {
        JiveGlobals.deleteProperty( "org.jitsi.videobridge.ofmeet.resolution" );
    }

    public void setVideoConstraintsIdealAspectRatio( String ratio )
    {
        JiveGlobals.setProperty( "org.jitsi.videobridge.ofmeet.constraints.video.aspectratio.ideal", ratio );
    }

    public String getVideoConstraintsIdealAspectRatio()
    {
        return JiveGlobals.getProperty( "org.jitsi.videobridge.ofmeet.constraints.video.aspectratio.ideal", "16 / 9" );
    }

    public void resetVideoConstraintsIdealAspectRatio()
    {
        JiveGlobals.deleteProperty( "org.jitsi.videobridge.ofmeet.constraints.video.aspectratio.ideal" );
    }

    public void setVideoConstraintsIdealHeight( int idealHeight )
    {
        JiveGlobals.setProperty( "org.jitsi.videobridge.ofmeet.constraints.video.height.ideal", Integer.toString( idealHeight ) );
    }

    public int getVideoConstraintsIdealHeight()
    {
        return JiveGlobals.getIntProperty( "org.jitsi.videobridge.ofmeet.constraints.video.height.ideal", getResolution() );
    }

    public void resetVideoConstraintsIdealHeight()
    {
        JiveGlobals.deleteProperty( "org.jitsi.videobridge.ofmeet.constraints.video.height.ideal" );
    }

    public void setVideoConstraintsMaxHeight( int maxHeight )
    {
        JiveGlobals.setProperty( "org.jitsi.videobridge.ofmeet.constraints.video.height.max", Integer.toString( maxHeight ) );
    }

    public int getVideoConstraintsMaxHeight()
    {
        final int value = JiveGlobals.getIntProperty( "org.jitsi.videobridge.ofmeet.constraints.video.height.max", getVideoConstraintsIdealHeight() * 3 );
        return Math.max( value, getVideoConstraintsIdealHeight() ); // don't have a 'max' that is lower than 'i


", GoGetter: "Policy"},
			_jsii_.MemberProperty{JsiiProperty: "replicationRoleArn", GoGetter: "ReplicationRoleArn"},
			_jsii_.MemberMethod{JsiiMethod: "s3UrlForObject", GoMethod: "S3UrlForObject"},
			_jsii_.MemberProperty{JsiiProperty: "stack", GoGetter: "Stack"},
			_jsii_.MemberMethod{JsiiMethod: "toString", GoMethod: "ToString"},
			_jsii_.MemberMethod{JsiiMethod: "transferAccelerationUrlForObject", GoMethod: "TransferAccelerationUrlForObject"},
			_jsii_.MemberMethod{JsiiMethod: "urlForObject", GoMethod: "UrlForObject"},
			_jsii_.MemberMethod{JsiiMethod: "virtualHostedUrlForObject", GoMethod: "VirtualHostedUrlForObject"},
		},
		func() interface{} {
			j := jsiiProxy_Bucket{}
			_jsii_.InitJsiiProxy(&j.jsiiProxy_BucketBase)
			return &j
		},
	)
	_jsii_.RegisterEnum(
		"aws-cdk-lib.aws_s3.BucketAccessControl",
		reflect.TypeOf((*BucketAccessControl)(nil)).Elem(),
		map[string]interface{}{
			"PRIVATE": BucketAccessControl_PRIVATE,
			"PUBLIC_READ": BucketAccessControl_PUBLIC_READ,
			"PUBLIC_READ_WRITE": BucketAccessControl_PUBLIC_READ_WRITE,
			"AUTHENTICATED_READ": BucketAccessControl_AUTHENTICATED_READ,
			"LOG_DELIVERY_WRITE": BucketAccessControl_LOG_DELIVERY_WRITE,
			"BUCKET_OWNER_READ": BucketAccessControl_BUCKET_OWNER_READ,
			"BUCKET_OWNER_FULL_CONTROL": BucketAccessControl_BUCKET_OWNER_FULL_CONTROL,
			"AWS_EXEC_READ": BucketAccessControl_AWS_EXEC_READ,
		},
	)
	_jsii_.RegisterStruct(
		"aws-cdk-lib.aws_s3.BucketAttributes",
		reflect.TypeOf((*BucketAttributes)(nil)).Elem(),
	)
	_jsii_.RegisterClass(
		"aws-cdk-lib.aws_s3.BucketBase",
		reflect.TypeOf((*BucketBase)(nil)).Elem(),
		[]_jsii_.Member{
			_jsii_.MemberMethod{JsiiMethod: "addEventNotification", GoMethod: "AddEventNotification"},
			_jsii_.MemberMethod{JsiiMethod: "addObjectCreatedNotification", GoMethod: "AddObjectCreatedNotification"},
			_jsii_.MemberMethod{JsiiMethod: "addObjectRemovedNotification", GoMethod: "AddObjectRemovedNotification"},
			_jsii_.MemberMethod{JsiiMethod: "addReplicationPolicy", GoMethod: "AddReplicationPolicy"},
			_jsii_.MemberMethod{JsiiMethod: "addToResourcePolicy", GoMethod: "AddToResourcePolicy"},
			_jsii_.MemberMethod{JsiiMethod: "applyRemovalPolicy", GoMethod: "ApplyRemovalPolicy"},
			_jsii_.MemberMethod{JsiiMethod: "arnForObjects", GoMethod: "ArnForObjects"},
			_jsii_.MemberProperty{JsiiProperty: "autoCreatePolicy", GoGetter: "AutoCreatePolicy"},
			_jsii_.MemberProperty{JsiiProperty: "bucketArn", GoGetter: "BucketArn"},
			_jsii_.MemberProperty{JsiiProperty: "bucketDomainName", GoGetter: "BucketDomainName"},
			_jsii_.MemberProperty{JsiiProperty: "bucketDualStackDomainName", GoGetter: "BucketDualStackDomainName"},
			_jsii_.MemberProperty{JsiiProperty: "bucketName", GoGetter: "BucketName"},
			_jsii_.MemberProperty{JsiiProperty: "bucketRef", GoGetter: "BucketRef"},
			_jsii_.MemberProperty{JsiiProperty: "bucketRegionalDomainName", GoGetter: "BucketRegionalDomainName"},
			_jsii_.MemberProperty{JsiiProperty: "bucketWebsiteDomainName", GoGetter: "BucketWebsiteDomainName"},
			_jsii_.MemberProperty{JsiiProperty: "bucketWebsiteUrl", G


} = *message {
            match *action {
                // Action when player collides into item
                ActorAction::Collision(ActorType::Player, _) => {
                    // Update score and remove coin
                    ActorMessage::MultipleMessages(vec![
                        Box::new(ActorMessage::UpdateScore(COIN_VALUE)),
                        Box::new(ActorMessage::RemoveActor(self.data().index)),
                    ])
                }
                // Action when an enemy is thrown or kicked into item
                ActorAction::DamageActor(_) => {
                    // Update score and remove coin
                    ActorMessage::MultipleMessages(vec![
                        Box::new(ActorMessage::UpdateScore(COIN_VALUE)),
                        Box::new(ActorMessage::RemoveActor(self.data().index)),
                    ])
                }
                _ => ActorMessage::None,
            }
        } else {
            ActorMessage::None
        }
    }

    fn collides_with(&mut self, other_actor: &ActorData) -> Option<CollisionSide> {
        self.rect.collides_with(&other_actor.rect)
    }

    fn update(&mut self, _context: &mut Context, elapsed: f64) -> PositionChange {
        // Update sprite animation
        self.animation.add_time(elapsed);
        PositionChange::new()
    }

    fn render(
        &mut self,
        context: &mut Context,
        viewport: &mut Viewport,
        _elapsed: f64,
    ) -> Result<(), Box<Error>> {
        let (rx, ry) = viewport.relative_point((self.rect.x, self.rect.y));
        let rect = Rect::new(rx, ry, self.rect.w, self.rect.h);

        // Render sprite animation
        self.animation.render(&mut context.renderer, rect)
    }

    fn data(&mut self) -> ActorData {
        ActorData {
            index: self.index,
            state: 0,
            damage: 0,
            collision_filter: 0b1111,
            resolves_collisions: false,
            rect: self.rect.to_sdl(),
            bounding_box: Some(BoundingBox::Rectangle(self.rect)),
            actor_type: ActorType::Item,
        }
    }
}
<filename>crates/matcher/src/algo.rs
use structopt::clap::arg_enum;

// Implement arg_enum for using it in the command line arguments.
arg_enum! {
  /// Supported line oriented String match algorithm.
  #[derive(Debug, Clone)]
  pub enum Algo {
      Skim,
      Fzy,
      SubString,
  }
}

pub mod skim {
    // Reexport the skim algorithm, mainly `fuzzy_indices()`.
    pub use fuzzy_matcher::skim::*;
}

pub mod fzy {
    // Reexport the fzy algorithm
    pub use extracted_fzy::*;

    /// Make the arguments order same to Skim's `fuzzy_indices()`.
    #[inline]
    pub fn fuzzy_indices(line: &str, query: &str) -> crate::MatcherResult {
        match_and_score_with_positions(query, line).map(|(score, indices)| (score as i64, indices))
    }
}

pub mod substring {
    fn find_start_at(slice: &str, start_at: usize, pat: &str) -> Option<usize> {
        slice[start_at..].find(pat).map(|i| start_at + i)
    }

    fn substr_indices_impl(haystack: &str, niddle: &str) -> Option<(f64, Vec<usize>)> {
        // unreasonably large haystack
        if haystack.len() > 1024 {
            return None;
        }

        let haystack = haystack.to_lowercase();


 Trait
        ty::TyRef(_, ty::mt { ty, .. }) | ty::TyBox(ty) if !type_is_sized(tcx, ty) => {
            path.push(FAT_PTR_ADDR);
            Some(path)
        },

        // Regular thin pointer: &T/&mut T/Box<T>
        ty::TyRef(..) | ty::TyBox(..) => Some(path),

        // Functions are just pointers
        ty::TyBareFn(..) => Some(path),

        // Is this the NonZero lang item wrapping a pointer or integer type?
        ty::TyStruct(did, substs) if Some(did) == tcx.lang_items.non_zero() => {
            let nonzero_fields = ty::lookup_struct_fields(tcx, did);
            assert_eq!(nonzero_fields.len(), 1);
            let nonzero_field = ty::lookup_field_type(tcx, did, nonzero_fields[0].id, substs);
            match nonzero_field.sty {
                ty::TyRawPtr(ty::mt { ty, .. }) if !type_is_sized(tcx, ty) => {
                    path.push_all(&[0, FAT_PTR_ADDR]);
                    Some(path)
                },
                ty::TyRawPtr(..) | ty::TyInt(..) | ty::TyUint(..) => {
                    path.push(0);
                    Some(path)
                },
                _ => None
            }
        },

        // Perhaps one of the fields of this struct is non-zero
        // let's recurse and find out
        ty::TyStruct(def_id, substs) => {
            let fields = ty::lookup_struct_fields(tcx, def_id);
            for (j, field) in fields.iter().enumerate() {
                let field_ty = ty::lookup_field_type(tcx, def_id, field.id, substs);
                if let Some(mut fpath) = find_discr_field_candidate(tcx, field_ty, path.clone()) {
                    fpath.push(j);
                    return Some(fpath);
                }
            }
            None
        },

        // Perhaps one of the upvars of this struct is non-zero
        // Let's recurse and find out!
        ty::TyClosure(def_id, substs) => {
            let typer = NormalizingClosureTyper::new(tcx);
            let upvars = typer.closure_upvars(def_id, substs).unwrap();
            let upvar_types = upvars.iter().map(|u| u.ty).collect::<Vec<_>>();

            for (j, &ty) in upvar_types.iter().enumerate() {
                if let Some(mut fpath) = find_discr_field_candidate(tcx, ty, path.clone()) {
                    fpath.push(j);
                    return Some(fpath);
                }
            }
            None
        },

        // Can we use one of the fields in this tuple?
        ty::TyTuple(ref tys) => {
            for (j, &ty) in tys.iter().enumerate() {
                if let Some(mut fpath) = find_discr_field_candidate(tcx, ty, path.clone()) {
                    fpath.push(j);
                    return Some(fpath);
                }
            }
            None
        },

        // Is this a fixed-size array of something non-zero
        // with at least one element?
        ty::TyArray(ety, d) if d > 0 => {
            if let Some(mut vpath) = find_discr_field_candidate(t


.fields.message_type = ProtoField.new("Message Type", "miax.pearlequities.topofmarket.mach.v1.1.a.messagetype", ftypes.STRING)
omi_miax_pearlequities_topofmarket_mach_v1_1_a.fields.offer_price = ProtoField.new("Offer Price", "miax.pearlequities.topofmarket.mach.v1.1.a.offerprice", ftypes.DOUBLE)
omi_miax_pearlequities_topofmarket_mach_v1_1_a.fields.offer_size = ProtoField.new("Offer Size", "miax.pearlequities.topofmarket.mach.v1.1.a.offersize", ftypes.UINT16)
omi_miax_pearlequities_topofmarket_mach_v1_1_a.fields.opening_time = ProtoField.new("Opening Time", "miax.pearlequities.topofmarket.mach.v1.1.a.openingtime", ftypes.STRING)
omi_miax_pearlequities_topofmarket_mach_v1_1_a.fields.packet = ProtoField.new("Packet", "miax.pearlequities.topofmarket.mach.v1.1.a.packet", ftypes.STRING)
omi_miax_pearlequities_topofmarket_mach_v1_1_a.fields.packet_length = ProtoField.new("Packet Length", "miax.pearlequities.topofmarket.mach.v1.1.a.packetlength", ftypes.UINT16)
omi_miax_pearlequities_topofmarket_mach_v1_1_a.fields.packet_type = ProtoField.new("Packet Type", "miax.pearlequities.topofmarket.mach.v1.1.a.packettype", ftypes.UINT8)
omi_miax_pearlequities_topofmarket_mach_v1_1_a.fields.payload = ProtoField.new("Payload", "miax.pearlequities.topofmarket.mach.v1.1.a.payload", ftypes.STRING)
omi_miax_pearlequities_topofmarket_mach_v1_1_a.fields.price = ProtoField.new("Price", "miax.pearlequities.topofmarket.mach.v1.1.a.price", ftypes.DOUBLE)
omi_miax_pearlequities_topofmarket_mach_v1_1_a.fields.primary_market_code = ProtoField.new("Primary Market Code", "miax.pearlequities.topofmarket.mach.v1.1.a.primarymarketcode", ftypes.STRING)
omi_miax_pearlequities_topofmarket_mach_v1_1_a.fields.reserved_1 = ProtoField.new("Reserved 1", "miax.pearlequities.topofmarket.mach.v1.1.a.reserved1", ftypes.STRING)
omi_miax_pearlequities_topofmarket_mach_v1_1_a.fields.sequence_number = ProtoField.new("Sequence Number", "miax.pearlequities.topofmarket.mach.v1.1.a.sequencenumber", ftypes.UINT64)
omi_miax_pearlequities_topofmarket_mach_v1_1_a.fields.session_id = ProtoField.new("Session Id", "miax.pearlequities.topofmarket.mach.v1.1.a.sessionid", ftypes.UINT8)
omi_miax_pearlequities_topofmarket_mach_v1_1_a.fields.session_number = ProtoField.new("Session Number", "miax.pearlequities.topofmarket.mach.v1.1.a.sessionnumber", ftypes.UINT8)
omi_miax_pearlequities_topofmarket_mach_v1_1_a.fields.short_sale_restriction = ProtoField.new("Short Sale Restriction", "miax.pe


displayfilter.UC.ImageSize = new Size(24, 24);
            displayfilter.UC.ScreenMargin = new Size(0,0);
            displayfilter.CloseBoundaryRegion = new Size(32, ((Control)sender).Height);

            displayfilter.SaveSettings = (s, o) =>
            {
                routecontrolsettings = s;
                PutSetting("routecontrol", s);
                DrawRoute(cur_sys);
                DrawFuel();
                SetVisibility();
            };

            displayfilter.Show(routecontrolsettings, (Control)sender, this.FindForm());
        }

        #endregion

        #region vars

        // we keep the results of the last CalculatethenDrawSystem so we can just DrawSystem later
        // we also set it to null in case DrawSystem gets called first before a calculate
        private SortedList<string, string> drawsystemtext = new SortedList<string, string>(new CollectionStaticHelpers.AlphaIntCompare<string>());
        private string drawsystemsignallist = "";
        private long drawsystemvalue = 0;

        // we keep the results of the last scan summary
        private string scansummarytext = "";

        // picked up from startjump and displayed
        private string starclass = "";

        // bodies found from FSSAllBodies found or DiscoveryScan
        private int bodies_found;
        private bool all_found = false;

        // the UI state is kept for display visibility
        private EliteDangerousCore.UIEvents.UIGUIFocus.Focus uistate = EliteDangerousCore.UIEvents.UIGUIFocus.Focus.NoFocus;
        private EliteDangerousCore.UIEvents.UIMode.ModeType uimode = EliteDangerousCore.UIEvents.UIMode.ModeType.None;

        // Route selection
        private const string NavRouteNameLabel = "!*NavRoute";      // special label to identify a save of using the nav route - not user presented
        private string translatednavroutename = "";     // presented to the user, found by the translator
        private SavedRouteClass currentRoute = null;    // the current route selected by the user. ID=-1 means a navroute
        private string lastsystemonroute;               // last system on route, used to check for updates

        // fsd
        private Ship shipinfo;   // and last ship info
        private EliteDangerousCalculations.FSDSpec.JumpInfo shipfsdinfo;        // last values of fsd info

        // user selections
        private Font displayfont;                       // font selected
        private StringAlignment alignment = StringAlignment.Near;   // text alignment
        private string fsssignalstodisplay = "";        // fss signals to show selector

        // tracking state
        private int eventsseen = 0;


a="i am hero"
c=a.split()
n=len(c)-1
for i in range(0,len(c)):
    print(c[n])
    n=n-1


CTX::instance()->geom.selectedCurveWidth);
#endif
  return CTX::instance()->geom.selectedCurveWidth;
}

double opt_geometry_curve_type(OPT_ARGS_NUM)
{
  if(action & GMSH_SET) { CTX::instance()->geom.curveType = (int)val; }
#if defined(HAVE_FLTK)
  if(FlGui::available() && (action & GMSH_GUI)) {
    FlGui::instance()->options->geo.choice[1]->value(
      CTX::instance()->geom.curveType);
  }
#endif
  return CTX::instance()->geom.curveType;
}

double opt_geometry_surface_type(OPT_ARGS_NUM)
{
  if(action & GMSH_SET) {
    CTX::instance()->geom.surfaceType = (int)val;
    if(CTX::instance()->geom.surfaceType < 0 ||
       CTX::instance()->geom.surfaceType > 2)
      CTX::instance()->geom.surfaceType = 0;
  }
#if defined(HAVE_FLTK)
  if(FlGui::available() && (action & GMSH_GUI)) {
    FlGui::instance()->options->geo.choice[2]->value(
      CTX::instance()->geom.surfaceType);
  }
#endif
  return CTX::instance()->geom.surfaceType;
}

double opt_geometry_volume_type(OPT_ARGS_NUM)
{
  if(action & GMSH_SET) {
    CTX::instance()->geom.volumeType = (int)val;
    if(CTX::instance()->geom.volumeType < 0 ||
       CTX::instance()->geom.volumeType > 1)
      CTX::instance()->geom.volumeType = 0;
  }
#if defined(HAVE_FLTK)
  if(FlGui::available() && (action & GMSH_GUI)) {
    FlGui::instance()->options->geo.choice[5]->value(
      CTX::instance()->geom.volumeType);
  }
#endif
  return CTX::instance()->geom.volumeType;
}

double opt_geometry_light(OPT_ARGS_NUM)
{
  if(action & GMSH_SET) CTX::instance()->geom.light = (int)val;
#if defined(HAVE_FLTK)
  if(FlGui::available() && (action & GMSH_GUI)) {
    FlGui::instance()->options->geo.butt[9]->value(CTX::instance()->geom.light);
  }
#endif
  return CTX::instance()->geom.light;
}

double opt_geometry_light_two_side(OPT_ARGS_NUM)
{
  if(action & GMSH_SET) CTX::instance()->geom.lightTwoSide = (int)val;
#if defined(HAVE_FLTK)
  if(FlGui::available() && (action & GMSH_GUI))
    FlGui::instance()->options->geo.butt[15]->value(
      CTX::instance()->geom.lightTwoSide);
#endif
  return CTX::instance()->geom.lightTwoSide;
}

double opt_geometry_occ_auto_embed(OPT_ARGS_NUM)
{
  if(action & GMSH_SET) CTX::instance()->geom.occAutoEmbed = val ? 1 : 0;
  return CTX::instance()->geom.occAutoEmbed;
}

double opt_geometry_occ_fast_unbind(OPT_ARGS_NUM)
{
  if(action & GMSH_SET) CTX::instance()->geom.occFastUnbind = (int)val;
  return CTX::instance()->geom.occFastUnbind;
}

double opt_geometry_occ_auto_fix(OPT_ARGS_NUM)
{
  if(action & GMSH_SET) CTX::instance()->geom.occAutoFix = val ? 1 : 0;
  return CTX::instance()->geom.occAutoFix;
}

double opt