TOR extends ffi.Struct {
  @ffi.Uint64()
  external int TimeDateStamp;

  @ffi.Uint64()
  external int ForwarderChain;

  @ffi.Uint64()
  external int Name;

  @ffi.Uint64()
  external int FirstThunk;
}

final class PIMAGE_BOUND_IMPORT_DESCRIPTOR extends ffi.Struct {
  @ffi.Uint64()
  external int TimeDateStamp;

  @ffi.Uint16()
  external int OffsetModuleName;

  @ffi.Uint16()
  external int NumberOfModuleForwarderRefs;
}

final class PIMAGE_BOUND_FORWARDER_REF extends ffi.Struct {
  @ffi.Uint64()
  external int TimeDateStamp;

  @ffi.Uint16()
  external int OffsetModuleName;

  @ffi.Uint16()
  external int Reserved;
}

final class PIMAGE_DELAYLOAD_DESCRIPTOR extends ffi.Opaque {}

final class PIMAGE_RESOURCE_DIRECTORY extends ffi.Struct {
  @ffi.Uint64()
  external int Characteristics;

  @ffi.Uint64()
  external int TimeDateStamp;

  @ffi.Uint16()
  external int MajorVersion;

  @ffi.Uint16()
  external int MinorVersion;

  @ffi.Uint16()
  external int NumberOfNamedEntries;

  @ffi.Uint16()
  external int NumberOfIdEntries;
}

final class PIMAGE_RESOURCE_DIRECTORY_ENTRY extends ffi.Opaque {}

final class PIMAGE_RESOURCE_DIRECTORY_STRING extends ffi.Opaque {}

final class PIMAGE_RESOURCE_DIR_STRING_U extends ffi.Opaque {}

final class PIMAGE_RESOURCE_DATA_ENTRY extends ffi.Struct {
  @ffi.Uint64()
  external int OffsetToData;

  @ffi.Uint64()
  external int Size;

  @ffi.Uint64()
  external int CodePage;

  @ffi.Uint64()
  external int Reserved;
}

final class PIMAGE_LOAD_CONFIG_CODE_INTEGRITY extends ffi.Struct {
  @ffi.Uint16()
  external int Flags;

  @ffi.Uint16()
  external int Catalog;

  @ffi.Uint64()
  external int CatalogOffset;

  @ffi.Uint64()
  external int Reserved;
}

final class PIMAGE_DYNAMIC_RELOCATION_TABLE extends ffi.Struct {
  @ffi.Uint64()
  external int Version;

  @ffi.Uint64()
  external int Size;
}

final class PIMAGE_DYNAMIC_RELOCATION32 extends ffi.Struct {
  @ffi.Uint64()
  external int Symbol;

  @ffi.Uint64()
  external int BaseRelocSize;
}

final class PIMAGE_DYNAMIC_RELOCATION64 extends ffi.Struct {
  @ffi.Uint64()
  external int Symbol;

  @ffi.Uint64()
  external int BaseRelocSize;
}

final class PIMAGE_DYNAMIC_RELOCATION32_V2 extends ffi.Struct {
  @ffi.Uint64()
  external int HeaderSize;

  @ffi.Uint64()
  external int FixupInfoSize;

  @ffi.Uint64()
  external int Symbol;

  @ffi.Uint64()
  external int SymbolGroup;

  @ffi.Uint64()
  external int Flags;
}

final class PIMAGE_DYNAMIC_RELOCATION64_V2 extends ffi.Struct {
  @ffi.Uint64()
  external int HeaderSize;

  @ffi.Uint64()
  external int FixupInfoSize;

  @ffi.Uint64()
  external int Symbol;

  @ffi.Uint64()
  external int SymbolGroup;

  @ffi.Uint64()
  external int Flags;
}

final class IMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADER extends f


/*
 *  Copyright 2017 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#ifndef API_CALL_CALLFACTORYINTERFACE_H_
#define API_CALL_CALLFACTORYINTERFACE_H_

#include <memory>

namespace webrtc {

// These classes are not part of the API, and are treated as opaque pointers.
class Call;
struct CallConfig;

// This interface exists to allow webrtc to be optionally built without media
// support (i.e., if only being used for data channels). PeerConnectionFactory
// is constructed with a CallFactoryInterface, which may or may not be null.
class CallFactoryInterface {
 public:
  virtual ~CallFactoryInterface() {}

  virtual Call* CreateCall(const CallConfig& config) = 0;
};

std::unique_ptr<CallFactoryInterface> CreateCallFactory();

}  // namespace webrtc

#endif  // API_CALL_CALLFACTORYINTERFACE_H_


import os
import subprocess
def change_backend(index_js_content):
    os.chdir("project/server")
    with open('index.js', 'w') as file:
        file.write(index_js_content)
    subprocess.Popen(["node" , "index.js"], shell=True)
    os.chdir("../..")

def change_frontend(index_js_content):
    print(os.getcwd())
    os.chdir("project/client/src")
    with open('App.jsx', 'w') as file:
        file.write(index_js_content)
    with open('App.css', 'w') as file:
        file.write(" ")
    with open('index.css', 'w') as file:
        file.write(" ")
    os.chdir("../../..")

def change_backend_and_frontend(back, front):
    change_backend(back)
    change_frontend(front)

change_backend_and_frontend("""const express = require('express');
const cors = require('cors');
const mongoose = require('mongoose');

const app = express();
const port = 2004;

// MongoDB connection
mongoose.connect('mongodb://localhost:27017/guitar-solos', { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log('Connected to MongoDB'))
  .catch(err => console.error('MongoDB connection error:', err));

// Middleware
app.use(cors());
app.use(express.json());

// Models
const SoloSchema = new mongoose.Schema({
  title: { type: String, required: true },
  artist: { type: String, required: true },
  description: { type: String, required: true },
  tab: { type: String },
  imageUrl: { type: String }
});

const Solo = mongoose.model('Solo', SoloSchema);

// API routes
app.get('/solos', async (req, res) => {
  try {
    const solos = await Solo.find();
    res.json(solos);
  } catch (err) {
    res.status(500).json({ message: 'Error fetching solos' });
  }
});

app.post('/solos', async (req, res) => {
  try {
    const newSolo = new Solo(req.body);
    await newSolo.save();
    res.status(201).json(newSolo);
  } catch (err) {
    res.status(400).json({ message: 'Error creating solo' });
  }
});

app.listen(port, () => console.log(`Server listening on port ${port}`));""", """import React, { useState, useEffect } from 'react';

function App() {
  const [solos, setSolos] = useState([]);

  useEffect(() => {
    fetch('http://localhost:2004/solos')
      .then(res => res.json())
      .then(data => setSolos(data))
      .catch(err => console.error('Error fetching solos:', err));
  }, []);

  return (

Famous Guitar Solos

        {solos.map(solo => (

{solo.title}

{solo.artist}

        ))}

  );
}

export default App;""")


FBhcnRuZXI= 35532
cHRvbXM= 35533
IDc3Nw== 35534
IEZvbGV5 35535
IENhc2Vz 35536
IGdyZWFzZQ== 35537
IFJlYmlydGg= 35538
R3JvdW5k 35539
IDsp 35540
IERvY3RyaW5l 35541
aWtpbmk= 35542
WWU= 35543
IEJsb3Nzb20= 35544
IHBlcnNpc3Rz 35545
YmlsbA== 35546
IGluZnVzaW9u 35547
IGJ1ZGRpZXM= 35548
OTEx 35549
IFBhdGllbnQ= 35550
IGRlbW9z 35551
IGFjcXVhaW50YW5jZQ== 35552
IFBhdw== 35553
YXRhcmk= 35554
IHhtbA== 35555
IGZhc2NpbmF0aW9u 35556
IFNlcnZl 35557
z4I= 35558
YnJhbmRlZA== 35559
IGF6 35560
UmV0dXJucw== 35561
IG92ZXJzaGFkb3c= 35562
IHJvYW0= 35563
IHNwZWVkeQ== 35564
bnVtYmVyZWQ= 35565
aGVsaWFs 35566
IGRpc2NpcGxl 35567
IGFzc3VyYW5jZXM= 35568
Z2l2ZW4= 35569
cGVjdGluZw== 35570
IE5hdGFsaWU= 35571
55Sw 35572
IG1vc3F1aXRvZXM= 35573
cm90ZWlu 35574
IG51bWVyaWM= 35575
IGluZGVwZW5kZW50cw== 35576
IHRyYW5zaXRpb25hbA== 35577
IHJlYWN0aW9uYXJ5 35578
IE1lY2hkcmFnb24= 35579
ZG9jdG9y 35580
IHNob3J0ZXN0 35581
IHNlcXVlbnRpYWw= 35582
IEJhYw== 35583
IEFjY291bnRz 35584
44GM 35585
YWNoeQ== 35586
cmFjdGl2ZQ== 35587
IFJlZ2ltZW50 35588
IGJyZWF0aHRha2luZw== 35589
ZmZpY2llbmN5 35590
IEJhdGVz 35591
IDMxMQ== 35592
IHdhcmRyb2Jl 35593
ZnRz 35594
IEJlcms= 35595
U2ltcGx5 35596
IFJpdmVyc2lkZQ== 35597
aXZlcmluZw== 35598
aWRlbnRpYWw= 35599
bHVjZW50 35600
IGVucmljaGVk 35601
IENvbnZlcg== 35602
IEdpdmluZw== 35603
44OZ 35604
IGxlZ2FsaXpl 35605
IEZUQw== 35606
IGZyZWFraW5n 35607
TWl4 35608
IHRlcnJlc3RyaWFs 35609
ZXNpYW4= 35610
Y2llbnRz 35611
V2luZw== 35612
TE9BRA== 35613
IGxlZGdl 35614
IFZpb2xlbnQ= 35615
IE1ldGFsbA== 35616
IDMwOA== 35617
IHNvdXRoZWFzdGVybg== 35618
aGV0dG8= 35619
TWVhdA== 35620
IHNsb3dkb3du 35621
IHJldHJlYXRlZA== 35622
SmVyZW15 35623
ZW5kYXM= 35624
KioqKio= 35625
ZXJpYw== 35626
IHJlaW5z 35627
b3Bw


d8_u91cfi
	local _obj_1 = require("块")
	_u5143_u7d20g, _u53d8_u91cfi = _obj_1[1], getmetatable(_obj_1[2]).__close
end


 {
	case LedgerEntryTypeAccount:
		tv, ok := value.(LedgerKeyAccount)
		if !ok {
			err = errors.New("invalid value, must be LedgerKeyAccount")
			return
		}
		result.Account = &tv
	case LedgerEntryTypeTrustline:
		tv, ok := value.(LedgerKeyTrustLine)
		if !ok {
			err = errors.New("invalid value, must be LedgerKeyTrustLine")
			return
		}
		result.TrustLine = &tv
	}
	return
}

// MustAccount retrieves the Account value from the union,
// panicing if the value is not set.
func (u LedgerKey) MustAccount() LedgerKeyAccount {
	val, ok := u.GetAccount()

	if !ok {
		panic("arm Account is not set")
	}

	return val
}

// GetAccount retrieves the Account value from the union,
// returning ok if the union's switch indicated the value is valid.
func (u LedgerKey) GetAccount() (result LedgerKeyAccount, ok bool) {
	armName, _ := u.ArmForSwitch(int32(u.Type))

	if armName == "Account" {
		result = *u.Account
		ok = true
	}

	return
}

// MustTrustLine retrieves the TrustLine value from the union,
// panicing if the value is not set.
func (u LedgerKey) MustTrustLine() LedgerKeyTrustLine {
	val, ok := u.GetTrustLine()

	if !ok {
		panic("arm TrustLine is not set")
	}

	return val
}

// GetTrustLine retrieves the TrustLine value from the union,
// returning ok if the union's switch indicated the value is valid.
func (u LedgerKey) GetTrustLine() (result LedgerKeyTrustLine, ok bool) {
	armName, _ := u.ArmForSwitch(int32(u.Type))

	if armName == "TrustLine" {
		result = *u.TrustLine
		ok = true
	}

	return
}

// EncodeTo encodes this value using the Encoder.
func (u LedgerKey) EncodeTo(e *xdr.Encoder) error {
	var err error
	if err = u.Type.EncodeTo(e); err != nil {
		return err
	}
	switch LedgerEntryType(u.Type) {
	case LedgerEntryTypeAccount:
		if err = (*u.Account).EncodeTo(e); err != nil {
			return err
		}
		return nil
	case LedgerEntryTypeTrustline:
		if err = (*u.TrustLine).EncodeTo(e); err != nil {
			return err
		}
		return nil
	}
	return fmt.Errorf("Type (LedgerEntryType) switch value '%d' is not valid for union LedgerKey", u.Type)
}

var _ decoderFrom = (*LedgerKey)(nil)

// DecodeFrom decodes this value using the Decoder.
func (u *LedgerKey) DecodeFrom(d *xdr.Decoder, maxDepth uint) (int, error) {
	if maxDepth == 0 {
		return 0, fmt.Errorf("decoding LedgerKey: %w", ErrMaxDecodingDepthReached)
	}
	maxDepth -= 1
	var err error
	var n, nTmp int
	nTmp, err = u.Type.DecodeFrom(d, maxDepth)
	n += nTmp
	if err != nil {
		return n, fmt.Errorf("decoding LedgerEntryType: %w", err)
	}
	switch LedgerEntryType(u.Type) {
	case LedgerEntryTypeAccount:
		u.Account = new(LedgerKeyAccount)
		nTmp, err = (*u.Account).DecodeFrom(d, maxDepth)
		n += nTmp
		if err != nil {
			return n, fmt.Errorf("decoding LedgerKeyAccount: %w", err)
		}
		return n, nil
	case LedgerEntryTypeTrustline:
		u.TrustLine = new


import os
import toml

# ホームディレクトリのパスを取得する
home_dir = os.path.expanduser("~")
# `.wanna`ディレクトリのパスを作成する
wanna_dir = os.path.join(home_dir, ".wanna")

# `.wanna`ディレクトリが存在しない場合は作成する
if not os.path.exists(wanna_dir):
    os.mkdir(wanna_dir)

def read_toml_file(file_path):
    with open(file_path, 'r') as f:
        data = toml.load(f)
    return data

def write_toml_file(file_path, data):
    with open(file_path, 'w') as f:
        toml.dump(data, f)

toml_file_name = os.path.join(wanna_dir, "config.toml")
if not os.path.exists(toml_file_name):
    write_toml_file(toml_file_name, {})

config = read_toml_file(toml_file_name)

def add_to_config(name, code, question):
    config[name] = {"question": question, "code": code}
    write_toml_file(toml_file_name, config)

def remove(name):
    del config[name]
    write_toml_file(toml_file_name, config)
    os.remove(os.path.join(wanna_dir, name))

def save_script(name, code, question):
    # configにもデータを保存する
    add_to_config(name, code, question)

    with open(os.path.join(wanna_dir, name), "w") as f:
        f.write(code)

    os.chmod(os.path.join(wanna_dir, name), 0o755)

def ideas():
    return [
        f"{key:<20}:{config[key]['question']}" for key in sorted(config)
    ]

def commands():
    return [
        key for key in sorted(config)
    ]

def exists(command):
    return command in config

def get_code(command):
    return config[command]["code"]

def get_command_path(command):
    return os.path.join(wanna_dir, command)


: auto;
  margin-left: 0em;
  -webkit-box-shadow: -1px -1px 0px 0px #bababc;
          box-shadow: -1px -1px 0px 0px #bababc;
}

/*--- Above ---*/

.ui.top.center.popup:before {
  top: auto;
  right: auto;
  bottom: -0.30714286em;
  left: 50%;
  margin-left: -0.30714286em;
}
.ui.top.left.popup {
  margin-left: 0em;
}
/*rtl:rename*/
.ui.top.left.popup:before {
  bottom: -0.30714286em;
  left: 1em;
  top: auto;
  right: auto;
  margin-left: 0em;
}
.ui.top.right.popup {
  margin-right: 0em;
}
/*rtl:rename*/
.ui.top.right.popup:before {
  bottom: -0.30714286em;
  right: 1em;
  top: auto;
  left: auto;
  margin-left: 0em;
}

/*--- Left Center ---*/

/*rtl:rename*/
.ui.left.center.popup:before {
  top: 50%;
  right: -0.30714286em;
  bottom: auto;
  left: auto;
  margin-top: -0.30714286em;
  -webkit-box-shadow: 1px -1px 0px 0px #bababc;
          box-shadow: 1px -1px 0px 0px #bababc;
}

/*--- Right Center  ---*/

/*rtl:rename*/
.ui.right.center.popup:before {
  top: 50%;
  left: -0.30714286em;
  bottom: auto;
  right: auto;
  margin-top: -0.30714286em;
  -webkit-box-shadow: -1px 1px 0px 0px #bababc;
          box-shadow: -1px 1px 0px 0px #bababc;
}

/* Arrow Color By Location */
.ui.bottom.popup:before {
  background: #FFFFFF;
}
.ui.right.center.popup:before,
.ui.left.center.popup:before {
  background: #FFFFFF;
}
.ui.top.popup:before {
  background: #FFFFFF;
}

/* Inverted Arrow Color */
.ui.inverted.bottom.popup:before {
  background: #1B1C1D;
}
.ui.inverted.right.center.popup:before,
.ui.inverted.left.center.popup:before {
  background: #1B1C1D;
}
.ui.inverted.top.popup:before {
  background: #1B1C1D;
}

/*******************************
            Coupling
*******************************/

/* Immediate Nested Grid */
.ui.popup > .ui.grid:not(.padded) {
  width: calc(100% + 1.75rem);
  margin: -0.7rem -0.875rem;
}

/*******************************
            States
*******************************/

.ui.loading.popup {
  display: block;
  visibility: hidden;
  z-index: -1;
}
.ui.animating.popup,
.ui.visible.popup {
  display: block;
}
.ui.visible.popup {
  -webkit-transform: translateZ(0px);
          transform: translateZ(0px);
  -webkit-backface-visibility: hidden;
          backface-visibility: hidden;
}

/*******************************
            Variations
*******************************/

/*--------------
     Basic
---------------*/

.ui.basic.popup:before {
  display: none;
}

/*--------------
     Wide
---------------*/

.ui.wide.popup {
  max-width: 350px;
}
.ui[class*="very wide"].popup {
  max-width: 550px;
}
@media only screen and (max-width: 767px) {
  .ui.wide.popup,
  .ui[class*="very wide"].pop


-border-top-colors: ThreeDShadow ThreeDDarkShadow;
  -moz-border-right-colors: ThreeDHighlight ThreeDLightShadow;
  -moz-border-bottom-colors: ThreeDHighlight ThreeDLightShadow;
  -moz-border-left-colors: ThreeDShadow ThreeDDarkShadow;
  background-color: #EEEEEE;
  color: -moz-DialogText;
}

.datepicker-popupgrid > .datepicker-mainbox {
  margin: 0;
  border: none;
}

.datepicker-gridlabel, .datepicker-weeklabel {
  text-align: center;
}

.datepicker-gridlabel[today="true"] {
  background-color: darkgrey;
  color: white;
}

.datepicker-gridlabel[selected="true"] {
  background-color: Highlight;
  color: HighlightText;
}

.datepicker-button {
  -moz-appearance: none;
  min-width: 8px;
  padding: 0px;
}

.datepicker-previous {
  list-style-image: url("chrome://global/skin/arrow/arrow-lft.gif");
}

.datepicker-next {
  list-style-image: url("chrome://global/skin/arrow/arrow-rit.gif");
}

.datepicker-previous:hover {
  list-style-image: url("chrome://global/skin/arrow/arrow-lft-hov.gif");
}

.datepicker-next:hover {
  list-style-image: url("chrome://global/skin/arrow/arrow-rit-hov.gif");
}

.datepicker-previous[disabled="true"] {
  list-style-image: url("chrome://global/skin/arrow/arrow-lft-dis.gif");
}

.datepicker-next[disabled="true"] {
  list-style-image: url("chrome://global/skin/arrow/arrow-rit-dis.gif");
}
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

@namespace url("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul");

.up {
  min-width: 0px;
  list-style-image: url("chrome://global/skin/arrow/arrow-up.gif");
}
.up[disabled="true"] {
  list-style-image: url("chrome://global/skin/arrow/arrow-up-dis.gif");
}

.down {
  min-width: 0px;
  list-style-image: url("chrome://global/skin/arrow/arrow-dn.gif");
}
.down[disabled="true"] {
  list-style-image: url("chrome://global/skin/arrow/arrow-dn-dis.gif");
}

.left {
  min-width: 0px;
  list-style-image: url("chrome://global/skin/arrow/arrow-lft.gif");
}
.left[disabled="true"] {
  list-style-image: url("chrome://global/skin/arrow/arrow-lft-dis.gif");
}

.right {
  min-width: 0px;
  list-style-image: url("chrome://global/skin/arrow/arrow-rit.gif");
}
.right[disabled="true"] {
  list-style-image: url("chrome://global/skin/arrow/arrow-rit-dis.gif");
}
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

@namespace url("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul");

#commonDialog > image {
  -moz-margin-end: 14px !important;
}

#commonDi


 * 8) + (i * 1) + 416);
					register_0 += base_0;
					_mm128_storeu_si128(out + (i * 1) + (0 * 8) + (8 * 52), register_0);
					register_0 = _mm128_loadu_si128(in + (0 * 8) + (i * 1) + 424);
					register_0 += base_0;
					_mm128_storeu_si128(out + (i * 1) + (0 * 8) + (8 * 53), register_0);
					register_0 = _mm128_loadu_si128(in + (0 * 8) + (i * 1) + 432);
					register_0 += base_0;
					_mm128_storeu_si128(out + (i * 1) + (0 * 8) + (8 * 54), register_0);
					register_0 = _mm128_loadu_si128(in + (0 * 8) + (i * 1) + 440);
					register_0 += base_0;
					_mm128_storeu_si128(out + (i * 1) + (0 * 8) + (8 * 55), register_0);
					register_0 = _mm128_loadu_si128(in + (0 * 8) + (i * 1) + 448);
					register_0 += base_0;
					_mm128_storeu_si128(out + (i * 1) + (0 * 8) + (8 * 56), register_0);
					register_0 = _mm128_loadu_si128(in + (0 * 8) + (i * 1) + 456);
					register_0 += base_0;
					_mm128_storeu_si128(out + (i * 1) + (0 * 8) + (8 * 57), register_0);
					register_0 = _mm128_loadu_si128(in + (0 * 8) + (i * 1) + 464);
					register_0 += base_0;
					_mm128_storeu_si128(out + (i * 1) + (0 * 8) + (8 * 58), register_0);
					register_0 = _mm128_loadu_si128(in + (0 * 8) + (i * 1) + 472);
					register_0 += base_0;
					_mm128_storeu_si128(out + (i * 1) + (0 * 8) + (8 * 59), register_0);
					register_0 = _mm128_loadu_si128(in + (0 * 8) + (i * 1) + 480);
					register_0 += base_0;
					_mm128_storeu_si128(out + (i * 1) + (0 * 8) + (8 * 60), register_0);
					register_0 = _mm128_loadu_si128(in + (0 * 8) + (i * 1) + 488);
					register_0 += base_0;
					_mm128_storeu_si128(out + (i * 1) + (0 * 8) + (8 * 61), register_0);
					register_0 = _mm128_loadu_si128(in + (0 * 8) + (i * 1) + 496);
					register_0 += base_0;
					_mm128_storeu_si128(out + (i * 1) + (0 * 8) + (8 * 62), register_0);
					register_0 = _mm128_loadu_si128(in + (0 * 8) + (i * 1) + 504);
					register_0 += base_0;
					_mm128_storeu_si128(out + (i * 1) + (0 * 8) + (8 * 63), register_0);
				}
			}
			void unffor(const uint8_t *__restrict a_in_p, uint8_t *__restrict a_out_p, uint8_t bw, const uint8_t *__restrict a_base_p)
			{
				 switch (bw)
				{
					case 0:
					   unffor_0bw_8ow_128crw_1


学、学术出版物、或会议演示层面的问题。它们对于防止语言及其标准库被分割成方言，并保证在编译器和平台之间的可移植性至关重要。这些问题包括：命名、名称查找、重载决策、语法细节、构件的确切含义、临时变量的生存周期、链接，还有其他很多很多。许多问题需要技巧才能解决，而拙劣的解决方案可能带来让人吃惊而具有破坏性的后果。解决方案往往经过精心设计，以最大程度减少对现有代码的破坏。委员会每年解决数百个问题。我估计委员至少要为此花费他们时间和精力的三分之一，乃至于三分之二。这项工作往往被忽视和低估。如果你用过计算机或计算机化的设备（例如电话或汽车），你得感谢 CWG 和 LWG 的工作。

当关注由一个庞大的委员会引起的问题时，也请记住，这些问题本质是一种有钱人的烦恼：C++ 的标准化流程由数百位各种不同背景的热心人士所驱动，他们的经验各不相同，但都满怀理想主义。

委员会应起到过滤作用，也就是说，把坏提案挡在标准之外，同时，还要提升最后通过的提案的品质。委员会的存在，是要鼓励大家提出建议，并主动提供帮助。然而，并没有正式的提案征求流程。

不存在全职的 C++ 设计者，尽管有许多全职人员从事 C++ 编译器、库和工具方面的工作。直到最近，委员会中还很少有人从事应用程序开发，这是一个问题，因为它使委员会偏向于语言“律师”、高阶特性和实现问题，而不是直接解决大量 C++ 开发者的需求——很多成员只是间接地了解这些需求。最近新成员急剧增加，也许会部分缓解这个问题。

委员会中的教育工作者相对较少。这可能是个问题，因为委员会（理所当然地）高度重视“易于学习”，但是委员们对其含义有着非常不同的理念（经常会意见强烈）。这往往使关于“简单性”和“易用性”的讨论变得混乱。

当思考组织问题对 C++ 发展的影响时，请记住，ISO 流程本不是为 200 人的会议而设计的——典型的 ISO 编程语言委员会只有一二十人。平均而言，我们在某种程度上是通过识别和解决问题来进行管理


84e4c43897fc4e51a6ff",
			seedChineseSimplified:  "0c510ef7585a9e506ef92152955ecda644398f475dc40ce642e0fabd3cc4dad74d0f42a224c557c66b2d90fef60fd7c58c73fade3ea261c612325c37d7cfe11b",
			seedChineseTraditional: "bf346a4b09f31be3b6d0aa4e840d7d8e6a6420ee50fce7348e7312e89ce4ea8536c2d1b5969d5e9e77f7ff269df126e6edf9d40a937a72799fb31a8ee0860613",
			seedItalian:            "25d048482d5ce15a5b2c412f23e8ae1ea4fbd19bcd5002b5a18bf045ac8ec6fa4ba95c34af1ff667602d28a51906ab7fa0cefc19b67bc2e780dbd21c244857f7",
			seedJapanese:           "b7f5478674839a3487a271014f066059490161a381ec57e9a00de0a3c7311ab51f20b53989c7bcbc923f956b5a16556bc6a4c143265e280769f12792d0e0913e",
			seedKorean:             "62392a9144379952afbcdd70c7e68f1a8ab06cc6fec4f0fe22915b8b26b0939061f31ae0c761579681bc0b3619fca8c8a27dcd9f964ab694068cac04f26de6ac",
			seedSpanish:            "338e1ee586e109e80a53af2294bca03f4a5a7e9d089f04d1f02b30dde370c8ae4268a37909bd278c21e29fc24e2a3f30104eb8dd153192eda5646415dbc21fc0",
		},
		{
			entropy:                "b63a9c59a6e641f288ebc103017f1da9f8290b3da6bdef7b",
			mnemEnglish:            "renew stay biology evidence goat welcome casual join adapt armor shuffle fault little machine walk stumble urge swap",
			mnemChineseSimplified:  "芽 碗 想 富 训 粪 争 额 生 使 怒 阿 折 泥 剑 勾 傅 浇",
			mnemChineseTraditional: "芽 碗 想 富 訓 糞 爭 額 生 使 怒 阿 折 泥 劍 勾 傅 澆",
			mnemItalian:            "rimbalzo solubile avvenire fanfara idra vicenda calibro malto adipe anatra scuderia focaccia monetario mummia velcro spatola uditivo staffa",
			mnemJapanese:           "ぬすむ ふっかつ うどん こうりつ しつじ りょうり おたがい せもたれ あつめる いちりゅう はんしゃ ごますり そんけい たいちょう らしんばん ぶんせき やすみ ほいく",
			mnemKorean:             "재정 체온 교통 번역 새벽 홀로 꽃잎 시금치 간접 경제 중반 본사 아시아 알코올 현상 최선 학위 치약",
			mnemSpanish:            "pleito semana ático ensayo giro viaje buceo júpiter activo amigo repetir fábula llover madera v


RawScore: $playerRawScore, '
        'timeDimension: $timeDimension, '
        'hasPlayerInfo: $hasPlayerInfo)';
  }
}
/*
    Copyright 2020-2024. Huawei Technologies Co., Ltd. All rights reserved.

    Licensed under the Apache License, Version 2.0 (the "License")
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        https://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.
*/

part of huawei_nearbyservice;

class MessagePicker {
  final bool includeAllTypes;
  final List<UidInstance> eddystoneUids;
  final List<IBeaconInfo> iBeaconIds;
  final List<NamespaceType> namespaceTypes;

  static final MessagePicker includeAll =
      MessagePickerBuilder().includeAll().build();

  bool equals(dynamic object) {
    return identical(this, object) ||
        object is MessagePickerBuilder &&
            _equalsEddystone(eddystoneUids, object._eddystoneUids) &&
            _equalsIBeacon(iBeaconIds, object._iBeaconIds) &&
            _equalsNamespace(namespaceTypes, object._namespaceTypes);
  }

  MessagePicker._builder(MessagePickerBuilder builder)
      : includeAllTypes = builder._includeAllTypes,
        eddystoneUids = builder._eddystoneUids,
        iBeaconIds = builder._iBeaconIds,
        namespaceTypes = builder._namespaceTypes;

  Map<String, dynamic> toMap() {
    Map<String, dynamic> map = <String, dynamic>{};
    map['includeAllTypes'] = includeAllTypes;
    if (iBeaconIds.isNotEmpty) {
      map['iBeaconIds'] = iBeaconIds.map((IBeaconInfo e) => e.toMap()).toList();
    }
    if (eddystoneUids.isNotEmpty) {
      map['eddystoneUids'] =
          eddystoneUids.map((UidInstance e) => e.toMap()).toList();
    }
    if (namespaceTypes.isNotEmpty) {
      map['namespaceTypes'] =
          namespaceTypes.map((NamespaceType e) => e.toMap()).toList();
    }

    return map;
  }

  @override
  String toString() {
    List<NamespaceType> types = List<NamespaceType>.empty(growable: true);
    eddystoneUids.forEach((UidInstance element) {
      types.add(NamespaceType('_reserved_namespace', '_eddystone_uid'));
    });

    iBeaconIds.forEach((IBeaconInfo element) {
      types.add(NamespaceType('_reserved_namespace', '_ibeacon_id'));
    });

    types.addAll(namespaceTypes);
    String str = '';
    for (NamespaceType element in types) {
      str += element.toString();
    }

    return 'MessagePicker{includeAllTypes=$includeAllTypes, messageTypes=$str}';
  }

  bool _equalsEddystone(List<UidInstance> l1, List<UidInstance> l2) {
    bool equals = false;
    if (l1.length == l2.length) {
      for (int i = 0; i < l1.length; i++) {
        equals = l1[i].equals(l2[i]);
      }
    }
    return equals;
  }

  bool _equalsIBeacon(List<IBeaconInfo> l1, List<IBeaconInfo> l2) {
    bool equals = false;
    if (l1.length == l2.length) {
      for (int i = 0; i < l1.length; i++) {
        equals = l1[i].equals(l2[i]);
      }
    }
    return equals;
  }

  bool _equalsNamespace(List<Name


ntinue
            if exp_config[key] is None:
                continue

            exp_config[key] = exp_config[key].replace(
                "<dataset_split>", exp_config.dataset_split
            )

    if "model_name" in exp_config:
        for key in path_keys:
            if key not in exp_config:
                continue
            if exp_config[key] is None:
                continue

            exp_config[key] = exp_config[key].replace(
                "<model_name>", exp_config.model_name
            )

    if "dataset" in exp_config:
        for key in path_keys:
            if key not in exp_config:
                continue
            if exp_config[key] is None:
                continue

            exp_config[key] = exp_config[key].replace(
                "<dataset>", exp_config.dataset
            )


puocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
d_LimitsA, uint *&
# 342 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
d_LimitsB, uint &
# 343 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
stride, uint &
# 344 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
N) ;
# 336 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
template< uint sortDir> void mergeElementaryIntervalsKernel(uint *
# 337 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
d_DstKey, uint *
# 338 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
d_DstVal, uint *
# 339 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
d_SrcKey, uint *
# 340 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
d_SrcVal, uint *
# 341 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
d_LimitsA, uint *
# 342 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
d_LimitsB, uint
# 343 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
stride, uint
# 344 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
N)
# 345 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
{__wrapper__device_stub_mergeElementaryIntervalsKernel<sortDir>(d_DstKey,d_DstVal,d_SrcKey,d_SrcVal,d_LimitsA,d_LimitsB,stride,N);
# 409 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
}
# 411 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
static void mergeElementaryIntervals(uint *
# 412 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
d_DstKey, uint *
# 413 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
d_DstVal, uint *
# 414 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
d_SrcKey, uint *
# 415 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
d_SrcVal, uint *
# 416 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
d_LimitsA, uint *
# 417 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.cu"
d_LimitsB, uint
# 418 "/home/andrew/repositories/gpuocelot/tests/cuda3.2/tests/mergeSort/mergeSort.


onntrack_ipv4
nf_conntrack_ipv4      16384  23
nf_defrag_ipv4         16384  1 nf_conntrack_ipv4
nf_conntrack          135168  10 xt_conntrack,nf_conntrack_ipv6,nf_conntrack_ipv4,nf_nat,nf_nat_ipv6,ipt_MASQUERADE,nf_nat_ipv4,xt_nat,nf_conntrack_netlink,ip_vs
```

### 配置k8s需要的内核参数

开启一些k8s集群中必须的内核参数，所有节点配置k8s内核：

```sh
cat <<EOF > /etc/sysctl.d/k8s.conf
net.ipv4.ip_forward = 1
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
fs.may_detach_mounts = 1
vm.overcommit_memory=1
vm.panic_on_oom=0
fs.inotify.max_user_watches=89100
fs.file-max=52706963
fs.nr_open=52706963
net.netfilter.nf_conntrack_max=2310720

net.ipv4.tcp_keepalive_time = 600
net.ipv4.tcp_keepalive_probes = 3
net.ipv4.tcp_keepalive_intvl =15
net.ipv4.tcp_max_tw_buckets = 36000
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_max_orphans = 327680
net.ipv4.tcp_orphan_retries = 3
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_max_syn_backlog = 16384
net.ipv4.ip_conntrack_max = 65536
net.ipv4.tcp_max_syn_backlog = 16384
net.ipv4.tcp_timestamps = 0
net.core.somaxconn = 16384
EOF
```

```sh
# 然后执行
sysctl --system
```

所有节点配置完内核后，重启服务器，保证重启后内核依旧加载

```sh
reboot
lsmod | grep --color=auto -e ip_vs -e nf_conntrack
```

## 基本组件安装

### 安装docker

```sh
主要安装的是集群中用到的各种组件，比如Docker-ce、Kubernetes各组件等。

查看可用docker-ce版本：
yum list docker-ce.x86_64 --showduplicates | sort -r
wget https://download.docker.com/linux/centos/7/x86_64/edge/Packages/containerd.io-1.2.13-3.2.el7.x86_64.rpm
yum install containerd.io-1.2.13-3.2.el7.x86_64.rpm -y

安装指定版本的Docker：
yum -y install docker-ce-17.09.1.ce-1.el7.centos
安装最新版本的Docker
yum install docker-ce -y
```

**注意 : **

```sh
由于新版kubelet建议使用systemd，所以可以把docker的CgroupDriver改成systemd
cat > /etc/docker/daemon.json <<EOF
{
  "exec-opts": ["native.cgroupdriver=systemd"]
}
EOF
所有节点设置开机自启动Docker：
systemctl daemon-reload && systemctl enable --now docker
```

### 安装k8s组件

```sh
yum list kubeadm.x86_64 --showduplicates | sort -r

所


e(builder, when (securityType) {
            SoftApConfiguration.SECURITY_TYPE_OPEN,
            SoftApConfiguration.SECURITY_TYPE_WPA3_OWE_TRANSITION,
            SoftApConfiguration.SECURITY_TYPE_WPA3_OWE -> null
            else -> passphrase
        }, securityType)
        setChannelsCompat(builder, channels)
        setBssid(builder,
            if (Build.VERSION.SDK_INT < 31 || macRandomizationSetting == RANDOMIZATION_NONE) bssid else null)
        setMaxNumberOfClients(builder, maxNumberOfClients)
        try {
            setShutdownTimeoutMillis(builder, shutdownTimeoutMillis)
        } catch (e: InvocationTargetException) {
            if (e.targetException is IllegalArgumentException) try {
                setShutdownTimeoutMillis(builder, -1 - shutdownTimeoutMillis)
            } catch (e2: InvocationTargetException) {
                e2.addSuppressed(e)
                throw e2
            } else throw e
        }
        setAutoShutdownEnabled(builder, isAutoShutdownEnabled)
        setClientControlByUserEnabled(builder, isClientControlByUserEnabled)
        setHiddenSsid(builder, isHiddenSsid)
        setAllowedClientList(builder, allowedClientList)
        setBlockedClientList(builder, blockedClientList)
        if (Build.VERSION.SDK_INT >= 31) {
            setMacRandomizationSetting(builder, macRandomizationSetting)
            setBridgedModeOpportunisticShutdownEnabled(builder, isBridgedModeOpportunisticShutdownEnabled)
            setIeee80211axEnabled(builder, isIeee80211axEnabled)
            if (Build.VERSION.SDK_INT >= 33) {
                setIeee80211beEnabled(builder, isIeee80211beEnabled)
                setBridgedModeOpportunisticShutdownTimeoutMillis(builder, bridgedModeOpportunisticShutdownTimeoutMillis)
                setVendorElements(builder, vendorElements)
                val needsUpdate = persistentRandomizedMacAddress != null && sac?.let {
                    getPersistentRandomizedMacAddress(it) as MacAddress
                } != persistentRandomizedMacAddress
                if (needsUpdate) try {
                    setRandomizedMacAddress(builder, persistentRandomizedMacAddress)
                } catch (e: ReflectiveOperationException) {
                    Timber.w(e)
                }
                for (bandType in BAND_TYPES) {
                    val value = allowedAcsChannels[bandType] ?: emptySet()
                    try {
                        setAllowedAcsChannels(builder, bandType, value.toIntArray())
                    } catch (e: InvocationTargetException) {
                        if (value.isNotEmpty()) throw e
                    }
                }
                setMaxChannelBandwidth(builder, maxChannelBandwidth)
            }
        }
        return build(builder) as SoftApConfiguration
    }

    /**
     * Documentation: https://github.com/zxing/zxing/wiki/Barcode-Contents#wi-fi-network-config-android-ios-11
     * Based on: https://android.googlesource.com/platform/packages/apps/Settings/+/4a5ff58/src/com/android/settings/wifi/dpp/WifiNetworkConfig.java#161
     */
    fun toQrCode() = StringBuilder("WIFI:").apply {
        when (securityType) {
            SoftApConfiguration.SECURITY_TYPE_OPEN, SoftApConfiguration.SECURITY_TYPE_WPA3_OWE_TRANSITION,
            SoftApConfiguration.SECURITY_TYPE_WPA3_OWE -> { }
            SoftApConfiguration.SECURITY_TYPE_WPA2_PSK, SoftApConfiguration.SECURITY_TYPE_WPA3_SAE_TRANSITION -> {
                append("T:WPA;")
            }
            SoftApConfiguration.SECURITY_TYPE_WPA3_


1
	   /// The dispatch origin for this call must be `Signed` either by the Root or authorized account.
		#[weight = 10_000 + T::DbWeight::get().writes(1)]
		pub fn transfer_shares_asset_generating_vcu(origin, sender: T::AccountId, recipient: T::AccountId, avg_account: Vec<u8>, number_of_shares: u32) -> DispatchResult {

			match ensure_root(origin.clone()) {
				Ok(()) => Ok(()),
				Err(e) => {
					ensure_signed(origin).and_then(|o: T::AccountId| {
						if AuthorizedAccountsAGV::<T>::contains_key(&o) {
							Ok(())
						} else {
							Err(e)
						}
					})
				}
			}?;

			ensure!(AssetsGeneratingVCUShares::<T>::contains_key(&sender, &avg_account), Error::<T>::AssetGeneratedSharesNotFound);

			let sender_shares = AssetsGeneratingVCUShares::<T>::get(&sender, &avg_account);

			// check whether asset generated shares exists or not
			ensure!(number_of_shares >= sender_shares, Error::<T>::NumberofSharesNotFound);

			AssetsGeneratingVCUShares::<T>::try_mutate(&sender, &avg_account, |share| -> DispatchResult {
				let total_sh = share.checked_sub(number_of_shares).ok_or(Error::<T>::TooLessShares)?;
				*share = total_sh;
				Ok(())
			})?;

			AssetsGeneratingVCUShares::<T>::try_mutate(&recipient, &avg_account, |share| -> DispatchResult {
				let total_sh = share.checked_add(number_of_shares).ok_or(Error::<T>::Overflow)?;
				*share = total_sh;
				Ok(())
			})?;

			// Generate event
			Self::deposit_event(RawEvent::AssetsGeneratingVCUSharesTransferred(recipient));
			// Return a successful DispatchResult
			Ok(())
		}

		/// To store asset generating vcu schedule
		///
		/// ex: avg_account: <KEY>
		/// The dispatch origin for this call must be `Signed` either by the Root or authorized account.
		#[weight = 10_000 + T::DbWeight::get().writes(1)]
		pub fn create_asset_generating_vcu_schedule(origin, avg_account_id: T::AccountId, avg_id: u32, period_days: u64, amount_vcu: Balance, token_id: u32) -> DispatchResult {

			match ensure_root(origin.clone()) {
				Ok(()) => Ok(()),
				Err(e) => {
					ensure_signed(origin).and_then(|o: T::AccountId| {
						if AuthorizedAccountsAGV::<T>::contains_key(&o) {
							Ok(())
						} else {
							Err(e)
						}
					})
				}
			}?;

			// check whether asset generated VCU exists or not
			ensure!(AssetsGeneratingVCU::<T>::contains_key(&avg_account_id, &avg_id), Error::<T>::AssetGeneratedVCUNotFound);
			ensure!(amount_vcu > 0, Error::<T>::InvalidVCUAmount);

			ensure!(AssetAVGBundle::<T>::contains_key(&avg_account_id, &avg_id), Error::<T>::AssetAVGBundleNotFound);

			let bundle_asset_id = AssetAVGBundle::<T>::get(&avg_account_id, &avg_id);

			ensure!(bundle_asset_id == token_id, Error::<T>::BundleAssetIdNotSame);

    		let json = Self::create_json_string(vec![("period_days",&mut period_days.to_string().as_bytes().to_vec()), ("amount_vcu",&mut  amount_vcu.to_string().as_bytes().to_vec()), ("token_id",&mut  token_id.to_string().as_bytes().to_vec())]);

			AssetsGeneratingVCUS


sia': const Locale('id'),
  'عربي': const Locale('ar'),
  'Suomi': const Locale('fi'),
  'Nederlands' : const Locale('nl'),
  'اُردُو' : const Locale('ur'),
  'Hrvat' : const Locale('hr'),
  'Македонски': const Locale('mk'),
  'Română' : const Locale('ro'),
  'Tiếng Việt' : const Locale('vi'),
};

Map<String, String> weatherIconPathMap = {
  'Clear Night': "assets/weather_icons/clear_night.svg",
  'Partly Cloudy': "assets/weather_icons/partly_cloudy.svg",
  'Clear Sky': "assets/weather_icons/clear_sky.svg",
  'Overcast': "assets/weather_icons/cloudy.svg",
  'Haze': "assets/weather_icons/haze.svg",
  'Rain': "assets/weather_icons/rain.svg",
  'Sleet': "assets/weather_icons/sleet.svg",
  'Drizzle': "assets/weather_icons/drizzle.svg",
  'Thunderstorm': "assets/weather_icons/thunderstorm.svg",
  'Heavy Snow': "assets/weather_icons/heavy_snow.svg",
  'Fog': "assets/weather_icons/fog.svg",
  'Snow': "assets/weather_icons/snow.svg",
  'Heavy Rain': "assets/weather_icons/heavy_rain.svg",
  'Cloudy Night' : "assets/weather_icons/cloudy_night.svg",
};

//each condition has a separate unsplash collection where i selected the best images i could find
//this map links the weather conditions to the collection's id
Map<String, String> conditionToCollection = {
  'Clear Night': 'QmrZHMXsUjU',
  'Partly Cloudy': 'HAtvB157RoQ',
  'Clear Sky': 'XMGA2-GGjyw',
  'Overcast': 'lH8D73y8two',
  'Haze': 'p0Z3vz_3QDI',
  'Rain': 'EHfrmBnBxKE',
  'Sleet': '6iA4l-qOEjQ',
  'Drizzle': 'gPoFdup1ER0',
  'Thunderstorm': 'u5yh41EfPWk',
  'Heavy Snow': 'Wz6zjLX6zoQ',
  'Fog': 'lt3McWCS6sk',
  'Snow': 'IV6PyvU0Vyo',
  'Heavy Rain': '9w3d8QBzjsw',
  'Cloudy Night' : 'ymdgzsktNTE'
};

String? conditionTranslation(String key, localizations) {
  final localizationMap = {
    'Clear Night': localizations.clearNight,
    'Partly Cloudy': localizations.partlyCloudy,
    'Clear Sky':localizations.clearSky,
    'Overcast': localizations.overcast,
    'Haze': localizations.haze,
    'Rain': localizations.rain,
    'Sleet': localizations.sleet,
    'Drizzle': localizations.drizzle,
    'Thunderstorm': localizations.thunderstorm,
    'Heavy Snow': localizations.heavySnow,
    'Fog': localizations.fog,
    'Snow': localizations.snow,
    'Heavy Rain': localizations.heavyRain,
    'Cloudy Night' : localizations.cloudyNight,
  };

  return localizationMap[key];
}

Map<String, List<String>> assetPhotoCredits = {
  'Clear Night': [
    'https://unsplash.com/photos/time-lapse-photography-of-stars-at-nighttime-YvOT1lJ0NPQ',
    'Jack B',
    'https://unsplash.com/@nervum'
  ],
  'Partly Cloudy': [
    'https://unsplash.com/photos/ocean-under-clouds-Plkff-dVfNM',
    'Edvinas Bruzas',
    'https://unsplash.com/@edvinasbru


死在公社（但是他两人材料我也没看，又没研究）。

   3，违法乱纪。1959年10月初，县委召开党员扩干大会上，在会议当中进行了斗打公社党委副书记、王荣义头毛扒掉，头打肿，同时将党委委员副社长李家乐的衣服撕破，身上打青，另将县委你根本长郭均功也进行了毒打，斗郭时，我亲自主持，这次共斗争5人，我应负责。由于在县扩干会议，这一股的歪风，造成党员干部的恐慌，同月14日回到公社，召开公社小队长以上的党员干部会议时，由（应加于——编者）陈墩大队长李文开不敢到会，在会议中并在有的地方进行了斗打，由于这样不管，是党员干部和非党员干部，给党和政府反映真实情况，严重的脱离了群众，群众因饿死现象，就不敢反映真实情况，所以我在南向店造成严重的最后恶果，并且我亲自在县委扩大会上打了晏河公社党委副书记张本深几下子。由于我个人不顾国法党纪，造成其它干部进行打人，干部与干部之间，领导与领导之间互不相信，离心离德，所以全公社造下（应为成，下同——编者）破产。

   4，在光山事件中的认识。自从1960年12月底进大仓，和反右倾学习以来，这个思想回忆起来，实在光山事件中犯的错误是严重的，虽然在党的教育十余年，不断（应为但——编者）没有给党和群众做出贡献，给党造下不可挽回的损失，在人民当中和劳动人民果实抢购透底，造成人口大量死亡，生产遭到破坏，是对不起光山的父母、姐妹，更重要的破坏党中央提出的三面红旗，在这种情况下为个人得失，不顾党中央的指示，一切，好表扬，不愿受批评，在马龙山弯曲党中央指示政策，自己是积极的跟着马龙山一块跑，陷害了光山的人民，进行毒打和亲自的斗争，造成乱七八糟，不顾党纪国法，自己为王，所以说我个人错误是极其严重的，作风是恶劣的，并要求上级党给予我撤销一切职务，开除党籍，下到农村去劳动改造，挽回党和人民的关系。

   5，个人保证。由于在民主革命补课运动以来，新的县委对（应为的——编者）教育和帮助，全体党员干部和群众对我严格批评和教育，我深刻认识到是一个血地（应为的——编者）教训，我个人进一步提高了马克思和列宁主义的理论，处处为人民着想，听取上级的正确指示和教育，到农村劳动当中偿还人民血债，改造我的思想，忠心恳（应为耿——编者）恳地的为人民服务，感谢党和新的县委对我的帮助和教育，就是在工作中，积极的、大胆的把问题向新的县委反映和汇报，恢复光山破产状况（原文如此——编者）。

   芦子玉1962年5月27日

   来源：

   河南省某档案馆

   <a h


ntName'] as core.String?,
        listingCount: json_['listingCount'] as core.String?,
        name: json_['name'] as core.String?,
        type: json_['type'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() => {
    if (gbpAccountId != null) 'gbpAccountId': gbpAccountId!,
    if (gbpAccountName != null) 'gbpAccountName': gbpAccountName!,
    if (listingCount != null) 'listingCount': listingCount!,
    if (name != null) 'name': name!,
    if (type != null) 'type': type!,
  };
}

/// A list of geotargets that defines the region area.
class GeoTargetArea {
  /// A non-empty list of
  /// [location IDs](https://developers.google.com/adwords/api/docs/appendix/geotargeting).
  ///
  /// They must all be of the same location type (for example, state).
  ///
  /// Required.
  core.List<core.String>? geotargetCriteriaIds;

  GeoTargetArea({this.geotargetCriteriaIds});

  GeoTargetArea.fromJson(core.Map json_)
    : this(
        geotargetCriteriaIds:
            (json_['geotargetCriteriaIds'] as core.List?)
                ?.map((value) => value as core.String)
                .toList(),
      );

  core.Map<core.String, core.dynamic> toJson() => {
    if (geotargetCriteriaIds != null)
      'geotargetCriteriaIds': geotargetCriteriaIds!,
  };
}

/// Response message for the GetAccountForGcpRegistration method.
class GetAccountForGcpRegistrationResponse {
  /// The name of the merchant account id that the GCP is registered with.
  core.String? name;

  GetAccountForGcpRegistrationResponse({this.name});

  GetAccountForGcpRegistrationResponse.fromJson(core.Map json_)
    : this(name: json_['name'] as core.String?);

  core.Map<core.String, core.dynamic> toJson() => {
    if (name != null) 'name': name!,
  };
}

/// The current status of establishing of the service.
///
/// (for example, pending approval or approved).
class Handshake {
  /// The most recent account to modify the account service's `approval_status`.
  ///
  /// Output only.
  /// Possible string values are:
  /// - "ACTOR_UNSPECIFIED" : Unspecified actor.
  /// - "ACCOUNT" : The last change was done by the account who has this
  /// service.
  /// - "OTHER_PARTY" : The last change was done by the other party who this
  /// service points to.
  core.String? actor;

  /// The approval state of this handshake.
  ///
  /// Output only.
  /// Possible string values are:
  /// - "APPROVAL_STATE_UNSPECIFIED" : Unspecified approval status.
  /// - "PENDING" : The service was proposed and is waiting to be confirmed.
  /// - "ESTABLISHED" : Both parties have confirmed the service.
  /// - "REJECTED" : The service proposal was rejected.
  core.String? approvalState;

  Handshake({this.actor, this.approvalState});

  Handshake.fromJson(core.Map json_)
    : this(
        actor: json_['actor'] as core.String?,
        approvalState: json_['approvalState'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() => {
    if (actor != null) 'actor': actor!,
    if (approvalState != null) 'approvalState': approvalState!,
  };
}

/// A non-empty list of row or column headers for a table.
///
/// Exactly one of `prices`, `weights`, `num_items`, `postal_code_group_names`,
/// or `location` must be set.
class Headers {
  /// A list of location ID sets.
  ///
  /// Must be non-empty. Can only be set if all


游戏结束时间
	QuitTxHash  string      `protobuf:"bytes,13,opt,name=quitTxHash,proto3" json:"quitTxHash,omitempty"`  //游戏结束交易hash
	DealerAddr  string      `protobuf:"bytes,14,opt,name=dealerAddr,proto3" json:"dealerAddr,omitempty"`  //下局庄家地址
	IsWaiting   bool        `protobuf:"varint,15,opt,name=isWaiting,proto3" json:"isWaiting,omitempty"`   //游戏是否处于等待状态
	PreStatus   int32       `protobuf:"varint,16,opt,name=preStatus,proto3" json:"preStatus,omitempty"`   //上一index的状态
	Round       int32       `protobuf:"varint,17,opt,name=round,proto3" json:"round,omitempty"`           //当前游戏回合数
}

func (x *PokerBull) Reset() {
	*x = PokerBull{}
	if protoimpl.UnsafeEnabled {
		mi := &file_pokerbull_proto_msgTypes[0]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*PokerBull) ProtoMessage() {}

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

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

func (x *PokerBull) GetGameId() string {
	if x != nil {
		return x.GameId
	}
	return ""
}

func (x *PokerBull) GetStatus() int32 {
	if x != nil {
		return x.Status
	}
	return 0
}

func (x *PokerBull) GetStartTime() int64 {
	if x != nil {
		return x.StartTime
	}
	return 0
}

func (x *PokerBull) GetStartTxHash() string {
	if x != nil {
		return x.StartTxHash
	}
	return ""
}

func (x *PokerBull) GetValue() int64 {
	if x != nil {
		return x.Value
	}
	return 0
}

func (x *PokerBull) GetPoker() *PBPoker {
	if x != nil {
		return x.Poker
	}
	return nil
}

func (x *PokerBull) GetPlayers() []*PBPlayer {
	if x != nil {
		return x.Players
	}
	return nil
}

func (x *PokerBull) GetPlayerNum() int32 {
	if x != nil {
		return x.PlayerNum
	}
	return 0
}

func (x *PokerBull) GetResults() []*PBResult {
	if x != nil {
		return x.Results
	}
	return nil
}

func (x *PokerBull) GetIndex() int64 {
	if x != nil {
		return x.Index
	}
	return 0
}

func (x *PokerBull) GetPrevIndex() int64 {
	if x != nil {
		return x.PrevIndex
	}
	return 0
}

func (x


estamp format: 1363238564[datetime]
	Server datetime format: 2013-03-14 09:22:44[Y/m/d]
	Server datetime format: 2013-03-14 09:22:44[time]
	Server datetime format: 2013-03-14 09:22:44';
	echo $daterDataHandler->handleDataTimezone($data);

Will print:

	Timestamp format: 1363238564 (will not be handled)
	Timestamp format: 2013/03/14
	Timestamp format: 14.03.2013 07:22
	Server datetime format: 2013/03/14
	Server datetime format: 07:22
	Server datetime format: 2013-03-14 07:22:44

### Convert output datetime to client timezone

	$daterDataHandler->enableOutputTimezoneHandler();
	echo $data; // $data from previous example will print the same as in prevous example

## Recommended

* Google Chrome extension [PHP Console](http://goo.gl/b10YF)
* Google Chrome extension [JavaScript Errors Notifier](http://goo.gl/kNix9)
# PHP Console server library

[![Author](http://img.shields.io/badge/author-@barbushin-blue.svg?style=flat-square)](https://www.linkedin.com/in/barbushin)
[![GitHub release](https://img.shields.io/github/release/barbushin/php-console.svg?maxAge=2592000&style=flat-square)](https://packagist.org/packages/php-console/php-console)
[![Coverage Status](https://img.shields.io/scrutinizer/coverage/g/barbushin/php-console.svg?style=flat-square)](https://scrutinizer-ci.com/g/barbushin/php-console/code-structure)
[![Build Status](https://img.shields.io/travis/barbushin/php-console/master.svg?style=flat-square)](https://travis-ci.org/barbushin/php-console)
[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](LICENSE)
[![Packagist](https://img.shields.io/packagist/dt/php-console/php-console.svg?maxAge=86400&style=flat-square)](https://packagist.org/packages/php-console/php-console)

PHP Console allows you to handle PHP errors & exceptions, dump variables, execute PHP code remotely and many other things using [Google Chrome extension PHP Console](https://chrome.google.com/webstore/detail/php-console/nfhmhhlpfleoednkpnnnkolmclajemef) and [PhpConsole server library](https://github.com/barbushin/php-console).

### Overview

* See [presentation video](http://www.youtube.com/watch?v=_4kG-Zrs2Io).
* Install Google Chrome extension [PHP Console](https://chrome.google.com/webstore/detail/php-console/nfhmhhlpfleoednkpnnnkolmclajemef).
* See how it works on [live demo](http://consle.com/instance/examples) page.
* PHP Console extension [features list and screenshots](https://github.com/barbushin/php-console/wiki/PHP-Console-extension-features).
* PHP Console server library [features list](https://github.com/barbushin/php-console/wiki/PHP-Console-server-features).
* Chrome extension source code https://github.com/barbushin/php-console-extension

### Requirements

* [PHP Console extension](https://chrome.google.com/webstore/detail/php-console/nfhmhhlpfleoednkpnnnkolmclajemef) must be installed on Google Chrome ([extension source code](https://github.com/barbushin/php-console-extension) is also on GitHub)
* PHP 5.3 (or later) on server.


 '0';
            }
            return s + fraction;
        }
        let digits: any[] = s.split('');
        let pos = decimalIndex + decimal;
        let roundDigit = digits[pos + 1];
        if (roundDigit > 4) {
            //跳过小数点
            if (pos == decimalIndex) {
                --pos;
            }
            digits[pos] = Number(digits[pos] || 0) + 1;
            //循环进位
            while (digits[pos] == 10) {
                digits[pos] = 0;
                --pos;
                if (pos == decimalIndex) {
                    --pos;
                }
                digits[pos] = Number(digits[pos] || 0) + 1;
            }
        }
        //避免包含末尾的.符号
        if (decimal == 0) {
            decimal--;
        }
        return digits.slice(0, decimalIndex + decimal + 1).join('');
    }

    /**
     * 将给定的数值转义为JSON字符串
     * @param num 目标数值
     * @return 1=>'1'
     */
    static toJson(num: number): number {
        return num;
    }

    /**
     * 返回字符串
     * @param num 目标数值
     * @return
     */
    static toString(num: number): string {
        return num + "";
    }

    /***
     * 将给定的对象转为Number类型
     * @param object 给定的对象
     * @return 转换为Number后的结果
     */
    static valueOf(object: any): number {
        return Number(object);
    }

}import { randomSeed } from "roughjs/bin/math";
import nanoid from "nanoid";
import { Drawable } from "roughjs/bin/core";

import { ExcalidrawElement, ExcalidrawTextElement } from "../element/types";
import { measureText } from "../utils";

export function newElement(
  type: string,
  x: number,
  y: number,
  strokeColor: string,
  backgroundColor: string,
  fillStyle: string,
  strokeWidth: number,
  roughness: number,
  opacity: number,
  width = 0,
  height = 0,
) {
  const element = {
    id: nanoid(),
    type,
    x,
    y,
    width,
    height,
    strokeColor,
    backgroundColor,
    fillStyle,
    strokeWidth,
    roughness,
    opacity,
    isSelected: false,
    seed: randomSeed(),
    shape: null as Drawable | Drawable[] | null,
  };
  return element;
}

export function newTextElement(
  element: ExcalidrawElement,
  text: string,
  font: string,
) {
  const metrics = measureText(text, font);
  const textElement: ExcalidrawTextElement = {
    ...element,
    type: "text",
    text: text,
    font: font,
    // Center the text
    x: element.x - metrics.width / 2,
    y: element.y - metrics.height / 2,
    width: metrics.width,
    height: metrics.height,
    baseline: metrics.baseline,
  };

  return textElement;
}

export function duplicateElement(element: ReturnType<


 if (stats.hasValidS())
            b.kv(M.grpc.DishObstructionStats.valid_s, Format.secD(stats.validS));

          b.kv(M.grpc.DishObstructionStats.currently_obstructed, stats.currentlyObstructed);

          if (stats.hasAvgProlongedObstructionDurationS())
            b.kv(M.grpc.DishObstructionStats.avg_prolonged_obstruction_duration_s,
                Format.secD(stats.avgProlongedObstructionDurationS));

          if (stats.hasAvgProlongedObstructionIntervalS())
            b.kv(M.grpc.DishObstructionStats.avg_prolonged_obstruction_interval_s,
                Format.secD(stats.avgProlongedObstructionIntervalS));

          if (stats.hasAvgProlongedObstructionValid())
            b.kv(M.grpc.DishObstructionStats.avg_prolonged_obstruction_valid, stats.avgProlongedObstructionValid);

          if (stats.hasTimeObstructed())
            b.kv(M.grpc.DishObstructionStats.time_obstructed, stats.timeObstructed);

          if (stats.hasPatchesValid())
            b.kv(M.grpc.DishObstructionStats.patches_valid, stats.patchesValid);
        }

        if (b.widgets.length > 1) {
          rows.addAll(b.widgets);
        }
      }

      if (status.hasReadyStates()) {
        var b = KVWidgetBuilder(context, theme);
        b.header(M.header.ready_states);
        var states = status.readyStates;
        for (var e in (states.info_.byName).entries) {
          var key = e.key;
          var val = states.getField(e.value.tagNumber) ?? false;
          if (key=="cady" && (hw.startsWith("rev4") || hw=="rev_mini_prod1"  || hw.startsWith("mini1_prod")))
            continue;
          var desc = R.i18n.map["grpc.DishReadyStates.$key"];
          if (desc!=null)
            desc = " ($desc)";
          b.kv("$key$desc", val, ok: val);
        }

        if (b.widgets.length > 1) {
          rows.addAll(b.widgets);
        }
      }

      if (status.hasInitializationDurationSeconds()) {
        var b = KVWidgetBuilder(context, theme);
        b.header(M.header.init_duration);

        var states = status.initializationDurationSeconds;
        Map<String, int> A = {};
        for (var e in (states.info_.byName).entries) {
          var val = states.getField(e.value.tagNumber);
          A["${e.key}"] = val ?? 0;
        }

        var sortedKeys = A.keys.toList();
        sortedKeys.sort((a, b) => Comparable.compare(A[a] ?? 0, A[b] ?? 0));

        for (var k in sortedKeys) {
          var title = R.i18n.map["grpc.DishInitDuration.$k"];
          var hint = R.i18n.map["grpc.DishInitDuration.${k}_hint"];

          b.kv("${title ?? k}", A[k], hint: hint);
        }
        if (b.widgets.length > 1) {
          rows.addAll(b.widgets);
        }
      }

      if (status.connectedRouters.isNotEmpty) {
        var b = KVWidgetBuilder(context, theme);
        b.header(M.header.connected_routers);
        for (var r in status.connectedRouters) {
          b.kv("", "$r");
        }

        if (b.widgets.length > 1) {
          rows.addAll(b


s(Logic.greaterThanOrEqual)),
  '>':    overloadBits((x, y) => x >  y, Bit.wrap_res(Logic.greaterThan)),
  '==':   overloadBits((x, y) => x == y, Bit.wrap_res(Logic.equalBits)),
  '!=':   overloadBits((x, y) => x != y, Bit.wrap_res((x, y) => Logic.not(Logic.equalBits(x, y)))),

  '+':    Logic.sum,
  // half ?

  literal: (i: number | string) => typeof i == 'string' ? i : Logic.constantBits(i)
}

type Action<A> = (a: A) => void
type TemplateStringAction = Action<TemplateString>
type TemplateString = str | TemplateStringsArray

function make_executor(exec: (a: Arg) => void, init_env: Env): TemplateStringAction {
  function make_lookup(binds: Env) {
    const env = {...init_env, ...binds}
    const env_default = env.default
    return (name: string, t: string): ArgFun => {
      if (name in env) {
        if (typeof env[name] == 'function') {
          return env[name] as ArgFun
        } else {
          return () => env[name]
        }
      } else if (env_default) {
        return (...args: Arg[]) => env_default(name, ...args)
      } else {
        throw name
      }
    }
  }

  function exec_stmts(binds: Env, es: jsep.Expression[]) {
    const [e, ...rest] = es
    if (e === undefined) {
      return
    }
    if (e.type === 'BinaryExpression') {
      if (e.operator == ':') {
        const rhs = evaluateExpression<Arg>(e.right, make_lookup(binds))
        if (Array.isArray(rhs) && rhs.every(x => typeof x === 'string')) {
          rhs.forEach(x => {
            exec_stmts({...binds, [(e.left as any).name as string]: x}, rest)
          })
          return
        } else {
          throw new Error(`Right hand side ${e.right.name} of : must be an array of strings but is ${JSON.stringify(rhs)}`)
        }
      }
    }
    const res = evaluateExpression<Arg>(e, make_lookup(binds))
    if (res === false) {
      return
    }
    if (res !== true) {
      exec(res)
    }
    exec_stmts(binds, rest)
  }

  return str => {
    const e = jsep(Array.isArray(str) ? str[0] : str)
    if (e.type == 'Compound') {
      exec_stmts({}, e.body)
    } else {
      exec_stmts({}, [e])
    }
  }
}

function mapObject<K extends string, A, B>(o: Record<K, A>, f: (a: A) => B): Record<K, B> {
  return Object.fromEntries(Object.entries<A>(o).map(([k, v]) => [k, f(v)]))
}

export const init = (bitsize: (name: string) => number, init_env: Env) => {
  console.time('solver')
  const solver = new Logic.Solver()
  console.timeEnd('solver')

  const logic_var = (name0: string, ...args: Arg[]): Bit | Logic.Bits => {
    let name = name0
    if (args.some(arg => typeof arg != 'string')) {
      throw JSON.stringify({name0, args})
    }
    const flat_name = () => name + '_' + args.join('_')
    if (name


2.282 2.97l-.396.031-.049.405c-.722 5.938-8.3 9.703-11.306 9.703-3.005 0-10.584-3.765-11.306-9.703M34.25 50.119l.262.02.139-.08c.039-.023 3.537-2.084 3.665-6.363 3.898 3.662 13.267 4.502 15.521 4.652v1.277l.065.498h.499c.447 0 1.197.127 1.197.979 0 .803-.312 1.178-.983 1.178-.103 0-.175-.01-.186-.012l-.593-.113v.604c0 3.23-4.983 5.736-9.27 5.736-4.517 0-9.666-3.055-9.666-5.736l-.004-.592-.584.1a1.064 1.064 0 01-.194.014c-.683 0-1.001-.375-1.001-1.178.001-.654.381-.984 1.133-.984m-.299-3.961v-1.182c0-3.959 4.18-7.146 10.407-7.146 6.441 0 10.409 3.188 10.409 7.146v1.182c0-3.959-3.968-7.145-10.409-7.145-6.227.001-10.407 3.186-10.407 7.145m3.801 11.467c1.953 1.123 4.415 1.869 6.815 1.869 2.361 0 4.854-.688 6.796-1.834 2.241.725 3.946 1.838 4.47 3.34H33.167c.531-1.525 2.287-2.65 4.585-3.375m-5.235-5.137c.15.211.324.389.53.51a9.753 9.753 0 00-.53 1.24v-1.75M60.983 61H56.86a4.234 4.234 0 00-.69-1.449c.123-.113.219-.219.266-.303 1.027-1.809.456-4.488-.57-6.381.428-.336.732-.896.732-1.766 0-.684-.264-1.154-.653-1.467v-3.799c0-5.451-4.416-9.836-11.586-9.836-6.932 0-11.582 4.385-11.582 9.836v3.748a1.64 1.64 0 00-.26.26V35.002c0-1.479 3.084-2.644 8.078-3.212 2.263 1.484 4.703 2.339 6.405 2.339 1.685 0 4.091-.836 6.333-2.291 4.745.596 7.65 1.794 7.65 2.937V61"/><circle cx="41.5" cy="20.309" r="2.25" fill="currentColor"/><circle cx="52.5" cy="20.309" r="2.25" fill="currentColor"/><path fill="currentColor" d="M50.934 27.657c.188-.346-.063-.719-.34-.504-2.316 1.801-4.887 1.789-7.189 0-.277-.215-.527.158-.34.504.703 1.285 2.121 2.434 3.934 2.434 1.814-.001 3.231-1.149 3.935-2.434"/><circle cx="11.633" cy="20.308" r="2.25" fill="currentColor"/><circle cx="22.369" cy="20.308" r="2.25" fill="currentColor"/><path fill="currentColor" d="M13.066 27.655c.703 1.285 2.121 2.434 3.934 2.434 1.814 0 3.232


	list.clear();
		for (String s : Text.fromCSV(input.toLowerCase()))
		{
			if (s.equals("unknown"))
			{
				list.add("unknown (combat)");
				list.add("unknown (puzzle)");
			}
			else
			{
				list.add(s);
			}
		}
	}

	boolean getRotationMatches()
	{
		RaidRoom[] combatRooms = raid.getCombatRooms();
		String rotation = Arrays.stream(combatRooms)
			.map(RaidRoom::getName)
			.map(String::toLowerCase)
			.collect(Collectors.joining(","));

		return rotationWhitelist.contains(rotation);
	}

	private Point findLobbyBase()
	{
		Tile[][] tiles = client.getScene().getTiles()[LOBBY_PLANE];

		for (int x = 0; x < SCENE_SIZE; x++)
		{
			for (int y = 0; y < SCENE_SIZE; y++)
			{
				if (tiles[x][y] == null || tiles[x][y].getWallObject() == null)
				{
					continue;
				}

				if (tiles[x][y].getWallObject().getId() == ObjectID.BLACK_WALL)
				{
					return tiles[x][y].getSceneLocation();
				}
			}
		}

		return null;
	}

	private Raid buildRaid(Raid from)
	{
		Raid raid = from;

		if (raid == null)
		{
			// The south-west tile of the lobby room in the scene
			Point gridBase = findLobbyBase();

			if (gridBase == null)
			{
				return null;
			}

			Integer lobbyIndex = findLobbyIndex(gridBase);

			if (lobbyIndex == null)
			{
				return null;
			}

			raid = new Raid(
				new WorldPoint(client.getBaseX() + gridBase.getX(), client.getBaseY() + gridBase.getY(), LOBBY_PLANE),
				lobbyIndex
			);
		}

		/*
		 * The x position of the starting room relative to other rooms
		 * The west most room will have a value of 0 and the east most will have a value of 3
		 * The rooms have the following x values
		 *     0 1 2 3
		 *     0 1 2 3
		 */
		int baseX = raid.getLobbyIndex() % AMOUNT_OF_ROOMS_PER_X_AXIS_PER_PLANE;

		/*
		 * The y position of the starting room relative to other rooms
		 * The north rooms will have a y value of 0 and the south will have a value of 1
		 * The rooms have the following y values
		 *     0 0 0 0
		 *     1 1 1 1
 		 */
		int baseY = raid.getLobbyIndex() % ROOMS_PER_PLANE > (AMOUNT_OF_ROOMS_PER_X_AXIS_PER_PLANE - 1) ? 1 : 0;

		/*
		 * i is the position of the room in the raid room array, the raid rooms are in order of north to south,
		 * west to east, and plane 3 to plane 2. For example the 0th room is the north-west room on plane 3 and
		 * the 15th room is the south-east room of plane 2
		 *
		 * The indexes of the rooms of plane 3 (the first/lobby floor) will look like
		 *     0  1  2  3
		 *     4  5  6  7
		 *
		 * The indexes of the rooms of plane 2 (the second floor) will look like
		 *     8  9  10 11
		 *     12 13 14 15
		 */
		for (int i = 0; i < raid.getRooms().length; i++)
		{
			/*
			 * The x position of the current room relative to other rooms
			 * The west most room will have a value of 0 and the east most will have a value of 3
			 * The rooms have the following x values
			 *     0 1 2 3
			 *     0 1 2 3
			 */
			int x = i % AMOUNT_OF_


ven BinaryWriter.
 * @param {!proto.MsgSubmitBlobPayment} message
 * @param {!jspb.BinaryWriter} writer
 * @suppress {unusedLocalVariables} f is only used for nested messages
 */
proto.MsgSubmitBlobPayment.serializeBinaryToWriter = function (message, writer) {
	var f = undefined
	f = message.getSigner()
	if (f.length > 0) {
		writer.writeString(1, f)
	}
	f = message.getNamespacesList_asU8()
	if (f.length > 0) {
		writer.writeRepeatedBytes(2, f)
	}
	f = message.getBlobSizesList()
	if (f.length > 0) {
		writer.writePackedUint32(3, f)
	}
	f = message.getShareCommitmentsList_asU8()
	if (f.length > 0) {
		writer.writeRepeatedBytes(4, f)
	}
	f = message.getShareVersionsList()
	if (f.length > 0) {
		writer.writePackedUint32(8, f)
	}
}

/**
 * optional string signer = 1;
 * @return {string}
 */
proto.MsgSubmitBlobPayment.prototype.getSigner = function () {
	return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""))
}

/**
 * @param {string} value
 * @return {!proto.MsgSubmitBlobPayment} returns this
 */
proto.MsgSubmitBlobPayment.prototype.setSigner = function (value) {
	return jspb.Message.setProto3StringField(this, 1, value)
}

/**
 * repeated bytes namespaces = 2;
 * @return {!Array<string>}
 */
proto.MsgSubmitBlobPayment.prototype.getNamespacesList = function () {
	return /** @type {!Array<string>} */ (jspb.Message.getRepeatedField(this, 2))
}

/**
 * repeated bytes namespaces = 2;
 * This is a type-conversion wrapper around `getNamespacesList()`
 * @return {!Array<string>}
 */
proto.MsgSubmitBlobPayment.prototype.getNamespacesList_asB64 = function () {
	return /** @type {!Array<string>} */ (jspb.Message.bytesListAsB64(this.getNamespacesList()))
}

/**
 * repeated bytes namespaces = 2;
 * Note that Uint8Array is not supported on all browsers.
 * @see http://caniuse.com/Uint8Array
 * This is a type-conversion wrapper around `getNamespacesList()`
 * @return {!Array<!Uint8Array>}
 */
proto.MsgSubmitBlobPayment.prototype.getNamespacesList_asU8 = function () {
	return /** @type {!Array<!Uint8Array>} */ (jspb.Message.bytesListAsU8(this.getNamespacesList()))
}

/**
 * @param {!(Array<!Uint8Array>|Array<string>)} value
 * @return {!proto.MsgSubmitBlobPayment} returns this
 */
proto.MsgSubmitBlobPayment.prototype.setNamespacesList = function (value) {
	return jspb.Message.setField(this, 2, value || [])
}

/**
 * @param {!(string|Uint8Array)} value
 * @param {number=} opt_index
 * @return {!proto.MsgSubmitBlobPayment} returns this
 */
proto.MsgSubmitBlobPayment.prototype.addNamespaces = function (value, opt_index) {
	return jspb.Message.addToRepeatedField(this, 2, value, opt_index)
}

/**
 * Clears the list making it empty but non-null.
 * @return {!proto.MsgSubmitBlobPayment} returns this
 */
proto.MsgSubmitBlobPayment.prototype.clearNamespacesList = function () {
	return this.setNamespacesList([])
}

/**
 * repeated uint32 blob_sizes = 3;
 * @return {!Array<number>}
 */
proto.MsgSubmitBlobPayment.prototype.getBlobSizesList = function () {
	return /** @type {!Array<number>} */ (jspb.Message.getRepeatedField(this, 3))
}

/**
 * @


NLS-1$ //$NON-NLS-2$
        assertFalse(LocaleInvariantStringHelpers.caseInsensitiveEndsWith("oolong", "toolong")); //$NON-NLS-1$ //$NON-NLS-2$
        assertTrue(LocaleInvariantStringHelpers.caseInsensitiveEndsWith("justright", "justright")); //$NON-NLS-1$ //$NON-NLS-2$

        Locale.setDefault(backupLocale);
    }
}
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See License.txt in the repository root.

package com.microsoft.tfs.util.json;

import java.util.concurrent.atomic.AtomicInteger;

import junit.framework.TestCase;

public class JSONEncoderDecodeStringTest extends TestCase {
    public void testDecodeNull() {
        assertEquals(null, JSONEncoder.decodeString(null));
        assertEquals(null, JSONEncoder.decodeString("null")); //$NON-NLS-1$
    }

    public void testDecodeEmpty() {
        assertEquals("", JSONEncoder.decodeString("\"\"")); //$NON-NLS-1$ //$NON-NLS-2$
    }

    public void testDecodeSimple() {
        assertEquals(" abc def ", JSONEncoder.decodeString("\" abc def \"")); //$NON-NLS-1$ //$NON-NLS-2$
    }

    public void testDecodeIgnoreWhitespaceAndTrailingChars() {
        assertEquals(" abc def ", JSONEncoder.decodeString(" \r\n\t \" abc def \" ignore this trailing stuff")); //$NON-NLS-1$ //$NON-NLS-2$
    }

    public void testDecodeLength() {
        final AtomicInteger charsRead = new AtomicInteger(-123);

        assertEquals("abc", JSONEncoder.decodeString("\"abc\" extra characters", charsRead)); //$NON-NLS-1$ //$NON-NLS-2$
        // Should have read 5 chars (start quote, "abc", end quote)
        assertEquals(5, charsRead.get());
    }

    public void testDecodeStandardEscapes() {
        assertEquals("\" \\ / \b \f \n \r \t", JSONEncoder.decodeString("\"\\\" \\\\ \\/ \\b \\f \\n \\r \\t\"")); //$NON-NLS-1$ //$NON-NLS-2$
    }

    public void testDecodeUnicodeEscapes() {
        // Unicode control chars
        assertEquals("\u0000", JSONEncoder.decodeString("\"\\u0000\"")); //$NON-NLS-1$ //$NON-NLS-2$
        assertEquals("\u001f", JSONEncoder.decodeString("\"\\u001F\"")); //$NON-NLS-1$ //$NON-NLS-2$
        assertEquals("\u007f", JSONEncoder.decodeString("\"\\u007F\"")); //$NON-NLS-1$ //$NON-NLS-2$
        assertEquals("\u009f", JSONEncoder.decodeString("\"\\u009F\"")); //$NON-NLS-1$ //$NON-NLS-2$

        // Non-control chars
        assertEquals("\u0020", JSONEncoder.decodeString("\"\\u0020\"")); //$NON-NLS-1$ //$NON-NLS-2$
        assertEquals("\u007e", JSONEncoder.decodeString("\"\\u007E\"")); //$NON-NLS-1$ //$NON-NLS-2$
        assertEquals("\u00a0", JSONEncoder.decodeString("\"\\u00A0\"")); //$NON-NLS-1$ //$NON-NLS-2$

        // Decode accepts upper and lower case hex
        assertEquals("\uffff", JSONEncoder.decodeString("\"\\uFfFf\"")); //$NON-NLS-1$ //$NON-NLS-2$

        // Some of the input code points are escaped, some are not
        assertEquals(
            "\u0000 \u1234 \uffff \u1234\u5678", //$NON-NLS-1$
            JSONEncoder.decodeString("\"\\u0000 \\u1234 \uffff \\u1234\\u5678\"")); //$NON-NLS-1$
    }

    public void testDecodeSurrogate() {
        // See http://en.wikipedia.org/wiki/UTF-16

        // String has two chars but just one code point: 0xD800 + 0xDC01 Decodes
        // 0x10001 (65537)
        final String withSurrog


++) {
            if (posten[i].art == "Lieferung") {
                var radioB2: HTMLInputElement = document.createElement("input");
                radioB2.type = "radio";
                radioB2.name = "Lieferoptionen";
                radioB2.value = posten[i].name;
                radioB2.id = "radio2." + i;
                lieferopt.appendChild(radioB2);

                //Labels hinzufügen
                var label3: HTMLLabelElement = document.createElement("label");
                label3.id = "label3." + i;
                label3.htmlFor = radioB2.id;
                label3.innerText = posten[i].name;
                lieferopt.appendChild(label3);
            }
        }

        //Button generieren

        let button: HTMLDivElement = <HTMLDivElement>document.getElementById("button");
        let submit: HTMLButtonElement = document.createElement("button");

        submit.type = "submit";
        submit.innerText = "Bestellung überprüfen";
        submit.addEventListener("mousedown", handleMouseDown);
        button.appendChild(submit);
    }

    //Warenkorbfunktion

    function warenkorb(_event: Event): void {
        let target: HTMLInputElement = <HTMLInputElement>_event.target; //Target zwischenspeichern,  casten, um auf die Properties zugreifen zu können
        let stepper: HTMLInputElement[] = []; //Stepper-Elemente zwischenspeichern
        let checkBoxes: HTMLInputElement[] = []; //Checkbox-Elemente zwischenspeichern
        let gesamtpreis: number = 0;

        //Auswahl überprüfen

        for (let i: number = 0; i < posten.length; i++) {
            console.log(_event.target);
            if (posten[i].art == "Schmuck") { //Wenn die Art Schmuck ist, werden Stepper und Checkbox Elemente in Arrays zwischengespeichert ( benötigt, um abzufragen ob Checkbox gecheckt ist)
                stepper[i] = <HTMLInputElement>document.getElementById("stepper" + i);
                checkBoxes[i] = <HTMLInputElement>document.getElementById("check" + i);
            }
            if (target.value == posten[i].name && target.id == "selectBaumart") { //Wenn der Name und die Id vom geänderten Element selectBaumart ist,
                basketBaumart[0] = posten[i].name;  //...wird der Name vom Posten an der Stelle i im Array basketBaumart an erster Stelle gespeichert
                basketBaumart[1] = "" + posten[i].preis; //...wird der Preis vom Posten an der Stelle i im Array an zweiter Stelle gespeichert
            }
            if (target.id == "radio" + i) {
                basketHalter[0] = posten[i].name;
                basketHalter[1] = "" + posten[i].preis;

            }
            if (target.id == "radio2." + i) {
                basketLieferopt[0] = posten[i].name;
                basketLieferopt[1] = "" + posten[i].preis;

            }
            if (target.value == posten[i].name && target.id == "selectBeleuchtung") {
                basketBeleuchtung[0] = posten[i].name;
                basketBeleuchtung[1] = "" + posten[i].preis;

            }
            if (target.id == "check" + i || target.id == "stepper" + i) { //Wenn sich was an den Elementen mit Id check oder stepper geändert hat,
                basketSchmuck[i] = [posten[i].name, "" + (posten[i].preis * parseInt(stepper[i].value))]; //...dann wird der Name des entsprechenden Posten und der Preis


criptors.FileDescriptor
      getDescriptor() {
    return descriptor;
  }
  private static  com.google.protobuf.Descriptors.FileDescriptor
      descriptor;
  static {
    java.lang.String[] descriptorData = {
      "\n\034AbilityInvokeEntryHead.proto\"\325\001\n\026Abili" +
      "tyInvokeEntryHead\022\034\n\024instanced_ability_i" +
      "d\030\005 \001(\r\022 \n\030modifier_config_local_id\030\004 \001(" +
      "\005\022\020\n\010local_id\030\t \001(\005\022\027\n\017server_buff_uid\030\007" +
      " \001(\r\022\035\n\025instanced_modifier_id\030\013 \001(\r\022\036\n\026i" +
      "s_serverbuff_modifier\030\014 \001(\010\022\021\n\ttarget_id" +
      "\030\010 \001(\rB\033\n\031emu.grasscutter.net.protob\006pro" +
      "to3"
    };
    descriptor = com.google.protobuf.Descriptors.FileDescriptor
      .internalBuildGeneratedFileFrom(descriptorData,
        new com.google.protobuf.Descriptors.FileDescriptor[] {
        });
    internal_static_AbilityInvokeEntryHead_descriptor =
      getDescriptor().getMessageTypes().get(0);
    internal_static_AbilityInvokeEntryHead_fieldAccessorTable = new
      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
        internal_static_AbilityInvokeEntryHead_descriptor,
        new java.lang.String[] { "InstancedAbilityId", "ModifierConfigLocalId", "LocalId", "ServerBuffUid", "InstancedModifierId", "IsServerbuffModifier", "TargetId", });
  }

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

package emu.grasscutter.net.proto;

public final class StartRogueDiaryRoomReqOuterClass {
  private StartRogueDiaryRoomReqOuterClass() {}
  public static void registerAllExtensions(
      com.google.protobuf.ExtensionRegistryLite registry) {
  }

  public static void registerAllExtensions(
      com.google.protobuf.ExtensionRegistry registry) {
    registerAllExtensions(
        (com.google.protobuf.ExtensionRegistryLite) registry);
  }
  public interface StartRogueDiaryRoomReqOrBuilder extends
      // @@protoc_insertion_point(interface_extends:StartRogueDiaryRoomReq)
      com.google.protobuf.MessageOrBuilder {

    /**
     * bool is_select_hard = 9;
     * @return The isSelectHard.
     */
    boolean getIsSelectHard();

    /**
     * uint32 room_difficulty = 13;
     * @return The roomDifficulty.
     */
    int getRoomDifficulty();
  }
  /**
   *

   * CmdId: 20500
   * Obf: DDOPBPBNBDM
   *

   *
   * Protobuf type {@code StartRogueDiaryRoomReq}
   */
  public static final class StartRogueDiaryRoomReq extends
      com.google.protobuf.GeneratedMessageV3 implements
      // @@protoc_insertion_point(message_implements:StartRogueDiaryRoomReq)
      StartRogueDiaryRoomReqOrBuilder {
  private static final long serialVersionUID = 0L;
    // Use StartRogueDiaryRoomReq.newBuilder() to construct.
    private StartRogueDiaryRoomReq(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
      super(builder);
    }
    private StartRogueDiaryRoomReq() {
    }

    @java.lang.Override
    @SuppressWarnings({"unused"})
    protected java.lang.Object newInstance(
        UnusedPrivateParameter unused) {
      return new StartRogueDiaryRoomReq();
    }

    @java.lang.Override
    public final com.google.protobuf.UnknownFieldSet
    getUnknownFields() {
      return this.unknownFields;


 any[]) => any) {
    this._emitter.off(event, handler);
  }

  protected _detect() {
    this.stop();
    const startTime = Date.now();
    this._emitter.emit(this.events.heartbeat, startTime);
    this._timeoutId = global.setTimeout(() => {
      const endTime = Date.now();
      const sleepTime = endTime - startTime - this._detectionInterval;
      if (sleepTime > this._detectionThreshold) {
        console.log('==== Sleep Detected =====');
        this._emitter.emit(this.events.detected, startTime, endTime, sleepTime);
      }
      this._timeoutId = null;
      this._detect();
    }, this._detectionInterval);
  }

  start() {
    this._detect();
  }

  stop() {
    if (this._timeoutId) {
      global.clearTimeout(this._timeoutId);
      this._timeoutId = null;
    }
  }
}
import { coords2pos } from "../";

export function boardPositions(height: number, width: number) {
  let ret = [];
  for (let y = 1; y <= height; y++) {
    for (let x = 1; x <= width; x++) {
      ret.push(coords2pos({ x: x, y: y }));
    }
  }
  return ret.sort();
}
import { appendTrips } from '../util';

it('adds up distance and time traveled if multiple drivers are in the report', () => {
  const data = [
    { name: 'Dan', distance: 17.3, timeTraveled: 30, speed: 34.6 },
    { name: 'Dan', distance: 21.8, timeTraveled: 20, speed: 65.4 },
    { name: 'Lauren', distance: 42, timeTraveled: 75, speed: 33.6 },
  ];

  const totalDistance = data[0].distance + data[1].distance;
  const totalTimeTraveled = data[0].timeTraveled + data[1].timeTraveled;

  const trips = appendTrips(data);
  expect(trips[0].name).toEqual('Dan');
  expect(trips[0].distance).toEqual(totalDistance);
  expect(trips[0].timeTraveled).toEqual(totalTimeTraveled);
});
import { Controller, Get, Post, UsePipes, ValidationPipe, Body, Patch, Param } from '@nestjs/common';
import { MedicalEquipmentService } from './medical-equipment.service';
import { MedicalEquipmentDTO } from './dto/medicalEquimentDTO';
import { ApiOperation, ApiResponse, ApiBody, ApiParam, ApiNotFoundResponse, ApiTags } from '@nestjs/swagger';
import { MedicalUpdateEquipmentDTO } from './dto/medicalUpdateDTO';

@Controller('medical-equipment')
@ApiTags('Equipment')
export class MedicalEquipmentController {
    /**
     * First method in the page
     * @param equipmentService controller for the equipment service
     */
    constructor(private equipmentService: MedicalEquipmentService){}
    /**
     * Get all the patients
     */
    @Get()
    @ApiOperation({ summary: 'Obtener la información de los equipos medicos' })
    @ApiResponse({ status: 200, type: [MedicalEquipmentDTO] })
    getPatients(){
        return this.equipmentService.getAllEquipments()
    }
    /**
     * Create a new patient
     * @param data data of the new patient
     */
    @Post()
    @ApiBody({ required: true, type: MedicalEquipmentDTO })
    @ApiOperation({ summary: 'Permite agregar un nuevo equipo medico a la base de datos.' })
    @ApiResponse({ status: 201, type: MedicalEquipmentDTO })
    @UsePipes(ValidationPipe)
    createPatient(@Body() data: MedicalEquipmentDTO){
        this.equipmentService.createEquipment(data);
    }
    /**
     * Update the data of the patient
     * @param PatientDni Dni of the patient
     * @param data of the patient
     */
    @Patch('/:id')
    @ApiBody({ required: true, type: MedicalUpdateEqu


_t> i(inf);
        assert(*i == L'a');
        assert(*++i == L'b');
        assert(*++i == L'c');
        assert(++i == std::istreambuf_iterator<wchar_t>());
    }
}
//===----------------------------------------------------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

// <iterator>

// template <InputIterator Iter>
//   void advance(Iter& i, Iter::difference_type n);
//
// template <BidirectionalIterator Iter>
//   void advance(Iter& i, Iter::difference_type n);
//
// template <RandomAccessIterator Iter>
//   void advance(Iter& i, Iter::difference_type n);

#include <iterator>
#include <cassert>

#include "../../iterators.h"

template <class It>
void
test(It i, typename std::iterator_traits<It>::difference_type n, It x)
{
    std::advance(i, n);
    assert(i == x);
}

int main()
{
    const char* s = "1234567890";
    test(input_iterator<const char*>(s), 10, input_iterator<const char*>(s+10));
    test(forward_iterator<const char*>(s), 10, forward_iterator<const char*>(s+10));
    test(bidirectional_iterator<const char*>(s+5), 5, bidirectional_iterator<const char*>(s+10));
    test(bidirectional_iterator<const char*>(s+5), -5, bidirectional_iterator<const char*>(s));
    test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
    test(random_access_iterator<const char*>(s+5), -5, random_access_iterator<const char*>(s));
    test(s+5, 5, s+10);
    test(s+5, -5, s);
}
//===----------------------------------------------------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

// <iterator>

// front_insert_iterator

// Test nested types and data member:

// template <class Container>
// class front_insert_iterator {
// protected:
//   Container* container;
// public:
//   typedef Container                   container_type;
//   typedef void                        value_type;
//   typedef void                        difference_type;
//   typedef front_insert_iterator<Cont>& reference;
//   typedef void                        pointer;
//   typedef output_iterator_tag         iterator_category;
// };

#include <iterator>
#include <type_traits>
#include <vector>

template <class C>
struct find_container
    : private std::front_insert_iterator<C>
{
    explicit find_container(C& c) : std::front_insert_iterator<C>(c) {}
    void test() {this->container = 0;}
};

template <class C>
void
test()
{
    typedef std::front_insert_iterator<C> R;
    C c;
    find_container<C> q(c);
    q.test();
    static_assert((std::is_same<typename R::container_type, C>::value), "");
    static_assert((std::is_same<typename R::value_type, void>::value), "");
    static_assert((std::is_same<typename R::difference_type, void>::value), "");
    static_assert((std::is_same<typename R::reference, R&>::value), "");
    static_assert((std::is_same<typename R::pointer, void>::value), "");
    static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");


.441.161h7.343c.366 0 .717-.147.976-.41a1.41 1.41 0 0 0 .404-.99V8.728c0-.713-.53-1.312-1.228-1.39z' id='b'/%3E%3Cfilter x='-32.7%25' y='-25%25' width='167.3%25' height='164.3%25' filterUnits='objectBoundingBox' id='a'%3E%3CfeMorphology radius='1' operator='dilate' in='SourceAlpha' result='shadowSpreadOuter1'/%3E%3CfeOffset dy='1' in='shadowSpreadOuter1' result='shadowOffsetOuter1'/%3E%3CfeGaussianBlur stdDeviation='1' in='shadowOffsetOuter1' result='shadowBlurOuter1'/%3E%3CfeComposite in='shadowBlurOuter1' in2='SourceAlpha' operator='out' result='shadowBlurOuter1'/%3E%3CfeColorMatrix values='0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.3 0' in='shadowBlurOuter1'/%3E%3C/filter%3E%3C/defs%3E%3Cg fill='none' fill-rule='evenodd'%3E%3Cg transform='rotate(-22 6.851 8.641)' fill='%23000' fill-rule='nonzero'%3E%3Cuse filter='url(%23a)' xlink:href='%23b'/%3E%3Cpath stroke='%23FFF' d='M5.407.675c.52 0 .991.213 1.332.56.338.342.548.816.548 1.34v3.753l4.54.512a1.87 1.87 0 0 1 1.195.624c.297.337.477.781.477 1.264v5.047c0 .503-.198.986-.548 1.341a1.87 1.87 0 0 1-1.332.56H4.102l-4.349-3.449c-.06-1.896.354-2.26.771-2.472l.104-.05a1.862 1.862 0 0 1 1.494-.042l1.405.57V2.575c0-.524.21-.998.548-1.34.34-.347.812-.56 1.332-.56z' fill-rule='evenodd'/%3E%3C/g%3E%3Cpath fill='none' d='M16 0h2v20h-2z'/%3E%3C/g%3E%3C/svg%3E"),auto;--cur-copy-lg:url("data:image/svg+xml,%3Csvg width='36' height='20' viewBox='0 0 36 20' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'%3E%3Cdefs%3E%3Cfilter x='-19.4%25' y='-15.6%25' width='138.9%25' height='143.8%25' filterUnits='objectBoundingBox' id='a'%3E%3CfeOffset dy='1' in='SourceAlpha' result='shadowOffsetOuter1'/%3E%3CfeGaussianBlur stdDeviation='1' in='shadowOffsetOuter1' result='shadowBlurOuter1'/%3E%3CfeColorMatrix values='0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.3 0' in='shadowBlurOuter1' result='shadowMatrixOuter1'/%3E%3CfeMerge%3E%3CfeMergeNode in='shadowMatrixOuter1'/%3E%3CfeMergeNode in='SourceGraphic'/%3E%3C/feMerge%3E%3C/filter%3E%3Cpath d


"""
Models module for data management
"""


   driver_excs = self.EXTRA_EXC_CLS
        try:
            result = self._list_table_names_i(db_name=db_name, show_dot=show_dot)
            for item in result:
                yield item
        except driver_excs as err:
            raise exc.DatabaseQueryError(db_message=str(err), query="list_directory()") from None

    def _get_tables(self, schema_ident: SchemaIdent, page_ident: PageIdent | None = None) -> list[TableIdent]:
        db_name = schema_ident.db_name
        assert db_name is not None
        return [
            TableIdent(
                schema_name=None,
                db_name=db_name,
                table_name=name,
            )
            for name in self._list_table_names(db_name)
        ]

class YDBAdapter(YDBAdapterBase[YDBConnTargetDTO]):
    pass


cd /workspace

conda create -n pixart python==3.9.0
conda activate pixart
pip install torch==2.0.0+cu117 torchvision==0.15.1+cu117 torchaudio==2.0.1 --index-url https://download.pytorch.org/whl/cu117

git clone https://github.com/PixArt-alpha/PixArt-alpha.git
cd PixArt-alpha
pip install -r requirements.txt
```

### 2. Install ComfyUI related dependencies

```bash
cd /workspace
git clone https://github.com/comfyanonymous/ComfyUI.git

cd ComfyUI
git clone https://github.com/city96/ComfyUI_ExtraModels custom_nodes/ComfyUI_ExtraModels
```

### 3. Download all the checkpoints: PixArt, VAE, T5 with script

```bash
cd /workspace/PixArt
python tools/download.py --model_names "PixArt-XL-2-1024-MS.pth"
```
or download with urls:[PixArt ckpt](https://huggingface.co/PixArt-alpha/PixArt-alpha/resolve/main/PixArt-XL-2-1024-MS.pth), [VAE ckpt](https://huggingface.co/PixArt-alpha/PixArt-alpha/tree/main/sd-vae-ft-ema),
[T5 ckpt](https://huggingface.co/PixArt-alpha/PixArt-alpha/tree/main/t5-v1_1-xxl).

### 4. Put Checkpoints into corresponding folders
```bash
cd /workspace/ComfyUI

mv /path/to/PixArt-XL-2-1024-MS.pth ./models/checkpoints/
mv /path/to/sd-vae-ft-ema ./models/VAE/
mv /path/to/t5-v1_1-xxl ./models/t5/
```
### 5. run the ComfyUI website
```bash
cd /workspace/ComfyUI

python main.py --port 11111 --listen 0.0.0.0
```
Open http://your-server-ip:11111 to play with PixArt.

### 6. Create your own custom nodes
Here we prepare two examples for better understanding:

1) [PixArt Text-to-Image workflow](https://huggingface.co/PixArt-alpha/PixArt-alpha/blob/main/PixArt-image-to-image-workflow.json)

2) [PixArt Image-to-Image workflow](https://huggingface.co/PixArt-alpha/PixArt-alpha/blob/main/PixArt-image-to-image-workflow.json)

Once you download these json files, you can open your server website which is `http://your-server-ip:11111` and drop the json file into the website window to begin the PixArt-ComfyUI playground.## SA-Solver: Stochastic Adams Solver for Fast Sampling of Diffusion Models (Neurips 2023)

> [**SA-Solver: Stochastic Adams Solver for Fast Sampling of Diffusion Models (Neurips 2023)**](https://arxiv.org/pdf/2309.05019.pdf)

> [Shuchen Xue*](https://github.com/scxue), [Mingyang Yi]()†,
> [Weijian Luo](), [Shifeng Zhang](), [Jiacheng Sun](),
> [Zhenguo Li](https://scholar.google.com/citations?user=XboZC1AAAAAJ),
> [Zhi-Ming Ma]()
>
University of Chinese Academy of Sciences, Huawei Noah’s Ark Lab, Peking University

---

## 🐱 Abstract
SA-Solver is a stochastic diffusion sampler based on Stochastic Adams Method. It is training-free and can be employed into pretrained diffusio


Rx descriptor used in chain list data structure */
#define ARMDFEC_RXQ_DESC_ALIGNED_SIZE \
	(((sizeof(struct rx_desc) / PKTALIGN) + 1) * PKTALIGN)

#define RX_BUF_OFFSET		0x2
#define RXQ			0x0	/* RX Queue 0 */
#define TXQ			0x1	/* TX Queue 1 */

struct addr_table_entry_t {
	u32 lo;
	u32 hi;
};

/* Bit fields of a Hash Table Entry */
enum hash_table_entry {
	HTEVALID = 1,
	HTESKIP = 2,
	HTERD = 4,
	HTERDBIT = 2
};

struct tx_desc {
	u32 cmd_sts;		/* Command/status field */
	u16 reserved;
	u16 byte_cnt;		/* buffer byte count */
	u8 *buf_ptr;		/* pointer to buffer for this descriptor */
	struct tx_desc *nextdesc_p;	/* Pointer to next descriptor */
};

struct rx_desc {
	u32 cmd_sts;		/* Descriptor command status */
	u16 byte_cnt;		/* Descriptor buffer byte count */
	u16 buf_size;		/* Buffer size */
	u8 *buf_ptr;		/* Descriptor buffer pointer */
	struct rx_desc *nxtdesc_p;	/* Next descriptor pointer */
};

/*
 * Armada100 Fast Ethernet controller Registers
 * Refer Datasheet Appendix A.22
 */
struct armdfec_reg {
	u32 phyadr;			/* PHY Address */
	u32 pad1[3];
	u32 smi;			/* SMI */
	u32 pad2[0xFB];
	u32 pconf;			/* Port configuration */
	u32 pad3;
	u32 pconf_ext;			/* Port configuration extend */
	u32 pad4;
	u32 pcmd;			/* Port Command */
	u32 pad5;
	u32 pstatus;			/* Port Status */
	u32 pad6;
	u32 spar;			/* Serial Parameters */
	u32 pad7;
	u32 htpr;			/* Hash table pointer */
	u32 pad8;
	u32 fcsal;			/* Flow control source address low */
	u32 pad9;
	u32 fcsah;			/* Flow control source address high */
	u32 pad10;
	u32 sdma_conf;			/* SDMA configuration */
	u32 pad11;
	u32 sdma_cmd;			/* SDMA command */
	u32 pad12;
	u32 ic;				/* Interrupt cause */
	u32 iwc;			/* Interrupt write to clear */
	u32 im;				/* Interrupt mask */
	u32 pad13;
	u32 *eth_idscpp[4];		/* Eth0 IP Differentiated Services Code
					   Point to Priority 0 Low */
	u32 eth_vlan_p;			/* Eth0 VLAN Priority Tag to Priority */
	u32 pad14[3];
	struct rx_desc *rxfdp[4];	/* Ethernet First Rx Descriptor
					   Pointer */
	u32 pad15[4];
	struct rx_desc *rxcdp[4];	/* Ethernet Current Rx Descriptor
					   Pointer */
	u32 pad16[0x0C];
	struct tx_desc *txcdp[2];	/* Ethernet Current Tx Descriptor
					   Pointer */
};

struct armdfec_device {
	struct eth_device dev;
	struct armdfec_reg *regs;
	struct tx_desc *p_txdesc;
	struct rx_desc *p_rxdesc;
	struct rx_desc *p_rxdesc_curr;
	u8 *p_rxbuf;
	u8 *p_aligned_txbuf;
	u8 *htpr;		/* hash pointer */
};

#endif /* __ARMADA100_FEC_H__ */


    ldm r1!, {r6}
/*0x0816*/      str r6, [r3, #4]
/*0x0818*/      str r5, [r3, #0x10]
/*0x081a*/      .short 0x1d00 /* adds r0, r0, #4 */
            jump_81c:
/*0x081c*/      .short 0x1e52 /* subs r2, r2, #1 */
/*0x081e*/      bhs jump_810
/*0x0820*/      pop {r4, r5, r6, pc}

/*0x0822*/  .byte 0x00
/*0x0823*/  .byte 0x00

            data_824:
/*0x0824*/  .word 0x40080000

            .thumb_func
            call_828:
/*0x0828*/      push.w {r4, r5, r6, r7, r8, lr}
/*0x082c*/      ldr r5, [pc, #0x1c4] /* data_9f4 */
/*0x082e*/      ldrb r0, [r5]
/*0x0830*/      cmp r0, #1
/*0x0832*/      bne jump_916
/*0x0834*/      ldr r6, [pc, #0x1c0] /* data_9f8 */
/*0x0836*/      movs r4, #0
/*0x0838*/      mov r0, r6
/*0x083a*/      ldrb r1, [r6]
/*0x083c*/      ldrb r0, [r0, #1]
/*0x083e*/      mov ip, r4
/*0x0840*/      cmp r1, #0x10
/*0x0842*/      beq jump_864
/*0x0844*/      mov r2, r6
/*0x0846*/      mov.w lr, #0xcc00
/*0x084a*/      ldr r3, [r2, #4]
/*0x084c*/      mov.w r2, #0x3400
/*0x0850*/      add.w r7, r3, #0x3000
/*0x0854*/      cmp r1, #0x1d
/*0x0856*/      beq jump_8e8
/*0x0858*/      bgt jump_86e
/*0x085a*/      cmp r1, #0x11
/*0x085c*/      beq jump_878
/*0x085e*/      cmp r1, #0x12
/*0x0860*/      bne jump_944
/*0x0862*/      b jump_87e
            jump_864:
/*0x0864*/      cmp r0, #2
/*0x0866*/      bne jump_944
/*0x0868*/      str.w ip, [r6, #4]
/*0x086c*/      b jump_97a
            jump_86e:
/*0x086e*/      cmp r1, #0x1e
/*0x0870*/      beq jump_964
/*0x0872*/      cmp r1, #0x1f
/*0x0874*/      bne jump_944
/*0x0876*/      b jump_99c
            jump_878:
/*0x0878*/      bl call_a00
/*0x087c*/      b jump_984
            jump_87e:
/*0x087e*/      mov.w r3, #0x400
/*0x0882*/      cmp r0, #0x20
/*0x0884*/      blo jump_8a4
/*0x0886*/      sub.w r1, r0, #0x1f
/*0x088a*/      rsb r1, r1, r1, lsl #4
/*0x088e*/      cmp.w r3, r1, lsl #2
/*0x0892*/      blt jump_8a4
/*0x0894*/      rsb r0, r0, r0, l


ge<isize>>, isize, Range<isize>) -> Range<isize>,
	C,
> {
	lines: L,
	segments: S,
	color: C,
	_phantom: PhantomData<P>,
}

impl<
		P: PixelFormat,
		L: Fn(Option<Range<isize>>) -> Range<isize>,
		S: Fn(Option<Range<isize>>, isize, Range<isize>) -> Range<isize>,
		C,
	> ColorClip<P, L, S, C>
{
	/// Creates a new [`ColorMask`] instance.
	pub fn new(lines: L, segments: S, color: C) -> Self {
		Self {
			lines,
			segments,
			color,
			_phantom: PhantomData,
		}
	}
}

impl<
		L: Fn(Option<Range<isize>>) -> Range<isize>,
		S: Fn(Option<Range<isize>>, isize, Range<isize>) -> Range<isize>,
	> Sprite<RgbaNoPadding<8>> for ColorClip<RgbaNoPadding<8>, L, S, [u8; 4]>
{
	fn lines(&self, all_lines_range: Option<Range<isize>>) -> Range<isize> {
		(self.lines)(all_lines_range)
	}

	fn line_segment(
		&self,
		all_lines_range: Option<Range<isize>>,
		line: isize,
		line_span: Range<isize>,
	) -> Range<isize> {
		(self.segments)(all_lines_range, line, line_span)
	}

	fn render(
		&self,
		_all_lines_range: Option<Range<isize>>,
		_line: isize,
		_line_span: Range<isize>,
		_segment: Range<isize>,
		offset_bits: usize,
		data: &mut [u8],
	) {
		assert_eq!(offset_bits, 0);

		for dest in data.chunks_exact_mut(4) {
			let dest_alpha = dest[3];

			for (src, dest) in self.color.iter().zip(dest) {
				*dest = (*dest).saturating_add(
					((*src).conv::<u16>() * (u8::MAX - dest_alpha).conv::<u16>()
						/ u8::MAX.conv::<u16>())
					.try_conv::<u8>()
					.expect("infallible"),
				);
			}
		}
	}
}

impl<
		L: Fn(Option<Range<isize>>) -> Range<isize>,
		S: Fn(Option<Range<isize>>, isize, Range<isize>) -> Range<isize>,
	> Effect<RgbaNoPadding<8>> for ColorClip<RgbaNoPadding<8>, L, S, [u8; 4]>
{
	fn lines(&self, all_lines_range: Option<Range<isize>>) -> Range<isize> {
		(self.lines)(all_lines_range)
	}

	fn line_segment(
		&self,
		all_lines_range: Option<Range<isize>>,
		line: isize,
		line_span: Range<isize>,
	) -> Range<isize> {
		(self.segments)(all_lines_range, line, line_span)
	}

	fn render(
		&self,
		_all_lines_range: Option<Range<isize>>,
		_line: isize,
		_line_span: Range<isize>,
		_segment: Range<isize>,
		offset_bits: usize,
		data: &mut [u8],
	) {
		assert_eq!(offset_bits, 0);

		for dest in data.chunks_exact_mut(4) {
			let src_alpha = self.color[3];

			for (src, dest) in self.color.iter().zip(dest) {
				*dest = src.saturating_add(
					((*dest).conv::<u16>() * (u8::MAX - src_alpha).conv::<u16>()
						/ u8::MAX.conv::<u16>())
					.try_conv::<u8>()
					.expect("infallible"),
				);
			}
		}
	}
}
<reponame>MaterializeInc/rust-protobuf


;
use Illuminate\Support\Facades\Schema;

Schema::table('users', function (Blueprint $table) {
    $table->integer('votes');
});
```

### 사용 가능한 컬럼 타입 (Available Column Types)

스키마 빌더의 `Blueprint` 클래스는 다양한 컬럼 타입에 해당하는 메서드를 제공합니다. 주요 컬럼 메서드는 다음과 같습니다:

[bigIncrements](#column-method-bigIncrements)
[bigInteger](#column-method-bigInteger)
[binary](#column-method-binary)
[boolean](#column-method-boolean)
[char](#column-method-char)
[dateTimeTz](#column-method-dateTimeTz)
[dateTime](#column-method-dateTime)
[date](#column-method-date)
[decimal](#column-method-decimal)
[double](#column-method-double)
[enum](#column-method-enum)
[float](#column-method-float)
[foreignId](#column-method-foreignId)
[foreignIdFor](#column-method-foreignIdFor)
[foreignUuid](#column-method-foreignUuid)
[geometryCollection](#column-method-geometryCollection)
[geometry](#column-method-geometry)
[id](#column-method-id)
[increments](#column-method-increments)
[integer](#column-method-integer)
[ipAddress](#column-method-ipAddress)
[json](#column-method-json)
[jsonb](#column-method-jsonb)
[lineString](#column-method-lineString)
[longText](#column-method-longText)
[macAddress](#column-method-macAddress)
[mediumIncrements](#column-method-mediumIncrements)
[mediumInteger](#column-method-mediumInteger)
[mediumText](#column-method-mediumText)
[morphs](#column-method-morphs)
[multiLineString](#column-method-multiLineString)
[multiPoint](#column-method-multiPoint)
[multiPolygon](#column-method-multiPolygon)
[nullableMorphs](#column-method-nullableMorphs)
[nullableTimestamps](#column-method-nullableTimestamps)
[nullableUuidMorphs](#column-method-nullableUuidMorphs)
[point](#


\\n        \",\n        \"\\n        \",\n        \"\\n        \",\n        \"\\n        \",\n        \"\\n        \",\n        \"\\n        \",\n        \"\\n        \\n        \",\n        \"\\n        \",\n        \"\\n        \",\n        \"\\n        \",\n        \"\\n        \",\n        \"\\n      \"\n    ]);\n    _templateObject = function() {\n        return data;\n    };\n    return data;\n}\nfunction ComponentStyles() {\n    return /*#__PURE__*/ _react.createElement(\"style\", null, (0, _nooptemplate.noop)(_templateObject(), _styles2.styles, _Toast.styles, _Dialog.styles, _styles1.styles, _styles.styles, _styles3.styles, _BuildError.styles, _RootLayoutError.styles, _Errors.styles, _RuntimeError.styles, _VersionStalenessInfo.styles));\n}\nif ((typeof exports.default === \"function\" || typeof exports.default === \"object\" && exports.default !== null) && typeof exports.default.__esModule === \"undefined\") {\n    Object.defineProperty(exports.default, \"__esModule\", {\n        value: true\n    });\n    Object.assign(exports.default, exports);\n    module.exports = exports.default;\n} //# sourceMappingURL=ComponentStyles.js.map\n//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiKHNzcikvLi9ub2RlX21vZHVsZXMvbmV4dC9kaXN0L2NsaWVudC9jb21wb25lbnRzL3JlYWN0LWRldi1vdmVybGF5L2ludGVybmFsL3N0eWxlcy9Db21wb25lbnRTdHlsZXMuanMiLCJtYXBwaW5ncyI6IkFBQWE7QUFDYkEsOENBQTZDO0lBQ3pDRyxPQUFPO0FBQ1gsQ0FBQyxFQUFDO0FBQ0ZILG1EQUFrRDtJQUM5Q0ksWUFBWTtJQUNaQyxLQUFLO1FBQ0QsT0FBT0M7SUFDWDtBQUNKLENBQUMsRUFBQztBQUNGLE1BQU1DLDRCQUE0QkMsbUJBQU9BLENBQUMsb0hBQTBDO0FBQ3BGLE1BQU1DLGlDQUFpQ0QsbUJBQU9BLENBQUMsOEhBQStDO0FBQzlGLE1BQU1FLFNBQVMsV0FBVyxHQUFHSCwwQkFBMEJJLENBQUMsQ0FBQ0gsbUJBQU9BLENBQUMsd0dBQU87QUFDeEUsTUFBTUksVUFBVUosbUJBQU9BLENBQUMsa0pBQ