158.cn/tags-t-p657dfa69a65ca.html" target="_blank" style="color:#2838a9">图片来源网络，侵删）

是不是所有小狗都要打疫苗？

是不是所有小狗都要打疫苗？

养小狗一定要打疫苗。 疫苗是指为了预防、控制传染病的发生、流行，用于人或动物预先接种的生物制品。

它是用微生物或其毒素、酶，人或动物的血清、细胞等制作的供预防、诊断和治疗用的制剂。

给狗狗接种的目的是预防狗狗某些危险又致命的传染病。

 断奶后的幼狗狗身体抗病能力差，外界细菌、病毒、真菌等病原微生物易侵入她们体内，健康受到极大威胁，有的疾病还会传染给。 人类。因此，做好预防<a href="http://www.to3158.cn/tags-g-z.html" target="_blank" clas


 ContractInfoByPoolIdResponse struct {
	// contract_address is the pool address and contract address
	// of the requested pool id.
	ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty" yaml:"contract_address"`
	// code_id is the code id of the requested pool id.
	CodeId uint64 `protobuf:"varint,2,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty" yaml:"code_id"`
}

func (m *ContractInfoByPoolIdResponse) Reset()         { *m = ContractInfoByPoolIdResponse{} }
func (m *ContractInfoByPoolIdResponse) String() string { return proto.CompactTextString(m) }
func (*ContractInfoByPoolIdResponse) ProtoMessage()    {}
func (*ContractInfoByPoolIdResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_733c758985c393b2, []int{5}
}
func (m *ContractInfoByPoolIdResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ContractInfoByPoolIdResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ContractInfoByPoolIdResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ContractInfoByPoolIdResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContractInfoByPoolIdResponse.Merge(m, src)
}
func (m *ContractInfoByPoolIdResponse) XXX_Size() int {
	return m.Size()
}
func (m *ContractInfoByPoolIdResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ContractInfoByPoolIdResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ContractInfoByPoolIdResponse proto.InternalMessageInfo

func (m *ContractInfoByPoolIdResponse) GetContractAddress() string {
	if m != nil {
		return m.ContractAddress
	}
	return ""
}

func (m *ContractInfoByPoolIdResponse) GetCodeId() uint64 {
	if m != nil {
		return m.CodeId
	}
	return 0
}

// =============================== PoolRawFilteredState
type PoolRawFilteredStateRequest struct {
	// pool_id is the pool id of the requested pool.
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
	// key_filter is the key filter of the requested pool.
	KeyFilter string `protobuf:"bytes,2,opt,name=key_filter,json=keyFilter,proto3" json:"key_filter,omitempty" yaml:"key_filter"`
	// value_filter is the value filter of the requested pool.
	ValueFilter string `protobuf:"bytes,3,opt,name=value_filter,json=valueFilter,proto3" json:"value_filter,omitempty" yaml:"value_filter"`
}

func (m *PoolRawFilteredStateRequest) Reset()         { *m = PoolRawFilteredStateRequest{} }
func (m *PoolRawFilteredStateRequest) String() string { return proto.CompactTextString(m) }
func (*PoolRawFilteredStateRequest) ProtoMessage()    {}
func (*PoolRawFilteredStateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_733c758985c393b2, []int{6}
}
func (m *PoolRawFilteredStateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PoolRawFilte


using System.Runtime.CompilerServices;

using Scover.WinClean.Services;

namespace Scover.WinClean.ViewModel.Logging;

public abstract class Logger
{
    /// Gets or sets the minimal log level for a logging operation to occur.
    /// <remarks>Default value is <see cref="LogLevel.Verbose"/>.</remarks>
    public LogLevel MinLevel { get; set; } = LogLevel.Verbose;

    /// Clears the logs.
    public abstract Task ClearLogsAsync();

    /// Logs a string.
    /// <param name="message">The string to log.</param>
    /// <param name="lvl">The level of the log entry.</param>
    /// <param name="caller"><see cref="CallerMemberNameAttribute"/> - Don't specify</param>
    /// <param name="callLine"><see cref="CallerLineNumberAttribute"/> - Don't specify</param>
    /// <param name="callFile"><see cref="CallerFilePathAttribute"/> - Don't specify</param>
    public void Log(string message,
               LogLevel lvl = LogLeve


translateX(100px)'
    })),
    transition('normal <=> highlighted', animate(300)),
  ];

  public static trigger(name: string): AnimationTriggerMetadata {

    const newTrigger = new MyAnime();
    newTrigger.name = name;
    console.log(newTrigger.createTrigger());
    return newTrigger.createTrigger();
  }

  private createTrigger() {
    return trigger(this.name, this.definitions);
  }

}

// mozna tak
// export const animation: AnimationTriggerMetadata [] = [MyAnime.trigger('divState')];

import {MessagePort, Worker, WorkerOptions} from "worker_threads";
import {WorkerPromiseOptions, WorkerPromiseProtocol} from "./types";
import hyperId from "hyperid";

class Main extends Worker {
  private requestMap: Map<string, {
    resolve: (value?: any | PromiseLike<any>) => void;
    reject: (reason?: any) => void
  }> = new Map();

  private timeoutCollectors: Map<string, NodeJS.Timeout> = new Map();

  private readonly idGenerator = hyperId({
    fixedLength: true
  });

  constructor(fileName: string, options?: WorkerOptions) {
    super(fileName, options);

    this.hookListener();
  }

  postMessageAsync(value: any, options?: WorkerPromiseOptions, transferList?: Array<ArrayBuffer | MessagePort>) {
    return new Promise((resolve, reject) => {
      const id = this.idGenerator();
      this.requestMap.set(id, {
        resolve,
        reject
      });
      this.postMessage(Main.prepareMessage(id, value), transferList);
      if (options && options.timeout) {
        this.setClear(id, options.timeout, options.unref)
      }
    });
  }

  hookListener() {
    this.on('message', (data: WorkerPromiseProtocol) => {
      if (data && data.___i) {
        const req = this.requestMap.get(data.___i);
        if (req) {
          this.timeoutCollectors.delete(data.___i);

          if (data.error) {
            req.reject(data.error);
          } else {
            req.resolve(data.value);
          }
        }
      }
    });
  }

  private setClear(id: string, ms: number, unref?: boolean) {
    const timeout = setTimeout(() => {
      this.timeout(id);
    }, ms);

    if (unref) {
      timeout.unref();
    }

    this.timeoutCollectors.set(id, timeout);
  }

  private timeout(id: string) {
    this.timeoutCollectors.delete(id);
    const request = this.requestMap.get(id);
    if (request) {
      request.reject(new Error('Worker timeout exceed'));
      this.requestMap.delete(id);
    }
  }

  static prepareMessage(i: string, value?: any, error?: any): WorkerPromiseProtocol {
    return {
      ___i: i,
      error,
      value
    }
  }

  static connect(parentPort: MessagePort) {
    const event = parentPort.on;
    parentPort.on = (type: string, listener: (value: any) => void) => {
      if (type !== 'message') event.apply(parentPort, [type, listener]);

      event.apply(parentPort, ['message', async (data: WorkerPromiseProtocol) => {
        if (data && data.___i) {
          try {
            parentPort.postMessage(this.prepareMessage(data.___i, await listener(data.value)));
          } catch (e) {
            parentPort.postMessage(this.prepareMessage(data.___i, null, data.error));
          }
        } else {
          listener(data.value);
        }
      }]);

      return parentPort;
    }
  }
}

export {
  Main
}
// 类型注解：我们主动告诉 ts  变量的类型
let count:number = 123; // 我们主动告诉 ts count 为 number 类型


import _plotly_utils.basevalidators

class ArraydtickValidator(_plotly_utils.basevalidators.IntegerValidator):
    def __init__(self, plotly_name="arraydtick", parent_name="carpet.aaxis", **kwargs):
        super(ArraydtickValidator, self).__init__(
            plotly_name=plotly_name,
            parent_name=parent_name,
            edit_type=kwargs.pop("edit_type", "calc"),
            min=kwargs.pop("min", 1),
            **kwargs,
        )


97 */  jal   Math_Vec3s_ToVec3f
/* AD720C 8006006C 26250046 */   addiu $a1, $s1, 0x46
/* AD7210 80060070 C6040058 */  lwc1  $f4, 0x58($s0)
/* AD7214 80060074 C6060064 */  lwc1  $f6, 0x64($s0)
/* AD7218 80060078 C60A004C */  lwc1  $f10, 0x4c($s0)
/* AD721C 8006007C C6120040 */  lwc1  $f18, 0x40($s0)
/* AD7220 80060080 46062200 */  add.s $f8, $f4, $f6
/* AD7224 80060084 3C013E80 */  li    $at, 0x3E800000 # 0.000000
/* AD7228 80060088 44810000 */  mtc1  $at, $f0
/* AD722C 8006008C 8FB80038 */  lw    $t8, 0x38($sp)
/* AD7230 80060090 460A4400 */  add.s $f16, $f8, $f10
/* AD7234 80060094 3C088016 */  lui   $t0, %hi(D_8015E390) # $t0, 0x8016
/* AD7238 80060098 2508E390 */  addiu $t0, %lo(D_8015E390) # addiu $t0, $t0, -0x1c70
/* AD723C 8006009C 27B90058 */  addiu $t9, $sp, 0x58
/* AD7240 800600A0 46128100 */  add.s $f4, $f16, $f18
/* AD7244 800600A4 8FA40078 */  lw    $a0, 0x78($sp)
/* AD7248 800600A8 02202825 */  move  $a1, $s1
/* AD724C 800600AC 8FA6003C */  lw    $a2, 0x3c($sp)
/* AD7250 800600B0 46002182 */  mul.s $f6, $f4, $f0
/* AD7254 800600B4 27A70064 */  addiu $a3, $sp, 0x64
/* AD7258 800600B8 E7A60058 */  swc1  $f6, 0x58($sp)
/* AD725C 800600BC C60A0068 */  lwc1  $f10, 0x68($s0)
/* AD7260 800600C0 C608005C */  lwc1  $f8, 0x5c($s0)
/* AD7264 800600C4 C6120050 */  lwc1  $f18, 0x50($s0)
/* AD7268 800600C8 C6060044 */  lwc1  $f6, 0x44($s0)
/* AD726C 800600CC 460A4400 */  add.s $f16, $f8, $f10
/* AD7270 800600D0 46128100 */  add.s $f4, $f16, $f18
/* AD7274 800600D4 46062200 */  add.s $f8, $f4, $f6
/* AD7278 800600D8 46004282 */  mul.s $f10, $f8, $f0
/* AD727C 800600DC E7AA005C */  swc1  $f10, 0x5c($sp)
/* AD7280 800600E0 C612006C */  lwc1  $f18, 0x6c($s0)
/* AD7284 800600E4 C6100060 */  lwc1  $f16, 0x60($s0)
/* AD7288 800600E8 C6060054 */  lwc1  $f6, 0x54($s0)
/* AD728C 800600EC C60A0048 */  lwc


，还应当提供经办人的身份证明。

销售民用爆炸物品的企业，应当查验前款规定的许可证和经办人的身份证明；对持《民用爆炸物品购买许可证》购买的，应当按照许可的品种、数量销售。

第二十三条 销售、购买民用爆炸物品，应当通过银行账户进行交易，不得使用现金或者实物进行交易。

销售民用爆炸物品的企业，应当将购买单位的许可证、银行账户转账凭证、经办人的身份证明复印件保存2年备查。

第二十四条 销售民用爆炸物品的企业，应当自民用爆炸物品买卖成交之日起3日内，将销售的品种、数量和购买单位向所在地省、自治区、直辖市人民政府民用爆炸物品行业主管部门和所在地县级人民政府公安机关备案。

购买民用爆炸物品的单位，应当自民用爆炸物品买卖成交之日起3日内，将购买的品种、数量向所在地县级人民政府公安机关备案。

第二十五条 进出口民用爆炸物品，应当经国务院民用爆炸物品行业主管部门审批。进出口民用爆炸物品审批办法，由国务院民用爆炸物品行业主管部门会同国务院公安部门、海关总署规定。

进出口单位应当将进出口的民用爆炸物品的品种、数量向收货地或者出境口岸所在地县级人民政府公安机关备案。

## 第四章 运输

第二十六条 运输民用爆炸物品，收货单位应当向运达地县级人民政府公安机关提出申请，并提交包括下列内容的材料：

(一)民用爆炸物品生产企业、销售企业、使用单位以及进出口单位分别提供的《民用爆炸物品生产许可证》、《民用爆炸物品销售许可证》、《民用爆炸物品购买许可证》或者进出口批准证明；

(二)运输民用爆炸物品的品种、数量、包装材料和包装方式；

(三)运输民用爆炸物品的特性、出现险情的应急处置方法；

(四)运输时间、起始地点、运输路线、经停地点。

受理申请的公安机关应当自


uario,
    on(
        UsuarioActions.cargarUsuario,
        (estado: UsuarioState, { parametros }) => {
            return {
                ...estado,
                ...parametros,
                cargando: true,
            };
        }
    ),
    on(
        UsuarioActions.cargarUsuarioExito,
        (estado: UsuarioState, { usuario }) => {
            return {
                ...estado,
                ...usuario,
                cargando: false,
                cargo: true,
            };
        }
    ),
    on(
        UsuarioActions.cargarUsuarioError,
        (estado: UsuarioState, { error }) => {
            return {
                ...estado,
                cargando: false,
                cargo: false,
                error,
            };
        }
    ),
);

export function usuarioReducer(state: UsuarioState | undefined, action: Action) {
    return _usuarioReducer(state, action);
}

import { Key } from '../Key';
import { Keyboard } from '../Keyboard';

export type WASDKeysConfig = {
    W: boolean;
    A: boolean;
    S: boolean;
    D: boolean;
    space: boolean;
};

export class WASDKeys
{
    W: Key;
    A: Key;
    S: Key;
    D: Key;
    space: Key;

    constructor (keyboardManager: Keyboard, config?: WASDKeysConfig)
    {
        const {
            W = true,
            A = true,
            S = true,
            D = true,
            space = true
        } = config;

        const keys = keyboardManager.keys;

        if (W)
        {
            this.W = new Key('w');

            keys.set(this.W.value, this.W);
        }

        if (A)
        {
            this.A = new Key('a');

            keys.set(this.A.value, this.A);
        }

        if (S)
        {
            this.S = new Key('s');

            keys.set(this.S.value, this.S);
        }

        if (D)
        {
            this.D = new Key('d');

            keys.set(this.D.value, this.D);
        }

        if (space)
        {
            this.space = new Key(' ');

            keys.set(this.space.value, this.space);
        }
    }
}
import { IS_IE } from "./consts";
import Component from "@egjs/component";
import { toArray, isDataAttribute, removeEvent, addEvent } from "./utils";
import { remove as removeAutoSizer, add as addAutoSizer } from "./AutoSizer";

/**
 * @namespace eg.LazyLoaded
 */
/**
 * This module is used to wait for images or videos to load.
 * @ko 이 모듈은 이미지 또는 비디오 로딩을 대기할 수 있습니다.
 * @memberof eg.LazyLoaded
 * @param -
 * @example
 * ## HTML
 * ```html
 * <div>
 *    <img src="./1.jpg" data-width="1280" data-height="853" style="width:100%"/>
 *    <img src="./2.jpg">
 *    <img src="./3.jpg">
 *    <img src="./4.jpg">
 *    <img src="ERR">
 *    <img src="./6.jpg">
 *    <img src="./7.jpg">
 *    <img src="ERR">
 * </div>
 * ```
 * ## Javascript
 * ```js
 * import {check} from "@egjs/lazyloaded";
 *
 * eg.LazyLoaded.check([document.querySelector("div")]).on({
 *   ready: () => console.log("ready"),
 *   finish: () => console.log("finish"),
 *   error: e => console.log("error", e),
 * });
 * ```
 */
export function check(
  elements: HTMLElement[],
  prefix: string = "data-",
): Component {
  const component = new Component();
  let finishCount = 0;
  let readyCount = 0;

  function checkReady() {
    if (--readyCount !== 0) {
      return;
    }
    /**
     * An event occurs when the size of all images is available.
     * @ko 모든 이미지의 사이즈를 구할 수 있는 상태가 된


//  2015-2016 Sitecore Corporation A/S. All rights reserved.

using System;
using System.Windows;
using System.Windows.Media;
using Sitecore.Rocks.Annotations;
using Sitecore.Rocks.Diagnostics;
using Sitecore.Rocks.Extensions.DateTimeExtensions;
using Xceed.Wpf.Toolkit;

namespace Sitecore.Rocks.UI.RuleEditors.Macros
{
    [RuleEditorMacro("datetime")]
    public class DateTimeMacro : RuleEditorMacroBase
    {
        private DateTimePicker _dateTimePicker;

        public override object GetEditableControl()
        {
            var value = GetValue();

            _dateTimePicker = new DateTimePicker
            {
                Foreground = Brushes.Blue,
                BorderThickness = new Thickness(0),
                BorderBrush = Brushes.Transparent,
                Background = Brushes.Transparent,
                Padding = new Thickness(0),
                Margin = new Thickness(0),
                VerticalAlignment = VerticalAlignment.Top,
                FontFamily = new FontFamily(@"Segoe UI"),
                FontSize = 11
            };

            TextOptions.SetTextRenderingMode(_dateTimePicker, TextRenderingMode.Clea


, 0).await.unwrap();
        let attr = SetAttr {
            size: Some(4096),
            .. Default::default()
        };
        fs.setattr(&fd, attr).await.unwrap();

        let r = fs.lseek(&fd, 0, SeekWhence::Data).await;
        assert_eq!(r, Err(libc::ENXIO));
    }

    #[rstest]
    #[case(false)]
    #[case(true)]
    #[tokio::test]
    async fn lseek_last_hole(#[case] blobs: bool) {
        use SeekWhence::Hole;
        let (fs, _cache, _db, _tree_id) = harness4k().await;
        let root = fs.root();

        // Create a file like this:
        // |======|      |>
        // | data | hole |EOF
        let filename = OsString::from("x");
        let fd = fs.create(&root, &filename, 0o644, 0, 0).await.unwrap();
        let buf = vec![42u8; 4096];
        fs.write(&fd, 0, &buf[..], 0).await.unwrap();
        let attr = SetAttr {
            size: Some(8192),
            .. Default::default()
        };
        fs.setattr(&fd, attr).await.unwrap();
        if blobs {
            // Sync the filesystem to flush the InlineExtents to BlobExtents
            fs.sync().await;
        }

        // SeekHole prior to the last hole in the file
        assert_eq!(Ok(4096), fs.lseek(&fd, 0, Hole).await);
    }

    #[tokio::test]
    async fn mkdir() {
        let (fs, _cache, _db, _tree_id) = harness4k().await;
        let name = OsStr::from_bytes(b"x");
        let root = fs.root();
        let fd = fs.mkdir(&root, name, 0o755, 0, 0).await
        .unwrap();
        let fd1 = fs.lookup(None, &root, name).await.unwrap();
        assert_eq!(fd1.ino(), fd.ino());

        // The new dir should have "." and ".." directory entries
        let entries = readdir_all(&fs, &fd, 0).await;
        let (dotdot, _) = entries[0];
        assert_eq!(dotdot.d_type, libc::DT_DIR);
        let dotdot_name = unsafe{
            CStr::from_ptr(&dotdot.d_name as *const c_char)
        };
        assert_eq!(dotdot_name, CString::new("..").unwrap().as_c_str());
        assert_eq!(u64::from(dotdot.d_fileno), root.ino());
        let (dot, _) = entries[1];
        assert_eq!(dot.d_type, libc::DT_DIR);
        let dot_name = unsafe{
            CStr::from_ptr(&dot.d_name as *const c_char)
        };
        assert_eq!(dot_name, CString::new(".").unwrap().as_c_str());
        assert_eq!(u64::from(dot.d_fileno), fd.ino());

        // The parent dir should have an "x" directory entry
        let entries = readdir_all(&fs, &root, 0).await;
        let (dirent, _ofs) = entries
        .into_iter()
        .find(|(dirent, _ofs)| {
            dirent.d_name[0] == 'x' as i8
        }).expect("'x' directory entry not found");
        assert_eq!(dirent.d_type, libc::DT_DIR);
        let dirent_name = unsafe{
            CStr::from_ptr(&dirent.d_name as *const c_char)
        };
        assert_eq!(dirent_name, CString


ntext _ctx)
        {
			DescribeDrdsTasksResponse describeDrdsTasksResponse = new DescribeDrdsTasksResponse();

			describeDrdsTasksResponse.HttpResponse = _ctx.HttpResponse;
			describeDrdsTasksResponse.Success = _ctx.BooleanValue("DescribeDrdsTasks.Success");
			describeDrdsTasksResponse.RequestId = _ctx.StringValue("DescribeDrdsTasks.RequestId");

			List<DescribeDrdsTasksResponse.DescribeDrdsTasks_Task> describeDrdsTasksResponse_tasks = new List<DescribeDrdsTasksResponse.DescribeDrdsTasks_Task>();
			for (int i = 0; i < _ctx.Length("DescribeDrdsTasks.Tasks.Length"); i++) {
				DescribeDrdsTasksResponse.DescribeDrdsTasks_Task task = new DescribeDrdsTasksResponse.DescribeDrdsTasks_Task();
				task.State = _ctx.StringValue("DescribeDrdsTasks.Tasks["+ i +"].State");
				task.Content = _ctx.StringValue("DescribeDrdsTasks.Tasks["+ i +"].Content");
				task.Id = _ctx.LongValue("DescribeDrdsTasks.Tasks["+ i +"].Id");

				describeDrdsTasksResponse_tasks.Add(task);
			}
			describeDrdsTasksResponse.Tasks = describeDrdsTasksResponse_tasks;

			return describeDrdsTasksResponse;
        }
    }
}


String? accessToken,
    String? userId,
  }) : super(chat: chat) {
    url = 'users/${getUrlEncodedUserId(chat, userId)}/session_key';

    headers = {'App-Id': appId};

    if (accessToken != null) {
      headers['Access-Token'] = accessToken;
    }

    body = {
      'expiring_session': chat.chatContext.isFeedAuthenticated
          ? true
          : (chat.eventManager.getSessionHandler() != null),
    };

    if (chat.chatContext.isChatConnected) {
      body['services'] = ['chat', 'feed'];
    } else if (chat.chatContext.isFeedAuthenticated) {
      body['services'] = ['feed'];
    }
  }

  @override
  Future<Map<String, dynamic>> response(Map<String, dynamic> res) async {
    return Map.from(res);
  }
}
// Copyright (c) 2023 Sendbird, Inc. All rights reserved.

import 'package:sendbird_chat_sdk/src/internal/main/chat/chat.dart';
import 'package:sendbird_chat_sdk/src/internal/main/extensions/extensions.dart';
import 'package:sendbird_chat_sdk/src/internal/network/http/http_client/http_client.dart';
import 'package:sendbird_chat_sdk/src/internal/network/http/http_client/request/api_request.dart';
import 'package:sendbird_chat_sdk/src/public/main/define/enums.dart';
import 'package:sendbird_chat_sdk/src/internal/network/http/http_client/response/responses.dart';

class MutedUserListRequest extends ApiRequest {
  @override
  HttpMethod get method => HttpMethod.get;

  MutedUserListRequest(
    Chat chat, {
    required int limit,
    required ChannelType channelType,
    required String channelUrl,
    String? token,
  }) : super(chat: chat) {
    url = '${channelType.urlString}/$channelUrl/mute';
    queryParams = {
      'limit': limit,
      if (token != null) 'token': token,
    };
  }

  @override
  Future<UserListQueryResponse> response(Map<String, dynamic> res) async {
    final output = {'users': res['muted_list'], 'next': res['next']};
    return UserListQueryResponse.fromJsonWithChat(chat, output);
  }
}
// Copyright (c) 2023 Sendbird, Inc. All rights reserved.

import 'package:sendbird_chat_sdk/src/internal/main/chat/chat.dart';
import 'package:sendbird_chat_sdk/src/internal/main/extensions/extensions.dart';
import 'package:sendbird_chat_sdk/src/internal/network/http/http_client/http_client.dart';
import 'package:sendbird_chat_sdk/src/internal/network/http/http_client/request/api_request.dart';
import 'package:sendbird_chat_sdk/src/public/main/define/enums.dart';
import 'package:sendbird_chat_sdk/src/internal/network/http/http_client/response/responses.dart';

class OperatorListRequest extends ApiRequest {
  @override
  HttpMethod get method => HttpMethod.get;

  OperatorListRequest(
    Chat chat, {
    required int limit,
    required ChannelType channelType,
    required String channelUrl,
    String? token,
  }) : super(chat: chat) {
    url = '${channelType.urlString}/$channelUrl/operators';
    queryParams = {
      'limit': limit.toString(),
      if (token != null) 'token': token,
    };
  }

  @override
  Future<OperatorListQueryResponse> response(Map<String, dynamic> res) async {
    final response = OperatorListQueryResponse.fromJson(res)


Duration;
import java.time.Instant;
import java.util.Random;

public class SortTestHelper {

    private static final Random random = new Random();

    /**
     * 生成随机数组的方法
     *
     * @param length 数组的位数
     * @param min    数组中元素的最小值（可以取到）
     * @param max    数组中元素的最大值（不能取到）
     * @return 一个随机数组
     */
    public static int[] generateRandomArray(int length, int min, int max) {
        int[] randomArray = new int[length];
        Random random = new Random();
        for (int i = 0; i < length; i++) {
            randomArray[i] = min + random.nextInt(max - min);
        }
        return randomArray;
    }

    /**
     * 测试排序的效率
     * @param sortAlgorithm
     * @param arr
     */
    public static void testSortEfficiency(ISortAlgorithm sortAlgorithm, int[] arr) {
        System.out.println("您所使用的排序算法是 => " + sortAlgorithm.getName());
        // SortTestHelper.printArray(arr);
        Instant begin = Instant.now();
        sortAlgorithm.sort(arr);
        Instant end = Instant.now();
        // long spend = Duration.between(begin, end).toNanos();
        long spend = Duration.between(begin, end).toMillis();
        BigDecimal spendBigDecimal = new BigDecimal(String.valueOf(spend)).divide(new BigDecimal("1000"));
        // SortTestHelper.printArray(arr);
        System.out.println("排序算法耗时 => " + spendBigDecimal + " 秒");
    }

    /**
     * 复制数组
     * 根据已经有的数组得到一个新的数组（用于比较排序算法的效率）
     *
     * @param arr
     * @return
     */
    public static int[] copyFromOldArray(int[] arr) {
        int[] newArr = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];
        }
        return newArr;
    }

    /**
     * 测试数组是否按照升序排序
     *
     * @param arr
     */
    public static void testSorted(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                throw new RuntimeException("给定数组不是按照升序排序");
            }
        }
        System.out.println("给定数组按照升序排序！");
    }

    /**
     * 打印数组
     *
     * @param arr
     */
    public static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.printf("%d ", num);
        }
        System.out.println();
    }

    /**
     * 判断两个数组是否相等
     *
     * @param arr1 待比较的数组 1
     * @param arr2 待比较的数组 2
     */
    public static boolean judgeArrayEquals(int[] arr1, int[] arr2) {
        if (arr1.length != arr2.length) {
            throw new RuntimeException("两个数组的长度不相等");
        }
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        return true;
    }

    /**
     * 生成近乎有序的数组
     */
    /**


import pandas as pd

# Read the CSV files into DataFrames
updated_skin_df = pd.read_csv("updated_skin.csv")
cosmetic_p_df = pd.read_csv("Products/cosmetic_p.csv")

# Drop the specified columns from cosmetic_p_df
cosmetic_p_df = cosmetic_p_df.drop(columns=["Sensitive", "ingredients"])

# Sort cosmetic_p_df by rank in descending order
sorted_cosmetic_p_df = cosmetic_p_df.sort_values(by="rank", ascending=False)

# Print unique labels in cosmetic_p_df for debugging
print("Unique Labels in cosmetic_p_df:")
print(cosmetic_p_df["Label"].unique())

# Initialize an empty DataFrame to store the results
results_df = pd.DataFrame(columns=["name", "rank", "label"])

# Iterate through each row in updated_skin_df
for _, row in updated_skin_df.iterrows():
    labels = [label.strip('"') for label in row["Label"].split(", ")]  # Remove quotes
    combination = row["Combination"]
    dry = row["Dry"]
    normal = row["Normal"]
    oily = row["Oily"]

    # Iterate through each label
    for label in labels:
        print("Processing label:", label)

        # Filter cosmetic_p_df based on label and skin type
        filtered_cosmetic_df = sorted_cosmetic_p_df[
            (sorted_cosmetic_p_df["Label"].str.strip('"') == label)
            & (
                (sorted_cosmetic_p_df["Combination"] == combination)
                | (sorted_cosmetic_p_df["Dry"] == dry)
                | (sorted_cosmetic_p_df["Normal"] == normal)
                | (sorted_cosmetic_p_df["Oily"] == oily)
            )
        ]

        # If there are matching products, add them to the results
        if not filtered_cosmetic_df.empty:
            result_rows = filtered_cosmetic_df[["name", "rank"]].assign(label=label)
            results_df = pd.concat([results_df, result_rows])

# Display the results
print(results_df)

# If you want to save it to a new CSV file:
# results_df.to_csv('path/to/results.csv', index=False)


pl(TestReferenceChecker checker) :
        checker_(std::move(checker)), bLastNewline_(true), currentLine_(0), bHasOutput_(false)
    {
        using ::testing::_;
        using ::testing::Invoke;
        EXPECT_CALL(inputStream_, readLine(_)).WillRepeatedly(Invoke(this, &Impl::readInputLine));
        EXPECT_CALL(inputStream_, close()).Times(0);
        EXPECT_CALL(outputStream_, write(_)).WillRepeatedly(Invoke(this, &Impl::addOutput));
        EXPECT_CALL(outputStream_, close()).Times(0);
    }

    bool readInputLine(std::string* line)
    {
        checkOutput();
        line->clear();
        const bool bPresent = (currentLine_ < Index(inputLines_.size()));
        if (bPresent)
        {
            line->assign(inputLines_[currentLine_]);
            if (bLastNewline_ || currentLine_ + 1 < Index(inputLines_.size()))
            {
                line->append("\n");
            }
        }
        ++currentLine_;
        const std::string id = formatString("Input%d", static_cast<int>(currentLine_));
        StringTestBase::checkText(&checker_, *line, id.c_str());
        return bPresent;
    }
    void addOutput(const char* str)
    {
        bHasOutput_ = true;
        currentOutput_.append(str);
    }

    void checkOutput()
    {
        if (bHasOutput_)
        {
            const std::string id = formatString("Output%d", static_cast<int>(currentLine_));
            StringTestBase::checkText(&checker_, currentOutput_, id.c_str());
            bHasOutput_ = false;
        }
        currentOutput_.clear();
    }

    TestReferenceChecker        checker_;
    ArrayRef<const char* const> inputLines_;
    bool                        bLastNewline_;
    Index                       currentLine_;
    bool                        bHasOutput_;
    std::string                 currentOutput_;
    MockTextInputStream         inputStream_;
    MockTextOutputStream        outputStream_;
};

InteractiveTestHelper::InteractiveTestHelper(TestReferenceChecker checker) :
    impl_(new Impl(checker.checkCompound("InteractiveSession", "Interactive")))
{
}

InteractiveTestHelper::~InteractiveTestHelper() {}

void InteractiveTestHelper::setLastNewline(bool bInclude)
{
    impl_->bLastNewline_ = bInclude;
}

void InteractiveTestHelper::setInputLines(const ArrayRef<const char* const>& inputLines)
{
    impl_->inputLines_  = inputLines;
    impl_->currentLine_ = 0;
}

TextInputStream& InteractiveTestHelper::inputStream()
{
    return impl_->inputStream_;
}

TextOutputStream& InteractiveTestHelper::outputStream()
{
    return impl_->outputStream_;
}

void InteractiveTestHelper::checkSession()
{
    impl_->checkOutput();
    impl_->checker_.checkUnusedEntries();
}

} // namespace test
} // namespace gmx
/*
 * This file is part of the GROMACS molecular simulation package.
 *
 * Copyright 2016- The GROMACS Authors
 * and the project initiators Erik Lindahl, Berk Hess and David van der Spoel.
 * Consult the AUTHORS/COPYING files and https://www.gromacs.org for details.
 *
 * GROMACS is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.
 *
 * GROMACS is distributed in the hope that it will be useful,
 * but WIT


	}
	case <-time.After(1 * time.Second):
		t.Fatalf("EthSubscribe did not return within 1s after Close")
	}
}

// This test checks that Client doesn't lock up when a single subscriber
// doesn't read subscription events.
func TestClientNotificationStorm(t *testing.T) {
	server := newTestServer("eth", new(NotificationTestService))
	defer server.Stop()

	doTest := func(count int, wantError bool) {
		client := DialInProc(server)
		defer client.Close()
		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
		defer cancel()

		// Subscribe on the server. It will start sending many notifications
		// very quickly.
		nc := make(chan int)
		sub, err := client.EthSubscribe(ctx, nc, "someSubscription", count, 0)
		if err != nil {
			t.Fatal("can't subscribe:", err)
		}
		defer sub.Unsubscribe()

		// Process each notification, try to run a call in between each of them.
		for i := 0; i < count; i++ {
			select {
			case val := <-nc:
				if val != i {
					t.Fatalf("(%d/%d) unexpected value %d", i, count, val)
				}
			case err := <-sub.Err():
				if wantError && err != ErrSubscriptionQueueOverflow {
					t.Fatalf("(%d/%d) got error %q, want %q", i, count, err, ErrSubscriptionQueueOverflow)
				} else if !wantError {
					t.Fatalf("(%d/%d) got unexpected error %q", i, count, err)
				}
				return
			}
			var r int
			err := client.CallContext(ctx, &r, "eth_echo", i)
			if err != nil {
				if !wantError {
					t.Fatalf("(%d/%d) call error: %v", i, count, err)
				}
				return
			}
		}
	}

	doTest(8000, false)
	doTest(10000, true)
}

func TestClientHTTP(t *testing.T) {
	server := newTestServer("service", new(Service))
	defer server.Stop()

	client, hs := httpTestClient(server, "http", nil)
	defer hs.Close()
	defer client.Close()

	// Launch concurrent requests.
	var (
		results    = make([]Result, 100)
		errc       = make(chan error)
		wantResult = Result{"a", 1, new(Args)}
	)
	defer client.Close()
	for i := range results {
		i := i
		go func() {
			errc <- client.Call(&results[i], "service_echo",
				wantResult.String, wantResult.Int, wantResult.Args)
		}()
	}

	// Wait for all of them to complete.
	timeout := time.NewTimer(5 * time.Second)
	defer timeout.Stop()
	for i := range results {
		select {
		case err := <-errc:
			if err != nil {
				t.Fatal(err)
			}
		case <-timeout.C:
			t.Fatalf("timeout (got %d/%d) results)", i+1, len(results))
		}
	}

	// Check results.
	for i := range results {
		if !reflect.DeepEqual(results[i], wantResult) {
			t.Errorf("result %d mismatch: got %#v, want %#v", i, results[i], wantResult)
		}
	}
}

func TestClientReconnect(t *testing.T) {
	startServer := func(addr string) (*Server, net.Listener) {
		srv := newTestServer("service", new(Service))
		l, err := net.Listen("tcp", addr)
		if err != nil {
			t.Fatal(err)
		}
		go http.Serve(l, srv.WebsocketHandler([]string{"*"})


    exp(preAlphaExp_*(fvc::interpolate(alpha_) - alphaMax_)),
            expMax_
        )
    );

   surfaceScalarField::Boundary& bpPrime =
       tpPrime.ref().boundaryFieldRef();

    forAll(bpPrime, patchi)
    {
        if (!bpPrime[patchi].coupled())
        {
            bpPrime[patchi] == 0;
        }
    }

    return tpPrime;
}

Foam::tmp<Foam::volSymmTensorField>
Foam::RASModels::phasePressureModel::devRhoReff() const
{
    return tmp<volSymmTensorField>
    (
        new volSymmTensorField
        (
            IOobject
            (
                IOobject::groupName("devRhoReff", U_.group()),
                runTime_.timeName(),
                mesh_,
                IOobject::NO_READ,
                IOobject::NO_WRITE
            ),
            mesh_,
            dimensioned<symmTensor>
            (
                "R",
                rho_.dimensions()*dimensionSet(0, 2, -2, 0, 0),
                Zero
            )
        )
    );
}

Foam::tmp<Foam::fvVectorMatrix>
Foam::RASModels::phasePressureModel::divDevRhoReff
(
    volVectorField& U
) const
{
    return tmp<fvVectorMatrix>
    (
        new fvVectorMatrix
        (
            U,
            rho_.dimensions()*dimensionSet(0, 4, -2, 0, 0)
        )
    );
}

void Foam::RASModels::phasePressureModel::correct()
{}

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


26级接收推荐免试研究生报名通知南方科技大学-固高科技专硕联培项目](https://sdim.sustech.edu.cn/index/show?id=503) |
| ~~2025-09-19~~ | [2025年南方科技大学环境科学与工程学院2026级工程硕博士培养改革专项接收推免生报名的通知](https://mp.weixin.qq.com/s/K6yS-nVjToNqKZGsFJP1wA) |
| ~~2025-09-15~~ | [2025年南方科技大学国家卓越工程师学院2026级推免研究生（含直博生）预报名通知](https://mp.weixin.qq.com/s/7Sa7Pw008VsKSFGBU7ycLw) |
| ~~2025-09-14~~ | [2025年南方科技大学公共卫生及应急管理学院2026级推荐免试研究生（含直博生）预报名通知](https://sph.sustech.edu.cn/news/detail/350.html?lang=zh-cn&cid=131) |
| ~~2025-09-10~~ | [2025年南方科技大学数学系接收2026级推荐免试研究生（含直博生）预报名通知](https://math.sustech.edu.cn/graduate_enrollment/13381) |
| ~~2025-09-10~~ | [2025年南方科技大学商学院2026级推荐免试研究生（含直博生）预报名通知](https://business.sustech.edu.cn/web/activity_detail.php?id=55) |
| ~~2025-09-08~~ | [2025年南方科技大学地球与空间科学系接收2026级推荐免试研究生（含直博生）](https://ess.sustech.edu.cn/New-detail-id-1182.html) |
| ~~2025-09-07~~ | [2025年南方科技大学海洋科学与工程系接收2026级推荐免试研究生（含直博生） 预报名通知](https://mp.weixin.qq.com/s/kg77M4QBbuKfew-fggoOVg) |
| ~~2025-09-06~~ | [2025年南方科技大学化学系2026级推荐免试研究生（含直博生）预报名通知](https://mp.weixin.qq.com/s/LMFdyNvA8KrNM9hQABYtvA) |
| ~~2025-09-01~~ | [2025年南方科技大学创新创业学院接收2026级推荐免试研究生预报名通知](http://ie-school.sustech.edu.cn/page/content?id=690) |
| ~~2025-08-31~~ | [2025年南方科技大学环境科学与工程学院2026


bscribeLink: '구독 링크 보기'
  },
  orders: {
    title: '주문 목록',
    loading: '주문 로딩 중...',
    tradeNo: '주문 번호',
    createdAt: '생성 시간',
    cycle: '주기',
    totalAmount: '금액',
    statusLabel: '상태',
    actions: '작업',
    viewDetail: '자세히 보기',
    cancel: '주문 취소',
    noOrders: '주문 없음',
    goShopping: '플랜 구매하러 가기',
    cancelConfirmTitle: '주문 취소 확인',
    cancelConfirmText: '이 주문을 취소하시겠습니까? 이 작업은 되돌릴 수 없습니다.',
    cancelSuccess: '주문이 취소되었습니다',
    cancelFailed: '주문 취소 실패',
    welcome: {
      title: '주문 목록',
      description: '주문을 확인하고 관리하세요'
    },
    status: {
      pending: '결제 대기',
      processing: '활성화 중',
      cancelled: '취소됨',
      completed: '완료됨',
      discounted: '할인 적용됨',
      unknown: '알 수 없는 상태'
    },
    confirmOrder: '주문 확인',
    payment: '주문 결제',
  },
  tickets: {
    title: '티켓 시스템',
    description: '지원 팀과 연락하세요',

    searchPlaceholder: '티켓 검색...',
    newTicket: '새 티켓',
    createNew: '티켓 생성',

    subject: '제목',
    subjectPlaceholder: '티켓 제목을 입력하세요',
    message: '내용',
    messagePlaceholder: '문제를 자세히 설명하세요',
    level: '우선순위',
    levelLow: '낮음',
    levelMedium: '중간',
    levelHigh: '높음',

    statusOpen: '처리 중',
    statusClosed: '종료됨',

    noTickets: '티켓 없음',
    selectTicket: '티켓을 선택하여 자세히 보세요',
    noMessages: '메시지 기록 없음',
    loadingMessages: '메시지 로딩 중...',
    loadingTickets: '티켓 로딩 중...',

    formIncomplete: '


n state of the *interferenceType* member.
    # Possible values are UNSET, SET, UNCHANGED, and FREED.
    interferenceTypeState: SymbolicConstant = None

    # A Float specifying the allowable overclosure.
    overclosure: float = None

    # A SymbolicConstant specifying the propagation state of the *overclosure* member.
    # Possible values are COMPUTED and DIRECTION_COSINE.
    overclosureState: SymbolicConstant = None

    # A SymbolicConstant specifying the interference direction type. Possible values are
    # COMPUTED and DIRECTION_COSINE.
    interferenceDirectionType: SymbolicConstant = None

    # A SymbolicConstant specifying the propagation state of the *interferenceDirectionType*
    # member. Possible values are UNSET, SET, UNCHANGED, and FREED.
    interferenceDirectionTypeState: SymbolicConstant = None

    # A SymbolicConstant specifying the propagation state of the *direction* member. Possible
    # values are UNSET, SET, UNCHANGED, and FREED.
    directionState: SymbolicConstant = None

    # A SymbolicConstant specifying the propagation state of the *amplitude* member. Possible
    # values are UNSET, SET, UNCHANGED, and FREED.
    amplitudeState: SymbolicConstant = None

    # A SymbolicConstant specifying the propagation state of the *contactControls* member.
    # Possible values are UNSET, SET, UNCHANGED, and FREED.
    contactControlsState: SymbolicConstant = None

    # A String specifying the name of the ContactProperty object associated with this
    # interaction.
    interactionProperty: str = ""

    # A String specifying the name of the Amplitude object that defines the magnitude of the
    # prescribed interference during the step.
    amplitude: str = ""

    # A String specifying the name of the ContactControl object associated with this
    # interaction.
    contactControls: str = ""

    # A tuple of three Floats specifying the following:
    # - X-direction cosine of the interference direction vector.
    # - Y-direction cosine of the interference direction vector.
    # - Z-direction cosine of the interference direction vector.
    direction: float = None

    # A SymbolicConstant specifying the propagation state of the InteractionState object.
    # Possible values are:
    # - NOT_YET_ACTIVE
    # - CREATED
    # - PROPAGATED
    # - MODIFIED
    # - DEACTIVATED
    # - NO_LONGER_ACTIVE
    # - TYPE_NOT_APPLICABLE
    # - INSTANCE_NOT_APPLICABLE
    # - BUILT_INTO_BASE_STATE
    status: SymbolicConstant = None


var(--dark-bg-s) 60%);

	--switch-border: hsl(var(--dark-bg-h) var(--dark-bg-s) 94% / 54.42%);

	--text-primary: hsl(var(--dark-bg-h) var(--dark-bg-s) 90%);
	--text-secondary: hsl(var(--dark-bg-h) var(--dark-bg-s) 85% / 75%);
	--text-tertiary: hsl(var(--dark-bg-h) var(--dark-bg-s) 80% / 55%);
	--text-quaternary: hsl(var(--dark-bg-h) var(--dark-bg-s) 75% / 35%);
}
@use '../assets/coloured' as *;

// Icons
$icons: (
	// User Settings
	'my-account': $user,
	'profile-customization': $user-settings,
	'privacy-&-safety': $shield-lock,
	'authorized-apps': $approval,
	'connections': $connections,
	'nitro-server-boost': $rocket,
	'subscriptions': $credit-card,
	'library-inventory': $gift,
	'billing': $billing,
	'appearance': $eye,
	'accessibility': $accessibility,
	'voice-&-video': $mic,
	'text-&-images': $chat-settings,
	'notifications': $bell,
	'keybinds': $esc,
	'language': $language,
	'windows': $windows,
	'streamer-mode': $camera,
	'advanced': $cogs,
	'game-activity': $wifi,
	'overlay': $monitor,
	'friend-requests': $user-add,
	'activity-privacy': $privacy,

	// BetterDiscord
	'settings': $cog,
	'emotes': $emoji,
	'customcss': $code,
	'plugins': $plugin,
	'themes': $palette,

	'changelog': $change,
	'hypesquad-online': $star,
	'logout': $logout,

	// Guild Settings
	'overview': $overview,
	'roles': $management,
	'emoji': $emoji,
	'stickers': $sticker,
	'moderation': $cog-admin,
	'audit_log': $auditlog,
	'integrations': $integrations,
	'widget': $applet,
	'guild_templates': $template,

	'community': $users,

	'members': $people-group,
	'instant_invites': $invite,
	'bans': $user-cross,

	'delete': $trash,

	// Plugins
	'pluginrepo': $cooking-book,
	'themerepo': $art-book
);

// Disabled icons (for now hopefully)
// .item-3XjbnG {
// 	@each $label, $icon in $icons {
// 		&[aria-controls="#{$label}-tab"]::before {
// 			background-image: url($icon);
// 		}
// 	}
// 	&[aria-controls="discord-nitro-tab"] {
// 		&::before {
// 			content: none !important;
// 		}
// 		.premiumLabel_e681d1 {
// 			gap: 12px;
// 			flex-direction: row-reverse;
// 		}
// 		svg {
// 			display: block !important;
// 		}
// 	}
// }


, "/export:??_7CDynamicAsteroid@@6B@=_off_639DC3C,@982")
#pragma comment(linker, "/export:??_7CEArmor@@6B@=_off_639CC4C,@983")
#pragma comment(linker, "/export:??_7CEAttachedFX@@6B@=_off_639C51C,@984")
#pragma comment(linker, "/export:??_7CECargo@@6B@=_off_639CD4C,@985")
#pragma comment(linker, "/export:??_7CECargoPod@@6B@=_off_639CCB4,@986")
#pragma comment(linker, "/export:??_7CECloakingDevice@@6B@=_off_639C78C,@987")
#pragma comment(linker, "/export:??_7CECounterMeasureDropper@@6B@=_off_639D074,@988")
#pragma comment(linker, "/export:??_7CEEngine@@6BCInternalEquip@@@=_off_639CE6C,@989")
#pragma comment(linker, "/export:??_7CEEngine@@6BCPhysControllerEquip@@@=_off_639CE3C,@990")
#pragma comment(linker, "/export:??_7CEGun@@6B@=_off_639D13C,@991")
#pragma comment(linker, "/export:??_7CEInternalFX@@6B@=_off_639CBEC,@992")
#pragma comment(linker, "/export:??_7CELauncher@@6B@=_off_639CEE4,@993")
#pragma comment(linker, "/export:??_7CELightEquip@@6B@=_off_639C59C,@994")
#pragma comment(linker, "/export:??_7CEMineDropper@@6B@=_off_639CFAC,@995")
#pragma comment(linker, "/export:??_7CEPower@@6B@=_off_639CA64,@996")
#pragma comment(linker, "/export:??_7CERepairDroid@@6B@=_off_639CB2C,@997")
#pragma comment(linker, "/export:??_7CEScanner@@6BCInternalEquip@@@=_off_639CACC,@998")
#pragma comment(linker, "/export:??_7CEScanner@@6BFilter@ScanList@@@=_off_639CAC0,@999")
#pragma comment(linker, "/export:??_7CEShield@@6B@=_off_639D50C,@1000")
#pragma comment(linker, "/export:??_7CEShieldGenerator@@6B@=_off_639D5A4,@1001")
#pragma comment(linker, "/export:??_7CEThruster@@6BCAttachedEquip@@@=_off_639D744,@1002")
#pragma comment(linker, "/export:??_7CEThruster@@6BCPhysControllerEquip@@@=_off_639D710,@1003")
#pragma comment(linker, "/export:??_7CETractor@@6B@=_off_639D8C4,@1004")
#pragma comment(linker, "/export:??_7CETradeLaneEquip@@6B@=_off_639CB8C,@1005")
#pragma comment(linker, "/export:??_7CEqObj@@6B@=_off_639BE5C,@1006")
#pragma comment(linker, "/export:??_7CEquip@@6B@=_off_639BDCC,@1007")
#pragma comment(linker, "/export:??_7CEquipmentObj@@6B@=_off_639C704,@1008")
#pragma comment(linker, "/export:??_7CExternalEquip@@6B@=_off_639C49C,@1009")
#pragma comment(linker, "/export:??_7CGuided@@6B@=_off_639BC6C,@1010")


    // --- If doesnt exist, try creating
    gqlWalletCreate(addressString)
      .then((walletAddress) => {
        set({ isWalletConnected: true, walletAddress });
        localStorage.setItem(LOCAL_STORAGE_KEY_WALLET, walletAddress);
      })
      .catch(() => {
        set({ isWalletConnected: false, walletAddress: undefined })
        localStorage.removeItem(LOCAL_STORAGE_KEY_WALLET);
      });
  },
  disconnectWallet: () => {
    set({
      isWalletConnected: false,
      walletAddress: undefined,
      walletBalanceADA: undefined,
      walletBalanceAssets: {},
      walletUtxos: [],
    });
    localStorage.removeItem(LOCAL_STORAGE_KEY_WALLET);
  },
  // ACTIONS
  fundWallet: async (quantity) => {
    try {
      // --- Validate
      if (!get().walletAddress) throw new Error ("No connected wallet");
      if (!quantity) throw new Error("Missing ADA quantity");
      if (Number(quantity) <= 0) throw new Error("ADA quantity can't be negative");
      // --- gQL
      await gqlWalletFund(get().walletAddress!, quantity);
      toast.success(`Funding wallet ${Number(quantity) / 1_000_000} ADA`, toastConfig);
    } catch ( e ) {
      console.error(`failed to fund wallet: ${e}`);
      toast.error(`Failed funding wallet ${Number(quantity) / 1_000_000} ADA`, toastConfig);
      throw e;
    }
  },
  mintAsset: async (name, quantity) => {
    try {
      // --- Validate
      if (!get().walletAddress) throw new Error ("No connected wallet");
      if (!name) throw new Error("Missing asset name");
      if (!quantity) throw new Error("Missing asset quantity");
      if (Number(quantity) <= 0) throw new Error("Asset quantity can't be negative");
      // --- gQL
      await gqlMintAsset(name, quantity, get().walletAddress!);
      toast.success(`Minting ${quantity} ${name}`, toastConfig);
    } catch ( e ) {
      console.error(`failed to mint asset: ${e}`);
      toast.error(`Failed minting ${quantity} ${name}`, toastConfig);
      throw e;
    }
  },
  refreshUtxos: () => {
    if (!get().walletAddress) {
      set({ walletBalanceADA: undefined, walletBalanceAssets: {} });
      return console.error("No connected wallet");
    }
    gqlGetUtxos({ address: get().walletAddress!, excludeScripts: true }).then((walletUtxos) => {
      set({
        walletBalanceADA: walletUtxos
          .filter((utxo) => utxo.tokens.length === 0)
          .reduce((total, utxo) => total + Number(utxo.value!), 0),
        walletBalanceAssets: walletUtxos
          .map((utxo) => utxo.tokens)
          .flat()
          .reduce((acc, token) => {
            const prevSum = acc[token.asset.assetId];
            return {
              ...acc,
              [token.asset.assetId]: prevSum
                ? Number(prevSum) + Number(token.quantity)
                : Number(token.quantity)
            };
          }, {} as TUseWalletStore["walletBalanceAssets"]),
        walletUtxos,
      })
    });
  }
}));
///<reference path="../../typings/node/node.d.ts"/>

import {BusDevice, Broker}  from "./Bus";
import {Topic, Message, ValueMessage, Value} from "./messages";

class Source extends BusDevice {

    value: Value;
    topic: Topic;
    cnt: numb


sr TTBR0_EL12, x0          // encoding: [0x00,0x20,0x1d,0xd5]
// CHECK:   msr TTBR1_EL12, x0          // encoding: [0x20,0x20,0x1d,0xd5]
// CHECK:   msr TCR_EL12, x0            // encoding: [0x40,0x20,0x1d,0xd5]
// CHECK:   msr AFSR0_EL12, x0          // encoding: [0x00,0x51,0x1d,0xd5]
// CHECK:   msr AFSR1_EL12, x0          // encoding: [0x20,0x51,0x1d,0xd5]
// CHECK:   msr ESR_EL12, x0            // encoding: [0x00,0x52,0x1d,0xd5]
// CHECK:   msr FAR_EL12, x0            // encoding: [0x00,0x60,0x1d,0xd5]
// CHECK:   msr MAIR_EL12, x0           // encoding: [0x00,0xa2,0x1d,0xd5]
// CHECK:   msr AMAIR_EL12, x0          // encoding: [0x00,0xa3,0x1d,0xd5]
// CHECK:   msr VBAR_EL12, x0           // encoding: [0x00,0xc0,0x1d,0xd5]
// CHECK:   msr CONTEXTIDR_EL12, x0     // encoding: [0x20,0xd0,0x1d,0xd5]
// CHECK:   msr CNTKCTL_EL12, x0        // encoding: [0x00,0xe1,0x1d,0xd5]
// CHECK:   msr CNTP_TVAL_EL02, x0      // encoding: [0x00,0xe2,0x1d,0xd5]
// CHECK:   msr CNTP_CTL_EL02, x0       // encoding: [0x20,0xe2,0x1d,0xd5]
// CHECK:   msr CNTP_CVAL_EL02, x0      // encoding: [0x40,0xe2,0x1d,0xd5]
// CHECK:   msr CNTV_TVAL_EL02, x0      // encoding: [0x00,0xe3,0x1d,0xd5]
// CHECK:   msr CNTV_CTL_EL02, x0       // encoding: [0x20,0xe3,0x1d,0xd5]
// CHECK:   msr CNTV_CVAL_EL02, x0      // encoding: [0x40,0xe3,0x1d,0xd5]
// CHECK:   msr SPSR_EL12, x0           // encoding: [0x00,0x40,0x1d,0xd5]
// CHECK:   msr ELR_EL12, x0            // encoding: [0x20,0x40,0x1d,0xd5]


Version, removeProperty, setComment, setEnabled, setName, setProperty, setProperty, setProperty, setProperty, setProperty, setProperty, setProperty, setProperty, setProperty, setRunningVersion, setTemporary, setThreadContext, setThreadName, traverse

Field Detail

IGNORE_SUB_CONTROLLERS

public static final int IGNORE_SUB_CONTROLLERS

See Also:
<A HREF="../../../../constant-values.


/*--------------------------------------------------------------------*/
/*--- Support for doing system calls.        syscall-ppc64-linux.S ---*/
/*--------------------------------------------------------------------*/

/*
  This file is part of Valgrind, a dynamic binary instrumentation
  framework.

  Copyright (C) 2005-2017 Paul Mackerras <paulus@samba.org>

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of the
  License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, see <http://www.gnu.org/licenses/>.

  The GNU General Public License is contained in the file COPYING.
*/

#include "pub_core_basics_asm.h"

#if defined(VGP_ppc64be_linux)

#include "pub_core_vkiscnums_asm.h"
#include "libvex_guest_offsets.h"

/*----------------------------------------------------------------*/
/*
        Perform a syscall for the client.  This will run a syscall
        with the client's specific per-thread signal mask.

        The structure of this function is such that, if the syscall is
        interrupted by a signal, we can determine exactly what
        execution state we were in with respect to the execution of
        the syscall by examining the value of NIP in the signal
        handler.  This means that we can always do the appropriate
        thing to precisely emulate the kernel's signal/syscall
        interactions.

        The syscall number is taken from the argument, even though it
        should also be in regs->m_gpr[0].  The syscall result is written
        back to regs->m_gpr[3]/m_xer/m_result on completion.

        Returns 0 if the syscall was successfully called (even if the
        syscall itself failed), or a nonzero error code in the lowest
	8 bits if one of the sigprocmasks failed (there's no way to
	determine which one failed).  And there's no obvious way to
	recover from that either, but nevertheless we want to know.

        VG_(fixup_guest_state_after_syscall_interrupted) does the
	thread state fixup in the case where we were interrupted by a
	signal.

        Prototype:

	UWord ML_(do_syscall_for_client_WRK)(
				  Int syscallno,		// r3
				  void* guest_state,		// r4
				  const vki_sigset_t *sysmask,	// r5
				  const vki_sigset_t *postmask,	// r6
				  Int sigsetSzB)		// r7
*/
/* from vki_arch.h */
#define VKI_SIG_SETMASK 2

.align 2
.globl ML_(do_syscall_for_client_WRK)
.section ".opd","aw"
.align 3
ML_(do_syscall_for_client_WRK):
.quad .ML_(do_syscall_for_client_WRK),.TOC.@tocbase,0
.previous
.type .ML_(do_syscall_for_client_WRK),@function
.globl .ML_(d


=None}}{{reference=PHB p228}}SpellData=[w:Liveoak,lv:6,sp:100,gp:0,cs:VSM,sph:Plant]{{effects=Charm a healthy oak tree (or other type if the DM allows) to cause it to serve as a protector.}}'},
						{name:'Locate-Animals-or-Plants',type:'prspelll1',ct:'10',charge:'uncharged',cost:'0',body:'\\amp{template:'+fields.spellTemplate+'}{{title=@{selected|Casting-name} casts\nLocate Animals or Plants\nas a level @{selected|pr-casting-level} caster}}{{splevel=Level 1 Priest}}{{school=Divination}}{{sphere=Divination(Animal,Plant)}}Specs=[Locate-Animals-or-Plants,PRspellL1,1H,Divination]{{components=V,S,M}}{{time=[[1]] round}}{{range=[[100+(20*@{selected|pr-casting-level})]] yards}}{{duration=[[@{selected|pr-casting-level}]] rounds}}{{aoe=[[[20*@{selected|pr-casting-level}]] x 20 yds long](!rounds --aoe @{selected|token_id}|bolt|yards|[[100+20*@{selected|pr-casting-level}]]|[[20*@{selected|pr-casting-level}]]|20|magic)}}{{save=Negates}}{{reference=PHB p201}}SpellData=[w:Locate-Animals-or-Plants,lv:1,sp:10,gp:0,cs:VSM,sph:Animal|Plant]{{effects=Find direction \\amp distance of any one type of animal or plant desired.}}{{hide1=The caster, facing in a direction, thinks of the animal or plant, and then knows if any such animal or plant is within range. If so, the exact distance and approximate number present is learned. During each round of the spell\'s duration, the caster can face in only one direction (i.e., only a 20-foot-wide path can be known). The spell lasts one round per level of experience of the caster, while the length of the path is 100 yards plus 20 yards per level of experience. (At the DM\'s option, some casters may be able to locate only those animals [or plants] associated closely with their own mythos.)\nWhile the exact chance of locating a specific type of animal or plant depends on the details and circumstances of the locale, the general frequency of the subject can be used as a guideline: common = 50%, uncommon = 30%, rare = 15%, and very rare = 5%. Most herbs grow in temperate regions, while most spices grow in tropical regions. Most plants sought as spell components or for magical research are rare or very rare. The results of this spell are always determined by the DM.}}{{materials=The caster\'s holy symbol}}'},
						{name:'Locate-Object',type:'prspelll3',ct:'100',charge:'uncharged',cost:'0.1',body:'\\amp{template:'+fields.spellTemplate+'}{{title=@{selected|Casting-name} casts\nLocate Object\nas a level @{selected|pr-casting-level} caster}}{{splevel=Level 3 Priest (reversable)}}{{school=Divination}}{{sphere=Divination}}Specs=[Locate-Object,PRspellL3,1H,Divination]{{components=V,S,M}}{{time=[[1]] turn}}{{range=[[[60+(10*@{selected|pr-casting-level})]] yards](!rounds --aoe @{selected|token_id}|circle|yards|0|[[60+(10*@{selected|pr-casting-level})]]||magic|true)}}{{duration=[[8]] hours}}{{aoe=[[1]] object}}{{save=None}}{{reference=PHB p211}}SpellData=[w:,lv:3,sp:100,gp:0.1,cs:VSM,sph:Divination]{{effects=Helps locate a known or familiar object by casting the spell, slowly turning, and will then sense when they are facing in the direction of the object to be located, provided the object is within range.}}{{hide1=For example,


i++) {
		const char *kextname = NULL;
		const char *funcname = NULL;

		struct range_tree_entry key = { .base = bt[i], .size = 0 };
		struct range_tree_entry *e = RB_FIND(range_tree, &range_tree_root, &key);

		if (!e) {
			/* no match at this address - kinda weird? */
			continue;
		}

		/* get the function and bundle name for the current frame */
		funcname = addr_to_func(bt[i], e->mh);
		if (e->bundleid) {
			kextname = strrchr(e->bundleid, '.');
			if (kextname) {
				kextname++;
			} else {
				kextname = e->bundleid;
			}
		}

		// printf("%s: a = 0x%016lx,0x%016lx f = %s, k = %s\n", __func__, bt[i], VM_KERNEL_UNSLIDE(bt[i]), funcname, kextname);

		/* check if kextname or funcname are in the blacklist */
		for (size_t j = 0; j < blacklist_entries; j++) {
			struct blacklist_entry *ble = &blacklist[j];
			uint64_t count;

			if ((ble->type_mask & type) != type) {
				/* wrong type */
				continue;
			}

			if (ble->kext_name && kextname && strncmp(kextname, ble->kext_name, KMOD_MAX_NAME) != 0) {
				/* wrong kext name */
				continue;
			}

			if (ble->func_name && funcname && strncmp(funcname, ble->func_name, 128) != 0) {
				/* wrong func name */
				continue;
			}

			/* found a matching function or kext */
			blhe = blacklist_hash_add(bt[i], ble);
			count = ble->count++;
			e->accessed = 1;

			dybl_unlock(flag);

			if (count == 0) {
				printf("KASan: ignoring blacklisted violation (%s:%s [0x%lx] %d 0x%x)\n",
				    kextname, funcname, VM_KERNEL_UNSLIDE(bt[i]), i, type);
			}

			return true;
		}
	}

	dybl_unlock(flag);
	return false;
}

static void
add_blacklist_entry(const char *kext, const char *func, access_t type)
{
	assert(kext || func);
	struct blacklist_entry *ble = &blacklist[blacklist_entries++];

	if (blacklist_entries > blacklist_max_entries) {
		panic("KASan: dynamic blacklist entries exhausted\n");
	}

	if (kext) {
		size_t sz = __nosan_strlen(kext) + 1;
		if (sz > 1) {
			char *s = zalloc_permanent(sz, ZALIGN_NONE);
			__nosan_strlcpy(s, kext, sz);
			ble->kext_name = s;
		}
	}

	if (func) {
		size_t sz = __nosan_strlen(func) + 1;
		if (sz > 1) {
			char *s = zalloc_permanent(sz, ZALIGN_NONE);
			__nosan_strlcpy(s, func, sz);
			ble->func_name = s;
		}
	}

	ble->type_mask = type;
}

#define TS(x) { .type = TYPE_##x, .str = #x }

static const struct {
	const access_t type;
	const char * const str;
} typemap[] = {
	TS(LOAD),
	TS(STORE),
	TS(MEMR),
	TS(MEMW),
	TS(STRR),
	TS(STRW),
	TS(KFREE),
	TS(ZFREE),
	TS(FSFREE),
	TS(UAF),
	TS(POISON_GLOBAL),
	TS(POISON_HEAP),
	TS(MEM),
	TS(STR),
	TS(READ),
	TS(WRITE),
	TS(RW),
	TS(FREE),
	TS(NORMAL),
	TS(DYNAMIC),
	TS(POISON),
	TS(ALL),

	/* convenience aliases */
	{ .type = TYPE_POISON_GLOBAL, .str = "GLOB" },
	{ .type = TYPE_POISON_HEAP, .str = "HEAP" },
};
static size_t typemap_sz = sizeof(typemap) / sizeof(typemap[0]);

static inline access_t
map_type(const char *str)
{
	if (strlen(str) == 0) {
		return TYPE_NORMAL;
	}

	/* convert type string to integer ID */
	for (size_t i = 0; i < typemap_sz; i++) {
		if (strcasecmp(str, typemap[i].str) == 0) {
			return typemap[i].type;
		}
	}

	printf("KASan: unknown blacklist type `%s', assuming `normal'\n", str);
	return TYPE_NORMAL;
}

void
kasan_init_dybl(void)
{
	simple_lock_init(&_dybl_lock, 0);

	/*
	 * dynamic blacklist entries via boot-arg. Syntax is:
	 *  kasan.bl=kext1:func1:type1,kext2:func2:type2,...
	 */
	char buf[256] = {};
	char *bufp = buf;
	if (PE_parse_boot_arg_str("kasan.bl", bufp, sizeof(buf))) {
		char *kext;
		while ((kext = strsep(&bufp, ",")) != NULL) {
			access_t type = TYPE_NORMAL;
			char *func = strchr(kext, ':');
			if (func) {
				*func++ = 0;
			}
			char *typestr = strchr(func, ':');
			if (typestr) {
				*typestr++ = 0;
				type = map_type(typestr);
			}
			add_blacklist_entry(kext, func, type);
		}
	}

	/* collect bitmask of blacklisted types */
	for (size_t j = 0; j < blacklist_entries; j++) {
		struct blacklist_entry *ble = &blacklist[j];
		blacklisted_types |= ble->type_mask;
	}

	/* add the fake kernel kext */
	kasan_dybl_load_kext((uintptr_t)&_mh_execute_header, "__kernel__");
}

#else /* KASAN_DYNAMIC_BLACKLIST */

bool
kasan_is_blacklisted(access_t __unused type)
{
	return false;
}
#endif


nzdec    $NUM_PART, _start_num_partials_loop_1_rem.\@

// ************************************************* //
// end of 1 vector accumulating, scale and store
// ************************************************* //
  {
    add $IN_j_DELTA, $IN_j_DELTA, 4
    f32v2gina  $VALUES_0:1, $azeros, 0
  }
  DO_SCALE_AND_UPDATE_FLOAT \UPDATE 1
  st32step   $VALUES_0, $mzero, $OUT_j_PTR+=, 1

_out_j_size_end.\@:
  // add num_partials to IN_i_ptr and store
  st32       $IN_i_PTR, $mworker_base, $mzero, IN_PTR_SCRATCH
  brnzdec    $OUT_i_SIZE, _loop_over_reductions.\@
// ************************************************* //
// End of loops
// ************************************************* //
_exit.\@:
  exitz      $mzero

FN_SIZE _Reduce_load_state\@
.endm

// -------------------------------------------------------- //
// -------------------------------------------------------- //
// Float Half
// -------------------------------------------------------- //
// -------------------------------------------------------- //
.macro INSTANTIATE_FLOAT_HALF UPDATE INSTRUCTION OP

.equ SIZE_OF_IN_TYPE, 4

// Instantiate two variants which call the same common function
// ************************************************* //
// Load vertex state
// ************************************************* //
#if defined(VECTOR_AVAIL_SCALED_PTR32) && defined(VECTORLIST_AVAIL_DELTAN)
FN_WORKER_ENTRY_POINT REDUCE_FLOAT_HALF(Reduce,DEFAULT)
FN_EXPORT REDUCE_FLOAT_HALF(Reduce,SCALAR___OUTPUT___REGIONS)
#else
FN_WORKER_ENTRY_POINT REDUCE_FLOAT_HALF(Reduce,DEFAULT)
  setzi      $SCRATCH, _Reduce_outer_loop_setup_out_align64
  bri        1f

FN_EXPORT REDUCE_FLOAT_HALF(Reduce,SCALAR___OUTPUT___REGIONS)
  setzi      $SCRATCH, _Reduce_outer_loop_setup_out_align32

1:
  st32       $SCRATCH, $mworker_base, $mzero, FN_REDUCE_OUTER_LOOP_SCRATCH
#endif
{
  bri        _Reduce_load_state\@
  or         $SCALE, $azero, FLOAT_1_0
}
FN_SIZE REDUCE_FLOAT_HALF(Reduce,DEFAULT)

#if defined(VECTOR_AVAIL_SCALED_PTR32) && defined(VECTORLIST_AVAIL_DELTAN)
FN_WORKER_ENTRY_POINT REDUCE_FLOAT_HALF(ScaledReduce,DEFAULT)
FN_EXPORT REDUCE_FLOAT_HALF(ScaledReduce,SCALAR___OUTPUT___REGIONS)
  ldz16      $SCRATCH, $mvertex_base, $mzero, SCALE_OFF/2
  setzi      $SCRATCH2, TMEM_REGION0_BASE_ADDR
  ld32       $SCALE, $SCRATCH2, $mzero, $SCRATCH
#else
FN_WORKER_ENTRY_POINT REDUCE_FLOAT_HALF(ScaledReduce,DEFAULT)
  setzi      $SCRATCH, _Reduce_outer_loop_setup_out_align64
  bri        1f

FN_EXPORT REDUCE_FLOAT_HALF(ScaledReduce,SCALAR___OUTPUT___REGIONS)
  setzi      $SCRATCH, _Reduce_outer_loop_setup_out_align32

1:
  st32       $SCRATCH, $mworker_base, $mzero, FN_REDUCE_OUTER_LOOP_SCRATCH
  ld32       $SCRATCH, $mvertex_base, $mzero, SCALE_OFF/4
  ld3


or (int i = 0; i < initialSamples; i++) {
            IVector parameter = priorSampler.sample();
            IVector simulatedData = simulator.simulate(parameter);
            IVector simulatedSummary = summaryStats.calculate(simulatedData);
            double distance = distanceFunction.distance(observedSummary, simulatedSummary);
            allSamples.add(new ABCSample(parameter, simulatedSummary, distance));
        }

        // 估计自适应阈值
        List<Double> distances = new ArrayList<>();
        for (ABCSample sample : allSamples) {
            distances.add(sample.getDistance());
        }
        Collections.sort(distances);

        int targetIndex = (int) (targetAcceptanceRate * distances.size());
        double adaptiveThreshold = distances.get(Math.min(targetIndex, distances.size() - 1));

        // 继续采样直到达到目标样本数
        int totalSimulations = initialSamples;
        while (totalSimulations < maxSimulations) {
            IVector parameter = priorSampler.sample();
            IVector simulatedData = simulator.simulate(parameter);
            IVector simulatedSummary = summaryStats.calculate(simulatedData);
            double distance = distanceFunction.distance(observedSummary, simulatedSummary);

            allSamples.add(new ABCSample(parameter, simulatedSummary, distance));
            totalSimulations++;

            // 定期更新阈值
            if (totalSimulations % 100 == 0) {
                distances.clear();
                for (ABCSample sample : allSamples) {
                    distances.add(sample.getDistance());
                }
                Collections.sort(distances);
                targetIndex = (int) (targetAcceptanceRate * distances.size());
                adaptiveThreshold = distances.get(Math.min(targetIndex, distances.size() - 1));
            }
        }

        // 筛选接受的样本
        List<ABCSample> acceptedSamples = new ArrayList<>();
        for (ABCSample sample : allSamples) {
            if (sample.getDistance() <= adaptiveThreshold) {
                acceptedSamples.add(sample);
            }
        }

        // 如果样本太多，随机选择
        if (acceptedSamples.size() > numSamples) {
            Collections.shuffle(acceptedSamples, random);
            acceptedSamples = acceptedSamples.subList(0, numSamples);
        }

        IVector posteriorMean = calculatePosteriorMean(acceptedSamples);
        IVector posteriorVariance = calculatePosteriorVariance(acceptedSamples, posteriorMean);
        double acceptanceRate = (double) acceptedSamples.size() / totalSimulations;

        return new ABCResult(acceptedSamples, posteriorMean, posteriorVariance,
                           acceptanceRate, adaptiveThreshold, totalSimulations);
    }

    /**
     * 更新权重
     * Update weights
     */
    private void updateWeights(List<ABCSample> particles, double threshold) {
        for (ABCSample particle : particles) {
            if (particle.getDistance() <= threshold) {
                // 简单的核权重：距离越小权重越大
                double weight = Math.exp(-particle.getDistance() / threshold);
                particle.setWeight(weight);
            } else {
                particle.setWeight(0.0);
            }
        }

        // 归一化权重
        double totalWeight = 0.0;
        for (ABCSample particle : particles) {
            totalWeight += particle.getWeight();
        }

        if (totalWeight > 0) {
            for (ABCSample particle : particles) {
                particle.setWeight(particle.getWeight() / totalWeight);
            }
        }
    }

    /**
     * 重采样粒子
     * Resample particles
     */
    private List<ABCSample> resampleParticles(List<ABCSample> particles, int numParticles) {
        List<ABCSample> resampledParticles = new ArrayList<>();

        // 计算累积权重
        double[] cumulativeWeights = new double[particles.size()];
        cumulativeWeights[0] = particles.get(0).getWeight();


3RhdHVzQ29kZQ== 77637
IE1veQ== 77638
TGlzdEFkYXB0ZXI= 77639
ICg/KQ== 77640
R2VuZXJhbGx5 77641
LmlzQ29ubmVjdGVk 77642
dmlkbw== 77643
TW91c2VCdXR0b24= 77644
R2VuZXJhdGlvblN0cmF0ZWd5 77645
X2Rlcml2 77646
IGxla2tlcg== 77647
TWVhc3VyZW1lbnQ= 77648
X0NPT0tJRQ== 77649
ICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq 77650
IGNvbXBldGl0aXZlbmVzcw== 77651
IGdhbWxl 77652
IHJldHJvc3BlY3Q= 77653
IEVkdWFyZG8= 77654
IERhdGFTZXJ2aWNl 77655
IGVzY29ydGVk 77656
IFF0eQ== 77657
SG9saWRheQ== 77658
CXJhdw== 77659
bGV1cnM= 77660
QmlydGhkYXk= 77661
IGhlYXRz 77662
LmludmVyc2U= 77663
IF8NCg== 77664
aWxsdW0= 77665
b2thYmxlQ2FsbA== 77666
X21s 77667
TGlrZWQ= 77668
ZW51bWVyYXRl 77669
RmluaXRl 77670
LXByb3A= 77671
QXJlYVZpZXc= 77672
IG1lZGlhdGlvbg== 77673
IGNoYW50aW5n 77674
X05U 77675
X3VuYw== 77676
c21vdXRo 77677
IHBpZ21lbnQ= 77678
UGFzc3dvcmRFbmNvZGVy 77679
IHbDqXI= 77680
IHdhc3Rld2F0ZXI= 77681
LVBhY2s= 77682
IGpvdmVu 77683
YWVz 77684
S1k= 77685
UGludGVyZXN0 77686
IG11c2ljYQ== 77687
bGFjZXM= 77688
IFdpY2g= 77689
KHJvdA== 77690
KGly 77691
IOyCreygnA== 77692
44Gd44KM 77693
X1RIRQ== 77694
Z2V0RmlsZQ== 77695
W3Byb3BlcnR5 77696
IGVuZGluZ3M= 77697
aXp6YXJl 77698
PXRyYWlu 77699
LWxvdmluZw== 77700
IG5vdXZl 77701
IGNvbW1hcw== 77702
IGNhbWJp 77703
IFp1c2FtbWVu 77704
CUV4dA== 77705
KG9ic2VydmVy 77706
Zm9ybWlr 77707
IHF1aW5kaQ== 77708
IEl2b3J5 77709
IEJvbGl2aWE= 77710
YXNhZA== 77711
X2xlZ2VuZA== 77712
Q2l0aWVz 77713
X0ZJUkU= 77714
YXNkZg== 77715
LkRlcHRo 77716
VmFsdWVHZW5lcmF0aW9uU3RyYXRlZ3k= 77717
dXBk 77718
LkdldFJlc3BvbnNl 77719
IHVyZ2VudGx5 77720
SW52YXJpYW50 77721
R2V0WA== 7


test_case("environ", new_vec(vec!["FOO=BAR"]), ElfProgramConfig { environ: Some(vec!["FOO=BAR".into()]), ..Default::default()} ; "when_environ_has_values")]
    #[test_case("lifecycle.stop_event", new_string("notify"), ElfProgramConfig { notify_lifecycle_stop: true, ..Default::default()} ; "when_stop_event_notify")]
    #[test_case("lifecycle.stop_event", new_string("ignore"), ElfProgramConfig { notify_lifecycle_stop: false, ..Default::default()} ; "when_stop_event_ignore")]
    #[test_case("main_process_critical", new_string("true"), ElfProgramConfig { main_process_critical: true, ..Default::default()} ; "when_main_process_critical_true")]
    #[test_case("main_process_critical", new_string("false"), ElfProgramConfig { main_process_critical: false, ..Default::default()} ; "when_main_process_critical_false")]
    #[test_case("job_policy_ambient_mark_vmo_exec", new_string("true"), ElfProgramConfig { ambient_mark_vmo_exec: true, ..Default::default()} ; "when_ambient_mark_vmo_exec_true")]
    #[test_case("job_policy_ambient_mark_vmo_exec", new_string("false"), ElfProgramConfig { ambient_mark_vmo_exec: false, ..Default::default()} ; "when_ambient_mark_vmo_exec_false")]
    #[test_case("job_policy_create_raw_processes", new_string("true"), ElfProgramConfig { create_raw_processes: true, ..Default::default()} ; "when_create_raw_processes_true")]
    #[test_case("job_policy_create_raw_processes", new_string("false"), ElfProgramConfig { create_raw_processes: false, ..Default::default()} ; "when_create_raw_processes_false")]
    #[test_case("use_next_vdso", new_string("true"), ElfProgramConfig { use_next_vdso: true, ..Default::default()} ; "use_next_vdso_true")]
    #[test_case("use_next_vdso", new_string("false"), ElfProgramConfig { use_next_vdso: false, ..Default::default()} ; "use_next_vdso_false")]
    fn test_parse_and_check_with_permissive_policy(
        key: &str,
        value: fdata::DictionaryValue,
        expected: ElfProgramConfig,
    ) {
        let checker = ScopedPolicyChecker::new(
            Arc::downgrade(&(*PERMISSIVE_RUNTIME_CONFIG)),
            TEST_MONIKER.clone(),
        );
        let program = new_program_stanza(key, value);

        let actual = ElfProgramConfig::parse_and_check(&program, &checker, TEST_URL).unwrap();

        assert_eq!(actual, expected);
    }

    #[test_case("job_policy_ambient_mark_vmo_exec", new_string("true") , "ambient_mark_vmo_exec" ; "when_ambient_mark_vmo_exec_true")]
    #[test_case("main_process_critical", new_string("true"), "main_process_critical" ; "when_main_process_critical_true")]
    #[test_case("job_policy_create_raw_processes", new_string("true"), "create_raw_processes" ; "when_create_raw_processes_true")]
    fn test_parse_and_check_with_restrictive_policy(
        key: &str,
        value: fdata::DictionaryValue,
        policy: &str,
    ) {
        let checker = ScopedPolicyChecker::new(
            Arc::downgrade(&(*RESTRICTIVE_RUNTIME_CONFIG)),
            TEST_MONIKER.clone(),
        );
        let program = new_pr


lists the backslash sequences that are
handled specially, along with the value that replaces each sequence.

\a

Audible alert (bell) (0x7).

\b

Backspace (0x8).

\f

Form feed (0xc).

\n

Newline (0xa).

\r

Carriage-return (0xd).

\t

Tab (0x9).

\v

Vertical tab (0xb).

\<newline>whiteSpace

A single space character replaces the backslash, newline, and all spaces
and tabs after the newline.  This backslash sequence is unique in that it
is replaced in a separate pre-pass before the command is actually parsed.
This means that it will be replaced even when it occurs between braces,
and the resulting space will be treated as a word separator if it isn't
in braces or quotes.

\\

Backslash (``\'').

\ooo

The digits ooo (one, two, or three of them) give an eight-bit octal
value for the Unicode character that will be inserted.  The upper bits of the
Unicode character will be 0.

\xhh

The hexadecimal digits hh give an eight-bit hexadecimal value for the
Unicode character that will be inserted.  Any number of hexadecimal digits
may be present; however, all but the last two are ignored (the result is
always a one-byte quantity).  The upper bits of the Unicode character will
be 0.

\uhhhh

The hexadecimal digits hhhh (one, two, three, or four of them) give a
sixteen-bit hexadecimal value for the Unicode character that will be
inserted.

Backslash substitution is not performed on words enclosed in braces,
except for backslash-newline as described above.

[9] Comments.

If a hash character (``#'') appears at a point where Tcl is
expecting the first character of the first word of a command,
then the hash character and the characters that follow it, up
through the next newline, are treated as a comment and ignored.
The comment character only has significance when it appears
at the beginning of a command.

[10] Order of substitution.

Each character is processed exactly once by the Tcl interpreter
as part of creating the words of a command.
For example, if variable substitution occurs then no further
substitutions are performed on the value of the variable;  the
value is inserted into the word verbatim.
If command substitution occurs then the nested command is
processed entirely by the recursive call to the Tcl interpreter;
no substitutions are performed before making the recursive
call and no additional substitutions are performed on the result
of the nested script.

Substitutions take place from left to right, and each substitution is
evaluated completely before attempting to evaluate the next.  Thus, a
sequence like

set y [set x 0][incr x][incr x]

will always set the


# Copyright 2020 Chris Cummins <chrisc.101@gmail.com>.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Unit tests for //tools/format/formatters:bazel."""
from labm8.py import test
from tools.format.formatters import bazel

FLAGS = test.FLAGS

def test_small_build_file():
  text = bazel.FormatBuild.Format(
    """
py_binary(
name = "foo",
srcs = ["foo.py"],
deps = [":b", ":a", "//third_party/foo",]
)
"""
  )
  print(text)
  assert (
    text
    == """\
py_binary(
    name = "foo",
    srcs = ["foo.py"],
    deps = [":b", ":a", "//third_party/foo"],
)
"""
  )

def test_build_file_without_trailing_newline():
  text = bazel.FormatBuild.Format(
    """cc_binary(
  name = "foo"    , srcs = ["foo.cc"])"""
  )
  print(text)
  assert (
    text
    == """\
cc_binary(
    name = "foo",
    srcs = ["foo.cc"],
)
"""
  )

if __name__ == "__main__":
  test.Main()


      <path d='M9 5a1 1 0 0 1 1 -1h2a1 1 0 0 1 1 1v4' />
      <path d='M13 13v6a1 1 0 0 1 -1 1h-2a1 1 0 0 1 -1 -1v-10' />
      <path d='M5 8h3' />
      <path d='M9 16h4' />
      <path d='M14.254 10.244l-1.218 -4.424a1.02 1.02 0 0 1 .634 -1.219l.133 -.041l2.184 -.53c.562 -.135 1.133 .19 1.282 .732l3.236 11.75' />
      <path d='M19.585 19.589l-1.572 .38c-.562 .136 -1.133 -.19 -1.282 -.731l-.952 -3.458' />
      <path d='M14 9l4 -1' />
      <path d='M19.207 15.199l.716 -.18' />
      <path d='M3 3l18 18' />
    </svg>
  );
}
import React from 'react';

export default function LivePhoto({
  size = 24,
  color = 'currentColor',
  ...restProps
}) {
  return (
    <svg
      xmlns='http://www.w3.org/2000/svg'
      className='icon icon-tabler icon-tabler-live-photo'
      width={size}
      height={size}
      viewBox='0 0 24 24'
      stroke={color}
      strokeWidth='2'
      fill='none'
      strokeLinecap='round'
      strokeLinejoin='round'
      {...restProps}
    >
      <path stroke='none' d='M0 0h24v24H0z' fill='none' />
      <circle cx='12' cy='12' r='1' />
      <circle cx='12' cy='12' r='5' />
      <line x1='15.9' y1='20.11' x2='15.9' y2='20.12' />
      <line x1='19.04' y1='17.61' x2='19.04' y2='17.62' />
      <line x1='20.77' y1='14' x2='20.77' y2='14.01' />
      <line x1='20.77' y1='10' x2='20.77' y2='10.01' />
      <line x1='19.04' y1='6.39' x2='19.04' y2='6.4' />
      <line x1='15.9' y1='3.89' x2='15.9' y2='3.9' />
      <line x1='12' y1='3' x2='12' y2='3.01' />
      <line x1='8.1' y1='3.89' x2='8.1' y2='3.9' />
      <line x1='4.96' y1='6.39' x2='4.96' y2='6.4' />
      <line x1='3.23' y1='10' x2='3.23' y2='10.01' />
      <line x1='3.23' y1='14' x2='3.23' y2='14.01' />
      <line x1='4.96' y1='17.61' x2='4.96' y2='17.62' />
      <line x1='8.1' y1='20.11' x2='8.1' y2='20.12' />
      <line x1='12' y1='21' x2='12' y2='21.01' />
    </svg>
  );
}
import React from 'react';

export default function BorderHorizontal({
  size = 24,
  color = 'currentColor',
  ...restProps
}) {
  return (
    <svg
      xmlns='http://www.w3.org/2000/svg'
      className='icon


= (state, payload) => {
  return Object.assign({}, state, {
    loading: false
  });
};

reducers[UserActionTypes.GET_USER_BASIC_DATA_SUCCESS] = (state, payload) => {
  return Object.assign({}, state, {
    user: payload,
    loading: false
  });
};

reducers[UserActionTypes.GET_USER_COMPANIONS_SUCCESS] = (state, payload) => {
  return Object.assign({}, state, {
    user: Object.assign({}, state.user, {
      companions: payload.companions
    })
  });
};

reducers[ActionTypes.LOGOUT_SUCCESS] = (state, payload) => {
  return Object.assign({}, state, {
    user: {},
    loading: false
  });
};

export default function reducer(state = initialState, action: Actions) {
  return reducers[action.type] && reducers[action.type](state, action.payload) || state;
};
import { NUM_GYOU, NUM_RETU } from "./Constant";
import { Field } from "./Field";
import { CellLocation, PuzzleBlock } from "./PuzzleBlock";

export type FallingBlock = {
    puzzleBlock: PuzzleBlock,
    location: CellLocation,
    rotation: number
}

export function fall(fallingBlock: FallingBlock): FallingBlock {
    return {
        puzzleBlock: fallingBlock.puzzleBlock,
        rotation   : fallingBlock.rotation,
        location   : [ fallingBlock.location[0] + 1, fallingBlock.location[1] ]
    }
}

export function goRight(fallingBlock: FallingBlock): FallingBlock {
    return {
        puzzleBlock: fallingBlock.puzzleBlock,
        rotation   : fallingBlock.rotation,
        location   : [ fallingBlock.location[0], fallingBlock.location[1] + 1]
    }
}

export function goLeft(fallingBlock: FallingBlock): FallingBlock {
    return {
        puzzleBlock: fallingBlock.puzzleBlock,
        rotation   : fallingBlock.rotation,
        location   : [ fallingBlock.location[0], fallingBlock.location[1] - 1]
    }
}

export function rotate(fallingBlock: FallingBlock): FallingBlock {
    return {
        puzzleBlock: fallingBlock.puzzleBlock,
        rotation   : fallingBlock.rotation + 1,
        location   : fallingBlock.location
    }
}

export function isOk(fallingBlock: FallingBlock, field: Field): boolean {
    function isGyouOk(cell: CellLocation): boolean {
        return (0 <= cell[0]) && (cell[0] <= NUM_GYOU - 1)
    }

    function isRetuOk(cell: CellLocation): boolean {
        return (0 <= cell[1]) && (cell[1] <= NUM_RETU - 1)
    }

    function isFieldOk(cell: CellLocation): boolean {
        return field[cell[0]][cell[1]] === undefined
    }

    return [...fallingBlock.puzzleBlock.cells, [0, 0] as CellLocation ]
        .map((cell) => {
            let newLocation = [ cell[0], cell[1] ] as CellLocation
            for (let i = 0; i < fallingBlock.rotation; i++) {
                newLocation = [ -newLocation[1], newLocation[0] ]
            }
            return newLocation
        })
        .map((cell) => [
            cell[0] + fallingBlock.location[0],
            cell[1] + fallingBlock.location[1]
        ] as CellLocation)
        .reduce((acc: boolean, cell: CellLocation) => {
            return acc && isGyouOk(cell) && isRetuOk(cell) && isFieldOk(cell)
        }, true)
}/*!
 * Copyright 2023 Cognite AS


KR 75₃₃₅, SC 30₄₁₄, TC 96₅₈₁.
    '4x4f3t3a6k,'
    // #5753: 5 fonts: HK 100₁₂₇, JP 101₂₃₇, KR 76₃₃₆, SC 91₄₇₅, TC 96₅₈₁.
    '4x4f3u5i4b,'
    // #5754: 5 fonts: HK 100₁₂₇, JP 101₂₃₇, KR 81₃₄₁, SC 91₄₇₅, TC 96₅₈₁.
    '4x4f3z5d4b,'
    // #5755: 5 fonts: HK 100₁₂₇, JP 101₂₃₇, KR 84₃₄₄, SC 50₄₃₄, TC 96₅₈₁.
    '4x4f4c3l5q,'
    // #5756: 5 fonts: HK 100₁₂₇, JP 101₂₃₇, KR 87₃₄₇, SC 90₄₇₄, TC 96₅₈₁.
    '4x4f4f4w4c,'
    // #5757: 5 fonts: HK 100₁₂₇, JP 102₂₃₈, KR 69₃₂₉, SC 16₄₀₀, TC 96₅₈₁.
    '4x4g3m2s6y,'
    // #5758: 5 fonts: HK 100₁₂₇, JP 102₂₃₈, KR 70₃₃₀, SC 18₄₀₂, TC 96₅₈₁.
    '4x4g3n2t6w,'
    // #5759: 5 fonts: HK 100₁₂₇, JP 102₂₃₈, KR 81₃₄₁, SC 90₄₇₄, TC 96₅₈₁.
    '4x4g3y5c4c,'
    // #5760: 5 fonts: HK 100₁₂₇, JP 102₂₃₈, KR 86₃₄₆, SC 90₄₇₄, TC 96₅₈₁.
    '4x4g4d4x4c,'
    // #5761: 5 fonts: HK 100₁₂₇, JP 102₂₃₈, KR 87₃₄₇, SC 90₄₇₄, TC 96₅₈₁.
    '4x4g4e4w4c,'
    // #5762: 5 fonts: HK 100₁₂₇, JP 102₂₃₈, KR 89₃₄₉, SC 58₄₄₂, TC 96₅₈₁.
    '4x4g4g3o5i,'
    // #5763: 5 fonts: HK 100₁₂₇, JP 102₂₃₈, KR 89₃₄₉, SC 91₄₇₅, TC 96₅₈₁.
    '4x4g4g4v4b,'
    // #5764: 5 fonts: HK 100₁₂₇, JP 102₂₃₈, KR 92₃₅₂, SC 92₄₇₆, TC 96₅₈₁.
    '4x4g4j4t4a,'
    // #5765: 5 fonts: HK 100₁₂₇, JP 102₂₃₈, KR 93₃₅₃, SC 91₄₇₅, TC 96₅₈₁.
    '4x4g4k4r4b,'
    // #5766: 5 fonts: HK 100₁₂₇, JP 102₂₃₈, KR 93₃₅₃, SC 92₄₇₆, TC 96₅₈₁.
    '4x4g4k4s


-string">旧式の許可されたDOCTYPE文字列を含むDOCTYPEは<dfn id="obsolete-permitted-doctype">旧式の許可されたDOCTYPE</dfn>である。不必要に長くなるので、著者は旧式の許可されたDOCTYPEを使うべきでない。

8.1.2 要素

5つの異なる種類の<dfn data-anolis-xref="syntax-elements" id="syntax-elements">要素</dfn>が存在する。空要素、生テキスト要素、エスケープ可能な生テキスト要素、外来要素、通常要素。

<dfn id="void-elements">空要素</dfn>

area、base、br、col、embed、hr、img、input、keygen、link、meta、param、source、track、wbr

<dfn id="raw-text-elements">生テキスト要素</dfn>

script、style

<dfn id="escapable-raw


�结核？ |
| 竞争情报 | 对于一家咖啡店来说，如何获取并分析竞争对手的销售数据以制定更好的营销策略？ |
| 情感分析 | 如何利用自然语言处理技术来分析一段文本的情感色彩？ |
| 决策支持 | 在公司经营过程中，如何利用数据挖掘技术来协助决策制定？ |
| 计算机视觉 | 如何利用深度学习算法实现人脸识别功能？ |
| 自动化流程 | 如何通过编程实现某个重复性工作的自动化处理？ |
| 数据可视化 | 如何使用Python库matplotlib进行数据可视化展示？ |
| 产品推荐 | 如何基于用户行为数据实现精准的产品推荐功能？ |
| 网络安全 | 如何通过漏洞扫描工具来保障网络安全？ |
| 金融风险控制 | 如何利用机器学习算法来进行信贷风险评估和控制？ |
| 影视推荐               | 你能推荐一部类似于黑镜的科幻电影吗？                                                                                |
| 食品分类               | 红枣和枸杞属于什么类型的食物？                                                                                |
| 历史事件描述           | 能否简要描述一下二战中最著名的空袭事件：大轰炸（The Blitz）？                                                                                |
| 生活常识               | 如何快速有效地给电脑除尘？                                                                                |
| 编辑工具使用技巧       | Photoshop中如何利用调整图层来改变图片的色调？                                                                                |
| 科学知识               | 什么是黑洞？


", "true")
    }

    @Setup
    fun setup() {
        nettyDirectBitBuf = WrappedBitBuf(Unpooled.directBuffer(BUFFER_SIZE))
        bufferToCopy = UnsafeLongBackedBitBuf()
        bufferToCopy.pBits(1, 1)
        bufferToCopy.pBits(8, 45)
        bufferToCopy.pBits(8, 80)
        bufferToCopy.pBits(8, 125)
        bufferToCopy.pBits(8, 200)
        bufferToCopy.pBits(5, 10)
    }

    @Benchmark
    fun nettyDirectBitBufferWrite() {
        nettyDirectBitBuf.writerIndex(0)
        nettyDirectBitBuf.use {
            it.pBits(1, 1)
            it.pBits(8, 45)
            it.pBits(8, 80)
            it.pBits(8, 125)
            it.pBits(8, 200)
            it.pBits(5, 10)
        }
    }

    @Benchmark
    fun nettyDirectBitBufferTransfer() {
        nettyDirectBitBuf.writerIndex(0)
        nettyDirectBitBuf.use {
            it.pBits(bufferToCopy)
        }
    }

    private companion object {
        private const val DISABLE_NETTY_CHECKS = true
        private const val BUFFER_SIZE = 40_000
    }
}
package net.rsprox.protocol.v228.game.incoming.decoder.codec.objs

import net.rsprot.buffer.JagByteBuf
import net.rsprot.protocol.ClientProt
import net.rsprot.protocol.util.gCombinedIdAlt2
import net.rsprox.protocol.ProxyMessageDecoder
import net.rsprox.protocol.game.incoming.model.objs.OpObjT
import net.rsprox.protocol.session.Session
import net.rsprox.protocol.v228.game.incoming.decoder.prot.GameClientProt

public class OpObjTDecoder : ProxyMessageDecoder<OpObjT> {
    override val prot: ClientProt = GameClientProt.OPOBJT

    override fun decode(
        buffer: JagByteBuf,
        session: Session,
    ): OpObjT {
        val x = buffer.g2()
        val z = buffer.g2Alt2()
        val id = buffer.g2Alt3()
        val selectedCombinedId = buffer.gCombinedIdAlt2()
        val selectedObj = buffer.g2Alt1()
        val controlKey = buffer.g1() == 1
        val selectedSub = buffer.g2Alt2()
        return OpObjT(
            id,
            x,
            z,
            controlKey,
            selectedCombinedId,
            selectedSub,
            selectedObj,
        )
    }
}
package net.rsprox.protocol.v228.game.incoming.decoder.codec.events

import net.rsprot.buffer.JagByteBuf
import net.rsprot.protocol.ClientProt
import net.rsprox.protocol.ProxyMessageDecoder
import net.rsprox.protocol.game.incoming.model.events.EventKeyboard
import net.rsprox.protocol.session.Session
import net.rsprox.protocol.v228.game.incoming.decoder.prot.GameClientProt

public class EventKeyboardDecoder : ProxyMessageDecoder<EventKeyboard> {
    override val prot: ClientProt = GameClientProt.EVENT_KEYBOARD

    override fun decode(
        buffer: JagByteBuf,
        session: Session,
    ): EventKeyboard {
        val count = buffer.readableBytes() / 4
        val keys = ByteArray(count)
        var lastTransmittedKeyPress: Int = -1
        for (i in 0..<count) {
            val key = buffer.g1Alt2()
            val delta = buffer.g3Alt2()
            if (i == 0) {
                lastTransmittedKeyPress = delta
            }
            keys[i] = key.toByte()
        }
        return EventKeyboard(
            lastTransmittedKeyPress,
            EventKeyboard.KeySequence(keys),
        )
    }
}


       "is stable internet connection "
        "during the time this program runs.\nIf the price of the "
        "product falls within your budget, "
        "you will recieve an email regarding the same and this"
        "program will auto-close.\nThank you for using "
        "C3PO scraper! Beep-bop bop-beep.")
    print(msg)
    c3po = Scraper(url, budget, u_email)
    while True:
        if c3po.run():
            break
        time.sleep(time_delay)

# get_user_email validates that that an email address was
# entered. It checks that the host exists and if the host
# is a mail server by checking if there is an MX record
# Loops once on invalid input
def get_user_email(first=True):

    try:
        email = str(input("Enter your email:"))
        validation = is_email(email.strip(), check_dns=True, diagnose=True)
        diagnosis = validation.diagnosis_type
        if (f'{diagnosis}' == 'VALID'):
            return email
        elif (f'{diagnosis}' == 'NODOMAIN'):
            message = "The address you entered didn't include a server"
        elif (f'{diagnosis}' == 'NOLOCALPART'):
            message = "Your email address didn't include a username"
        else:
            message = "Please Try again"
        raise CustomEmailValidationError(message)
    except CustomEmailValidationError as error:
        if (first is True):
            print(error.arg)
            get_user_email(first=False)
        else:
            print("ERROR: You didn't enter a valid email address")
            exit()

# get_frequency validates the user input for how
# often the user wants the URL to be checked
def get_frequency(first=True):
    inp_str = ("How frequently would you like to check the price?"
               "\n1.Every hour\n2.Every 3 hours\n3.Every 6 hours"
               "\nEnter your choice:")
    try:
        frequency = int(input(inp_str))
        if (frequency < 0 or frequency > 3):
            raise ValueError
        return frequency
    except ValueError:
        if (first is True):
            print("Please only select one of the provided options")
            get_frequency(first=False)
        else:
            print("Error: You didn't select a valid option")
            exit()

# get_target_cost validates price input from user
# Loops once on invalid input
def get_target_cost(first=True):

    try:
        target = int(input("Enter your budget price:"))
        return target
    except ValueError:
        if (first is True):
            print("Please enter only numbers; "
                  "not currency symbols.")
            get_target_cost(first=False)
        else:
            print("ERROR: Your target price wasn't valid")
            exit()

# get_url will get the Amazon URL from the user to
# scrape for a cost
def get_url(first=True):
    while True:
        try:
            URL = input("Paste the link of the Amazon product:")
            validate = URLValidator()
            validate(URL)
            return URL
        except ValidationError:
            if (first is True):
                print("Please enter a valid URL; "
                      "Remember to include http/https")
                first = False
            else:
                print("ERROR: You didn't enter a valid URL")
                exit()

if __name__ == '__main__':
    main()


			ret = unlink(path);
			if (ret != 0) {
				ERR(sh, "Error while removing cached CIL file %s: %s", path, strerror(errno));
				status = -3;
				goto cleanup;
			}
		}
	}

cleanup:
	semanage_module_key_destroy(sh, &higher_key);
	semanage_module_info_destroy(sh, higher_info);
	free(higher_info);
	umask(mask);

	return status;
}

static int semanage_direct_remove_key(semanage_handle_t *sh,
				      const semanage_module_key_t *modkey)
{
	assert(sh);
	assert(modkey);

	int status = 0;
	int ret = 0;

	char path[PATH_MAX];
	semanage_module_info_t *modinfo = NULL;

	semanage_module_key_t modkey_tmp;
	ret = semanage_module_key_init(sh, &modkey_tmp);
	if (ret != 0) {
		status = -1;
		goto cleanup;
	}

	/* validate module key */
	ret = semanage_module_validate_priority(modkey->priority);
	if (ret != 0) {
		errno = 0;
		ERR(sh, "Priority %d is invalid.", modkey->priority);
		status = -1;
		goto cleanup;
	}

	ret = semanage_module_validate_name(modkey->name);
	if (ret != 0) {
		errno = 0;
		ERR(sh, "Name %s is invalid.", modkey->name);
		status = -1;
		goto cleanup;
	}

	ret = semanage_module_key_set_name(sh, &modkey_tmp, modkey->name);
	if (ret != 0) {
		status = -1;
		goto cleanup;
	}

	/* get module path */
	ret = semanage_module_get_path(
			sh,
			(const semanage_module_info_t *)modkey,
			SEMANAGE_MODULE_PATH_NAME,
			path,
			sizeof(path));
	if (ret != 0) {
		status = -2;
		goto cleanup;
	}

	/* remove directory */
	ret = semanage_remove_directory(path);
	if (ret != 0) {
		ERR(sh, "Unable to remove module %s at priority %d.", modkey->name, modkey->priority);
		status = -2;
		goto cleanup;
	}

	/* check if its the last module at any priority */
	ret = semanage_module_get_module_info(sh, &modkey_tmp, &modinfo);
	if (ret != 0) {
		/* info that no other module will override */
		errno = 0;
		INFO(sh,
		     "Removing last %s module (no other %s module exists at another priority).",
		     modkey->name,
		     modkey->name);

		/* remove disabled status file */
		ret = semanage_module_get_path(
				sh,
				(const semanage_module_info_t *)modkey,
				SEMANAGE_MODULE_PATH_DISABLED,
				path,
				sizeof(path));
		if (ret != 0) {
			status = -1;
			goto cleanup;
		}

		struct stat sb;
		if (stat(path, &sb) == 0) {
			ret = unlink(path);
			if (ret != 0) {
				status = -1;
				goto cleanup;
			}
		}
	}
	else {
		/* if a lower priority module is going to become active */
		if (modkey->priority > modinfo->priority) {
			/* inform what the new active module will be */
			errno = 0;
			INFO(sh,
			     "%s module at priority %d is now active.",
			     modinfo->name,
			     modinfo->priority);
		}
	}

cleanup:
	semanage_module_key_destroy(sh, &modkey_tmp);

	semanage_module_info_destroy(sh, modinfo);
	free(modinfo);

	return status;
}


ology.hl7.org/CodeSystem/plan-definition-type code 'eca-rule' = 'ECA Rule', given as 'ECA Rule'})

status: draft

date: 23/04/2017

publisher: Centers for Disease Control and Prevention (CDC)

description: When prescribing opioids for chronic pain, providers should use urine drug testing before starting opioid therapy and consider urine drug testing at least annually to assess for prescribed medications as well as other controlled prescription drugs and illicit drugs.

useContext: ,

jurisdiction: United States of America (Details : {urn:iso:std:iso:3166 code 'US' = 'United States of America', given as 'United States of America'})

purpose: CDC’s Guideline for Prescribing Opioids for Chronic Pain is intended to improve communication between providers and patients about the risks and benefits of opioid therapy for chronic pain, improve the safety and effectiveness of pain treatment, and reduce the risks associated with long-term opioid therapy, including opioid use disorder and overdose. The Guideline is not intended for patients who are in active cancer treatment, palliative care, or end-of-life care.

usage: Providers should be aware if patients are taking other prescription drugs or illicit drugs that might increase their risk of an overdose.

copyright: © CDC 2016+.

topic: Opioid Prescribing (Details )

author: , , ,

relatedArtifact:

library: Library/opioidcds-recommendation-10

action

title: Annual Urine Screening Check

description: Patient has not had a urine screening in the past 12 months

documentation:

trigger:

Conditions&


_2()
  L1_2 = CBBA8BC6DEECCDCB4
  L1_2 = L1_2.S9DEB10F3B940A275
  L2_2 = "event_npc_gym_normal_040_okyaku01"
  L3_2 = 14
  L4_2 = false
  L1_2(L2_2, L3_2, L4_2)
  L1_2 = CBBA8BC6DEECCDCB4
  L1_2 = L1_2.S9DEB10F3B940A275
  L2_2 = "event_npc_gym_normal_040_okyaku02"
  L3_2 = 14
  L4_2 = false
  L1_2(L2_2, L3_2, L4_2)
  L1_2 = CBBA8BC6DEECCDCB4
  L1_2 = L1_2.S9DEB10F3B940A275
  L2_2 = "event_npc_gym_normal_040_okyaku03"
  L3_2 = 14
  L4_2 = false
  L1_2(L2_2, L3_2, L4_2)
  L1_2 = CBBA8BC6DEECCDCB4
  L1_2 = L1_2.S9DEB10F3B940A275
  L2_2 = "event_npc_gym_normal_040_okyaku04"
  L3_2 = 14
  L4_2 = false
  L1_2(L2_2, L3_2, L4_2)
  L1_2 = CBBA8BC6DEECCDCB4
  L1_2 = L1_2.S9DEB10F3B940A275
  L2_2 = "event_npc_gym_normal_040_okyaku05"
  L3_2 = 14
  L4_2 = false
  L1_2(L2_2, L3_2, L4_2)
  L1_2 = CBBA8BC6DEECCDCB4
  L1_2 = L1_2.S9DEB10F3B940A275
  L2_2 = "event_npc_gym_normal_040_okyaku06"
  L3_2 = 14
  L4_2 = false
  L1_2(L2_2, L3_2, L4_2)
  L1_2 = CBBA8BC6DEECCDCB4
  L1_2 = L1_2.S9DEB10F3B940A275
  L2_2 = "event_npc_gym_normal_040_okyaku07"
  L3_2 = 14
  L4_2 = false
  L1_2(L2_2, L3_2, L4_2)
  L1_2 = CBBA8BC6DEECCDCB4
  L1_2 = L1_2.S9DEB10F3B940A275
  L2_2 = "event_npc_gym_normal_040_okyaku08"
  L3_2 = 14
  L4_2 = false
  L1_2(L2_2, L3_2, L4_2)
  L1_2 = CBBA8BC6DEECCDCB4
  L1_2 = L1_2.S9DEB10F3B940A275
  L2_2 = "event_npc_gym_normal_040_okyaku09"
  L3_2 = 14
  L4_2 = false
  L1_2(L2_2, L3_2, L4_2)
  L1_2 = CBBA8BC6DEECCDCB4
  L1_2 = L1_2.S9DEB10F3B


d_data[0],
		.nr		= 0,
		.name		= "SiByte SMBus 0",
	},
	{
		.owner		= THIS_MODULE,
		.class		= I2C_CLASS_HWMON | I2C_CLASS_SPD,
		.algo		= NULL,
		.algo_data	= &sibyte_board_data[1],
		.nr		= 1,
		.name		= "SiByte SMBus 1",
	},
};

static int __init i2c_sibyte_init(void)
{
	pr_info("i2c-sibyte: i2c SMBus adapter module for SiByte board\n");
	if (i2c_sibyte_add_bus(&sibyte_board_adapter[0], K_SMB_FREQ_100KHZ) < 0)
		return -ENODEV;
	if (i2c_sibyte_add_bus(&sibyte_board_adapter[1],
			       K_SMB_FREQ_400KHZ) < 0) {
		i2c_del_adapter(&sibyte_board_adapter[0]);
		return -ENODEV;
	}
	return 0;
}

static void __exit i2c_sibyte_exit(void)
{
	i2c_del_adapter(&sibyte_board_adapter[0]);
	i2c_del_adapter(&sibyte_board_adapter[1]);
}

module_init(i2c_sibyte_init);
module_exit(i2c_sibyte_exit);

MODULE_AUTHOR("Kip Walker (Broadcom Corp.), Steven J. Hill <sjhill@realitydiluted.com>");
MODULE_DESCRIPTION("SMBus adapter routines for SiByte boards");
MODULE_LICENSE("GPL");


A_WORD(b___pkn_cher_iveghny)
DATA_WORD(b___pkn_cher_iveghny)
DATA_WORD(b__MGIA10__pkknovi120__fv_pynff_glcr_vasbR)
DATA_WORD(b__MGFA6vph_6413ErfbheprInyhrR)
DATA_WORD(b__MGVA6vph_647HBowrpgR)
.space (__SIZEOF_POINTER__ * 1)
DATA_WORD(b__MGVA6vph_6412ErfbheprFvaxR)
DATA_WORD(b__MA6vph_6412ErfbheprFvaxQ2Ri)
DATA_WORD(b__MA6vph_6412ErfbheprFvaxQ0Ri)
DATA_WORD(b__MAX6vph_647HBowrpg17trgQlanzvpPynffVQRi)
DATA_WORD(b___pkn_cher_iveghny)
DATA_WORD(b__MGIA10__pkknovi120__fv_pynff_glcr_vasbR)
DATA_WORD(b__MGFA6vph_6412ErfbheprFvaxR)
DATA_WORD(b__MGVA6vph_647HBowrpgR)
.space (__SIZEOF_POINTER__ * 1)
DATA_WORD(b__MGVA6vph_6423FgevatPunenpgreVgrengbeR)
DATA_WORD(b__MA6vph_6423FgevatPunenpgreVgrengbeQ2Ri)
DATA_WORD(b__MA6vph_6423FgevatPunenpgreVgrengbeQ0Ri)
DATA_WORD(b__MAX6vph_6423FgevatPunenpgreVgrengbe17trgQlanzvpPynffVQRi)
DATA_WORD(b__MAX6vph_6423FgevatPunenpgreVgrengberdREXAF_24SbejneqPunenpgreVgrengbeR)
DATA_WORD(b__MAX6vph_6422HPunePunenpgreVgrengbe8unfuPbqrRi)
DATA_WORD(b__MA6vph_6422HPunePunenpgreVgrengbe11arkgCbfgVapRi)
DATA_WORD(b__MA6vph_6422HPunePunenpgreVgrengbe13arkg32CbfgVapRi)
DATA_WORD(b__MA6vph_6422HPunePunenpgreVgrengbe7unfArkgRi)
DATA_WORD(b__MAX6vph_6423FgevatPunenpgreVgrengbe5pybarRi)
DATA_WORD(b__MA6vph_6422HPunePunenpgreVgrengbe5svefgRi)
DATA_WORD(b__MA6vph_6422HPunePunenpgreVgrengbe12svefgCbfgVapRi)
DATA_WORD(b__MA6vph_6422HPunePunenpgreVgrengbe7svefg32Ri)
DATA_WORD(b__MA6vph_6422HPunePunenpgreVgrengbe14svefg32CbfgVapRi)
DATA_WORD(b__MA6vph_6422HPunePunenpgreVgrengbe4ynfgRi)
DATA_WORD(b__MA6vph_6422HPunePunenpgreVgrengbe6ynfg32Ri)
DATA_WORD(b__MA6vph_6422HPunePunenpgreVgrengbe8frgVaqrkRv)
DATA_WORD(b__MA6vph_6422HPunePunenpgreVgrengbe10frgVaqrk32Rv)
DATA_WORD(b__MAX6vph_6422HPunePunenpgreVgrengbe7pheeragRi)
DATA_WORD(b__MAX6vph_6422HPunePunenpgreVgrengbe9pheerag32Ri)
DATA_WORD(b__MA6vph_6422HPunePunenpgreVgrengbe4arkgRi)
DATA_WORD(b__MA6v