ww.w3.org/2000/svg" width="17" height="17" fill="%2300AAEE" class="bi bi-bug-fill" viewBox="0 0 16 16"><path d="M4.978.855a.5.5 0 1 0-.956.29l.41 1.352A4.985 4.985 0 0 0 3 6h10a4.985 4.985 0 0 0-1.432-3.503l.41-1.352a.5.5 0 1 0-.956-.29l-.291.956A4.978 4.978 0 0 0 8 1a4.979 4.979 0 0 0-2.731.811l-.29-.956z"/><path d="M13 6v1H8.5v8.975A5 5 0 0 0 13 11h.5a.5.5 0 0 1 .5.5v.5a.5.5 0 1 0 1 0v-.5a1.5 1.5 0 0 0-1.5-1.5H13V9h1.5a.5.5 0 0 0 0-1H13V7h.5A1.5 1.5 0 0 0 15 5.5V5a.5.5 0 0 0-1 0v.5a.5.5 0 0 1-.5.5H13zm-5.5 9.975V7H3V6h-.5a.5.5 0 0 1-.5-.5V5a.5.5 0 0 0-1 0v.5A1.5 1.5 0 0 0 2.5 7H3v1H1.5a.5.5 0 0 0 0 1H3v1h-.5A1.5 1.5 0 0 0 1 11.5v.5a.5.5 0 1 0 1 0v-.5a.5.5 0 0 1 .5-.5H3a5 5 0 0 0 4.5 4.975z"/></svg>');
}

.pe-ui-classic .pe-controlbar .pe-button.capture {
    margin-right: 8px;
    width: 22px;
    height: 40px;
    background-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="19" height="19" fill="%23E6E6E6" class="bi bi-camera-fill" viewBox="0 0 16 16"><path d="M10.5 8.5a2.5 2.5 0 1 1-5 0 2.5 2.5 0 0 1 5 0z"/><path d="M2 4a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2h-1.172a2 2 0 0 1-1.414-.586l-.828-.828A2 2 0 0 0 9.172 2H6.828a2 2 0 0 0-1.414.586l-.828.828A2 2 0 0 1 3.172 4H2zm.5 2a.5.5 0 1 1 0-1 .5.5 0 0 1 0 1zm9 2.5a3.5 3.5 0 1 1-7 0 3.5 3.5 0 0 1 7 0z"/></svg>');
}

@media(hover:hover) {
    .pe-ui-classic .pe-controlbar .pe-button.capture:hover {
        background-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="19" height="19" fill="%2300AAEE" class="bi bi-camera-fill" viewBox="0 0 16 16"><path d="M10.5 8.5a2.5 2.5 0 1 1-5 0 2.5 2.5 0 0 1 5 0z"/><path d="M2 4a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2h12a


 \
        FWPM_CONDITION_ALE_SIO_FIREWALL_SYSTEM_PORT

// b482d227-1979-4a98-8044-18bbe6237542
DEFINE_GUID(
   FWPM_CONDITION_ALE_REAUTH_REASON,
   0xb482d227,
   0x1979,
   0x4a98,
   0x80, 0x44, 0x18, 0xbb, 0xe6, 0x23, 0x75, 0x42
);

#endif // (NTDDI_VERSION >= NTDDI_WIN7)

// 46275a9d-c03f-4d77-b784-1c57f4d02753
DEFINE_GUID(
   FWPM_CONDITION_ALE_NAP_CONTEXT,
   0x46275a9d,
   0xc03f,
   0x4d77,
   0xb7, 0x84, 0x1c, 0x57, 0xf4, 0xd0, 0x27, 0x53
);

#if (NTDDI_VERSION >= NTDDI_WIN7)
// 35d0ea0e-15ca-492b-900e-97fd46352cce
DEFINE_GUID(
   FWPM_CONDITION_KM_AUTH_NAP_CONTEXT,
   0x35d0ea0e,
   0x15ca,
   0x492b,
   0x90, 0x0e, 0x97, 0xfd, 0x46, 0x35, 0x2c, 0xce
);
#endif // (NTDDI_VERSION >= NTDDI_WIN7)

// 9bf0ee66-06c9-41b9-84da-288cb43af51f
DEFINE_GUID(
    FWPM_CONDITION_REMOTE_USER_TOKEN,
    0x9bf0ee66,
    0x06c9,
    0x41b9,
    0x84, 0xda, 0x28, 0x8c, 0xb4, 0x3a, 0xf5, 0x1f
);

// 7c9c7d9f-0075-4d35-a0d1-8311c4cf6af1
DEFINE_GUID(
   FWPM_CONDITION_RPC_IF_UUID,
   0x7c9c7d9f,
   0x0075,
   0x4d35,
   0xa0, 0xd1, 0x83, 0x11, 0xc4, 0xcf, 0x6a, 0xf1
);

// eabfd9b7-1262-4a2e-adaa-5f96f6fe326d
DEFINE_GUID(
   FWPM_CONDITION_RPC_IF_VERSION,
   0xeabfd9b7,
   0x1262,
   0x4a2e,
   0xad, 0xaa, 0x5f, 0x96, 0xf6, 0xfe, 0x32, 0x6d
);

// 238a8a32-3199-467d-871c-272621ab3896
DEFINE_GUID(
    FWPM_CONDITION_RPC_IF_FLAG,
    0x238a8a32,
    0x3199,
    0x467d,
    0x87, 0x1c, 0x27, 0x26, 0x21, 0xab, 0x38, 0x96
);

// ff2e7b4d-3112-4770-b636-4d24ae3a6af2
DEFINE_GUID(
    FWPM_CONDITION_DCOM_APP_ID,
    0xff2e7b4d,
    0x3112,
    0x4770,
    0xb6, 0x36, 0x4d, 0x24, 0xae, 0x3a, 0x6a, 0xf2
);

// d024de4d-deaa-4317-9c85-e40ef6e140c3
DEFINE_GUID(
    FWPM_CONDITION


emes.js",RE="build/vega-themes.module.js",IE="build/vega-themes.min.js",LE="build/vega-themes.min.js",PE="build/vega-themes.module.d.ts",zE={type:"git",url:"https://github.com/vega/vega-themes.git"},DE=["src","build"],jE={prebuild:"yarn clean",build:"rollup -c",clean:"rimraf build && rimraf examples/build","copy:data":"rsync -r node_modules/vega-datasets/data/* examples/data","copy:build":"rsync -r build/* examples/build","deploy:gh":"yarn build && mkdir -p examples/build && rsync -r build/* examples/build && gh-pages -d examples",preversion:"yarn lint",serve:"browser-sync start -s -f build examples --serveStatic examples",start:"yarn build && concurrently --kill-others -n Server,Rollup 'yarn serve' 'rollup -c -w'",format:"eslint . --fix",lint:"eslint .",release:"release-it"},ME={"@babel/core":"^7.22.9","@babel/plugin-proposal-async-generator-functions":"^7.20.7","@babel/plugin-proposal-json-strings":"^7.18.6","@babel/plugin-proposal-object-rest-spread":"^7.20.7","@babel/plugin-proposal-optional-catch-binding":"^7.18.6","@babel/plugin-transform-runtime":"^7.22.9","@babel/preset-env":"^7.22.9","@babel/preset-typescript":"^7.22.5","@release-it/conventional-changelog":"^7.0.0","@rollup/plugin-json":"^6.0.0","@rollup/plugin-node-resolve":"^15.1.0","@rollup/plugin-terser":"^0.4.3","@typescript-eslint/eslint-plugin":"^6.0.0","@typescript-eslint/parser":"^6.0.0","browser-sync":"^2.29.3",concurrently:"^8.2.0",eslint:"^8.45.0","eslint-config-prettier":"^8.8.0","eslint-plugin-prettier":"^5.0.0","gh-pages":"^5.0.0",prettier:"^3.0.0","release-it":"^16.1.0",rollup:"^3.26.2","rollup-plugin-bundle-size":"^1.0.3","rollup-plugin-ts":"^3.2.0",typescript:"^5.1.6",vega:"^5.25.0","vega-lite":"^5.9.3"},UE={vega:"*","vega-lite":"*"},BE={},WE={name:CE,version:NE,description:FE,keywords:kE,license:TE,author:AE,contributors:OE,main:_E,module:RE,unpkg:IE,jsdelivr:LE,types:PE,repository:zE,files:DE,scripts:jE,devDependencies:ME,peerDependencies:UE,dependencies:BE};const Un="#fff",dl="#888",GE={background:"#333",view:{stroke:dl},title:{color:Un,subtitleColor:Un},style:{"guide-label":{fill:Un},"guide-title":{fill:Un}},axis:{domainColor:Un,gridColor:dl,tickColor:Un}},an="#4572a7",HE={background:"#fff",arc:{fill:an},area:{fill:an},line:{stroke:an,strokeWidth:2},path:{stroke:an},rect:{fill:an},shape:{stroke:an},symbol:{fill:an,strokeWidth:1.5,size:50},axis:{bandPosition:.5,grid:!0,gridColor:"#000000",gridOpacity:1,gridWidth:.5,labelPadding:10,tickSize:5,tickWidth:.5},axisBand:{grid:!1,tickExtra:!


ForkMapper extends ClassMapperBase<FlutterFork> {
  FlutterForkMapper._();

  static FlutterForkMapper? _instance;
  static FlutterForkMapper ensureInitialized() {
    if (_instance == null) {
      MapperContainer.globals.use(_instance = FlutterForkMapper._());
    }
    return _instance!;
  }

  @override
  final String id = 'FlutterFork';

  static String _$name(FlutterFork v) => v.name;
  static const Field<FlutterFork, String> _f$name = Field('name', _$name);
  static String _$url(FlutterFork v) => v.url;
  static const Field<FlutterFork, String> _f$url = Field('url', _$url);

  @override
  final MappableFields<FlutterFork> fields = const {
    #name: _f$name,
    #url: _f$url,
  };
  @override
  final bool ignoreNull = true;

  static FlutterFork _instantiate(DecodingData data) {
    return FlutterFork(name: data.dec(_f$name), url: data.dec(_f$url));
  }

  @override
  final Function instantiate = _instantiate;

  static FlutterFork fromMap(Map<String, dynamic> map) {
    return ensureInitialized().decodeMap<FlutterFork>(map);
  }

  static FlutterFork fromJson(String json) {
    return ensureInitialized().decodeJson<FlutterFork>(json);
  }
}

mixin FlutterForkMappable {
  String toJson() {
    return FlutterForkMapper.ensureInitialized()
        .encodeJson<FlutterFork>(this as FlutterFork);
  }

  Map<String, dynamic> toMap() {
    return FlutterForkMapper.ensureInitialized()
        .encodeMap<FlutterFork>(this as FlutterFork);
  }

  FlutterForkCopyWith<FlutterFork, FlutterFork, FlutterFork> get copyWith =>
      _FlutterForkCopyWithImpl<FlutterFork, FlutterFork>(
          this as FlutterFork, $identity, $identity);
  @override
  String toString() {
    return FlutterForkMapper.ensureInitialized()
        .stringifyValue(this as FlutterFork);
  }

  @override
  bool operator ==(Object other) {
    return FlutterForkMapper.ensureInitialized()
        .equalsValue(this as FlutterFork, other);
  }

  @override
  int get hashCode {
    return FlutterForkMapper.ensureInitialized().hashValue(this as FlutterFork);
  }
}

extension FlutterForkValueCopy<$R, $Out>
    on ObjectCopyWith<$R, FlutterFork, $Out> {
  FlutterForkCopyWith<$R, FlutterFork, $Out> get $asFlutterFork =>
      $base.as((v, t, t2) => _FlutterForkCopyWithImpl<$R, $Out>(v, t, t2));
}

abstract class FlutterForkCopyWith<$R, $In extends FlutterFork, $Out>
    implements ClassCopyWith<$R, $In, $Out> {
  $R call({String? name, String? url});
  FlutterForkCopyWith<$R2, $In, $Out2> $chain<$R2, $Out2>(Then<$Out2, $R2> t);
}

class _FlutterForkCopyWithImpl<$R, $Out>
    extends ClassCopyWithBase<$R, FlutterFork, $Out>
    implements FlutterForkCopyWith<$R, FlutterFork, $Out> {
  _FlutterForkCopyWithImpl(super.value, super.then, super.then2);

  @override
  late final ClassMapperBase<FlutterFork> $mapper =
      FlutterForkMapper.ensureInitialized();
  @override
  $R call({String? name, String? url}) => $apply(FieldCopyWithData(


            id++,
            DiagnosticDetail(
                diagnosticSource.severity.name, diagnosticSource.message, null, null
            )
        )
        result.add(diagnostic)
    }
    return result
}

fun DiagnosticSeverity.toEditorLevel(): Short {
    return when (this) {
        DiagnosticSeverity.Hint, DiagnosticSeverity.Information -> DiagnosticRegion.SEVERITY_TYPO
        DiagnosticSeverity.Error -> DiagnosticRegion.SEVERITY_ERROR
        DiagnosticSeverity.Warning -> DiagnosticRegion.SEVERITY_WARNING
    }
}

private fun getVersion(fileUri: FileUri): Int {
    val notNullLock = lock ?: ReentrantReadWriteLock()
    if (lock == null) {
        lock = notNullLock
    }

    val readLock = notNullLock.readLock()
    readLock.lock()
    var version = versionMap.getOrDefault(fileUri, 0)
    version++
    readLock.unlock()
    val writeLock = notNullLock.writeLock()
    writeLock.lock()
    versionMap[fileUri] = version
    writeLock.unlock()
    return version
}

fun clearVersions(func: (FileUri) -> Boolean) {
    versionMap.keys.filter(func).forEach { versionMap.remove(it) }
}/*******************************************************************************
 *    sora-editor - the awesome code editor for Android
 *    https://github.com/Rosemoe/sora-editor
 *    Copyright (C) 2020-2023  Rosemoe
 *
 *     This library 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.
 *
 *     This library 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
 *     Lesser General Public License for more details.
 *
 *     You should have received a copy of the GNU Lesser General Public
 *     License along with this library; if not, write to the Free Software
 *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
 *     USA
 *
 *     Please contact Rosemoe by email 2073412493@qq.com if you need
 *     additional information or have any questions
 ******************************************************************************/

package io.github.rosemoe.sora.lsp.events.diagnostics

import io.github.rosemoe.sora.lang.diagnostic.DiagnosticsContainer
import io.github.rosemoe.sora.lsp.editor.LspEditor
import io.github.rosemoe.sora.lsp.events.EventContext
import io.github.rosemoe.sora.lsp.events.EventListener
import io.github.rosemoe.sora.lsp.events.EventType
import io.github.rosemoe.sora.lsp.utils.transformToEditorDiagnostics
import org.eclipse.lsp4j.Diagnostic

class PublishDiagnosticsEvent : EventListener {
    override val eventName: String = "editor/publishDiagnostics"

    override fun handle(context: EventContext) {
        val lspEditor = context.get<LspEditor>("lsp-editor")
        val originEditor = lspEditor.editor ?: return
        val data = context.getOrNull<List<Diagnostic>>("data") ?: return

        val diagnosticsContainer =
            originEditor.diagnostics ?: DiagnosticsContainer()

        diagnosticsContainer.reset()

        diagnosticsContainer.addDiagnostics(
            data.transformToEditorDiagnostics(originEditor)
        )

        // run on ui thread
        originEditor.post {
            originEditor.diagnostics = diagnosticsContainer
        }
    }

}

val EventType.publishDiagnostics: String
    get() = "editor/publishDiagnostics"plugins {
    id("com.android.application")
    id("kotlin-android")
}

android {
    compileSdk = 33

    defaultConfig {


 = &envtest.Environment{
		CRDDirectoryPaths:     []string{filepath.Join("..", "..", "config", "crd", "bases")},
		ErrorIfCRDPathMissing: false,

		// The BinaryAssetsDirectory is only required if you want to run the tests directly
		// without call the makefile target test. If not informed it will look for the
		// default path defined in controller-runtime which is /usr/local/kubebuilder/.
		// Note that you must have the required binaries setup under the bin directory to perform
		// the tests directly. When we run make test it will be setup and used automatically.
		BinaryAssetsDirectory: filepath.Join("..", "..", "bin", "k8s",
			fmt.Sprintf("1.29.0-%s-%s", runtime.GOOS, runtime.GOARCH)),

		WebhookInstallOptions: envtest.WebhookInstallOptions{
			Paths: []string{filepath.Join("..", "..", "config", "webhook")},
		},
	}

	var err error
	// cfg is defined in this file globally.
	cfg, err = testEnv.Start()
	Expect(err).NotTo(HaveOccurred())
	Expect(cfg).NotTo(BeNil())

	scheme := apimachineryruntime.NewScheme()
	err = awv1beta2.AddToScheme(scheme)
	Expect(err).NotTo(HaveOccurred())

	err = admissionv1.AddToScheme(scheme)
	Expect(err).NotTo(HaveOccurred())
	err = rbacv1.AddToScheme(scheme)
	Expect(err).NotTo(HaveOccurred())
	err = clientgoscheme.AddToScheme(scheme)
	Expect(err).NotTo(HaveOccurred())

	//+kubebuilder:scaffold:scheme

	k8sClient, err = client.New(cfg, client.Options{Scheme: scheme})
	Expect(err).NotTo(HaveOccurred())
	Expect(k8sClient).NotTo(BeNil())

	// configure a restricted rbac user who can create AppWrappers and Pods but not Deployments
	limitedCfg := *cfg
	limitedCfg.Impersonate = rest.ImpersonationConfig{UserName: limitedUserName, UID: string(limitedUserID), Extra: map[string][]string{"xyzzy": {"plugh"}}}
	_, err = testEnv.AddUser(envtest.User{Name: limitedUserName, Groups: []string{}}, &limitedCfg)
	Expect(err).NotTo(HaveOccurred())
	clusterRole := &rbacv1.ClusterRole{
		ObjectMeta: metav1.ObjectMeta{Name: "limited-role"},
		Rules: []rbacv1.PolicyRule{
			{Verbs: []string{"*"}, APIGroups: []string{"workload.codeflare.dev"}, Resources: []string{"appwrappers"}},
			{Verbs: []string{"*"}, APIGroups: []string{""}, Resources: []string{"pods"}},
			{Verbs: []string{"get"}, APIGroups: []string{"apps"}, Resources: []string{"deployments"}},
		},
	}
	err = k8sClient.Create(ctx, clusterRole)
	Expect(err).NotTo(HaveOccurred())
	clusterRoleBinding := &rbacv1.ClusterRoleBinding{
		ObjectMeta: metav1.ObjectMeta{Name: "limited-role-binding"},
		Subjects:   []rbacv1.Subject{{Kind: rbacv1.UserKind, Name: limitedUserName}},
		RoleRef:    rbacv1.RoleRef{APIGroup: "rbac.authorization.k8s.io", Kind: "ClusterRole", Name: clusterRole.Name},
	}
	err = k8sClient.Create(ctx, clusterRoleBinding)
	Expect(err).NotTo(HaveOccurred())

	k8sLimitedClient, err = client.New(&limitedCfg, client.Options{Scheme: scheme})
	Expect(err).NotTo(HaveOccurred())

	// start webhook server using Manager
	webhookInstallOptions := &testEnv.WebhookInstallOptions
	mgr, err := ctrl.NewManager(cfg, ctrl.Options{
		Scheme: scheme,
		WebhookServer: webhook.NewServer(


n initial_placement<N, E, Ty: EdgeType>(graph: &Graph<N, E, Ty, Ix>) -> Coordinates<Ix> {
        let indices = graph.node_indices().collect::<Vec<_>>();
        let mut index_map = HashMap::new();
        let n = indices.len();
        let mut points = Vec::with_capacity(n);
        for (i, &u) in indices.iter().enumerate() {
            index_map.insert(u, i);
            let r = 10. * (i as usize as f32).sqrt();
            let theta = PI * (3. - (5. as f32).sqrt()) * (i as usize as f32);
            let x = r * theta.cos();
            let y = r * theta.sin();
            points.push(Point::new(x, y));
        }
        Coordinates {
            indices,
            points,
            index_map,
        }
    }
}

pub struct CoordinatesIterator<'a, Ix: IndexType> {
    coordinates: &'a Coordinates<Ix>,
    index: usize,
}

impl<'a, Ix: IndexType> Iterator for CoordinatesIterator<'a, Ix> {
    type Item = (NodeIndex<Ix>, Point);
    fn next(&mut self) -> Option<Self::Item> {
        let index = self.index;
        self.index += 1;
        if index < self.coordinates.points.len() {
            Some((
                self.coordinates.indices[index],
                self.coordinates.points[index],
            ))
        } else {
            None
        }
    }
}
//! # `multi_eq`
//! `multi_eq` is a macro library for creating custom equality derives.
//!
//! ## Description
//! This crate exports two macros:
//! [`multi_eq_make_trait!()`](multi_eq_make_trait), and
//! [`multi_eq_make_derive!()`](multi_eq_make_derive). The first is for creating
//! custom equality traits. The second is for creating a derive macro for a
//! custom equality trait. Since derive macros can only be exported by a crate
//! with the `proc-macro` crate type, a typical usage of this library is in
//! multi-crate projects: a `proc-macro` crate for the derive macros, and a main
//! crate importing the derive macros.
//!
//! ## Example
//!
//! ### File tree
//! ```text
//! custom-eq-example
//! ├── Cargo.lock
//! ├── Cargo.toml
//! ├── custom-eq-derive
//! │   ├── Cargo.lock
//! │   ├── Cargo.toml
//! │   └── src
//! │       └── lib.rs
//! └── src
//!     └── lib.rs
//! ```
//!
//! #### `custom-eq-example/custom-eq-derive/Cargo.toml`
//! ```toml
//! # ...
//!
//! [lib]
//! proc-macro = true
//!
//! # ...
//! ```
//!
//! #### `custom-eq-example/custom-eq-derive/src/lib.rs`
//! ```ignore
//! use multi_eq::*;
//!
//! /// Derive macro for a comparison trait `CustomEq` with a method `custom_eq`
//! multi_eq_make_derive!(pub, CustomEq, custom_eq);
//! ```
//!
//! #### `custom-eq-example/Cargo.toml`
//! ```toml
//! # ...
//!
//! [dependencies.custom-eq-derive]
//! path = "custom-eq-derive"
//!
//! # ...
//! ```
//!
//! #### `custom-eq-example/src/lib.rs`
//! ```ignore
//! use multi_eq::*;
//! use custom_eq_derive::*;
//!
//! /// Custom comparison trait `CustomEq` with a method


rr;
    ctx->md = NULL;
    return 1;
 err:
    hmac_ctx_cleanup(ctx);
    return 0;
}

int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx)
{
    if (!HMAC_CTX_reset(dctx))
        goto err;
    if (!EVP_MD_CTX_copy_ex(dctx->i_ctx, sctx->i_ctx))
        goto err;
    if (!EVP_MD_CTX_copy_ex(dctx->o_ctx, sctx->o_ctx))
        goto err;
    if (!EVP_MD_CTX_copy_ex(dctx->md_ctx, sctx->md_ctx))
        goto err;
    memcpy(dctx->key, sctx->key, HMAC_MAX_MD_CBLOCK);
    dctx->key_length = sctx->key_length;
    dctx->md = sctx->md;
    return 1;
 err:
    hmac_ctx_cleanup(dctx);
    return 0;
}

unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len,
                    const unsigned char *d, size_t n, unsigned char *md,
                    unsigned int *md_len)
{
    HMAC_CTX *c = NULL;
    static unsigned char m[EVP_MAX_MD_SIZE];
    static const unsigned char dummy_key[1] = {'\0'};

    if (md == NULL)
        md = m;
    if ((c = HMAC_CTX_new()) == NULL)
        goto err;

    /* For HMAC_Init_ex, NULL key signals reuse. */
    if (key == NULL && key_len == 0) {
        key = dummy_key;
    }

    if (!HMAC_Init_ex(c, key, key_len, evp_md, NULL))
        goto err;
    if (!HMAC_Update(c, d, n))
        goto err;
    if (!HMAC_Final(c, md, md_len))
        goto err;
    HMAC_CTX_free(c);
    return md;
 err:
    HMAC_CTX_free(c);
    return NULL;
}

void HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags)
{
    EVP_MD_CTX_set_flags(ctx->i_ctx, flags);
    EVP_MD_CTX_set_flags(ctx->o_ctx, flags);
    EVP_MD_CTX_set_flags(ctx->md_ctx, flags);
}

const EVP_MD *HMAC_CTX_get_md(const HMAC_CTX *ctx)
{
    return ctx->md;
}


(%eax), %ecx
	movl	%ecx, oFPREGS(%eax)
	/* Save the floating-point context.  */
	fnstenv	(%ecx)

	/* Load address of the context data structure we have to load.  */
	movl	8(%esp), %ecx

	/* Save the current signal mask and install the new one.  */
	pushl	%ebx
	leal	oSIGMASK(%eax), %edx
	leal	oSIGMASK(%ecx), %ecx
	movl	$SIG_SETMASK, %ebx
	movl	$__NR_sigprocmask, %eax
	int	$0x80
	popl	%ebx
	cmpl	$-4095, %eax		/* Check %eax for error.  */
	jae	SYSCALL_ERROR_LABEL	/* Jump to error handler if error.  */

	/* EAX was modified, reload it.  */
	movl	8(%esp), %eax

	/* Restore the floating-point context.  Not the registers, only the
	   rest.  */
	movl	oFPREGS(%eax), %ecx
	fldenv	(%ecx)

	/* Restore the FS and GS segment registers.  */
	movl	oGS(%eax), %edx
	movl	oFS(%eax), %ecx
	movw	%dx, %gs
	movw	%cx, %fs

	/* Load the new stack pointer.  */
	movl	oESP(%eax), %ecx
	/* Make room for 8 registers and the return address.  We will load
	   the values from the stack.  */
	subl	$36, %ecx

	/* Move the values of all the 32-bit registers (except ESP) on
	   the stack.  This happens in the form the 'popa' instruction
	   expects it.  Before this block put the address of the code
	   to execute.  */
	movl	oEDI(%eax), %ebx
	movl	oESI(%eax), %edx
	movl	oEBP(%eax), %esi
	movl	oEBX(%eax), %edi
	movl	%ebx, (%ecx)
	movl	%edx, 4(%ecx)
	movl	%esi, 8(%ecx)
	movl	%edi, 16(%ecx)
	movl	oEDX(%eax), %ebx
	movl	oECX(%eax), %edx
	movl	oEAX(%eax), %esi
	movl	oEIP(%eax), %edi
	movl	%ebx, 20(%ecx)
	movl	%edx, 24(%ecx)
	movl	%esi, 28(%ecx)
	movl	%edi, 32(%ecx)

	/* Set the new stack address.  The stack points now to the block
	   we put the register content in.  */
	movl	%ecx, %esp
	/* Restore the register content.  */
	popa
	/* The following 'ret' will pop the addres of the code and jump
	   to it.  */

L(pseudo_end):
	ret
PSEUDO_END(__swapcontext)

weak_alias(__swapcontext, swapcontext)


LabelByFrame(this.$currentFrameNum);
                return label && label.name;
            }
        );
        d(p, "currentLabel"
            /**
             * 当前播放的帧对应的标签，如果当前帧没有标签，则currentLabel返回包含标签的先前帧的标签。如果当前帧和先前帧都不包含标签，currentLabel返回null。
             * @version Egret 2.4
             * @platform Web,Native
             */
            ,function () {
                var label = this.getFrameLabelForFrame(this.$currentFrameNum);
                return label ? label.name : null;
            }
        );
        d(p, "frameRate"
            /**
             * MovieClip 实例的帧频
             * @version Egret 2.4
             * @platform Web,Native
             */
            ,function () {
                return this.$frameRate;
            }
            ,function (value) {
                if (value == this.$frameRate) {
                    return;
                }
                this.$frameRate = value;
                this.frameIntervalTime = 1000 / this.$frameRate;
            }
        );
        d(p, "isPlaying"
            /**
             * MovieClip 实例当前是否正在播放
             * @version Egret 2.4
             * @platform Web,Native
             */
            ,function () {
                return this.$isPlaying;
            }
        );
        d(p, "movieClipData"
            /**
             * @version Egret 2.4
             * @platform Web,Native
             */
            ,function () {
                return this.$movieClipData;
            }
            /**
             * MovieClip数据源
             */
            ,function (value) {
                this.setMovieClipData(value);
            }
        );
        /**
         * @private
         *
         * @param value
         */
        p.setMovieClipData = function (value) {
            if (this.$movieClipData == value) {
                return;
            }
            this.$movieClipData = value;
            this.$init();
        };
        /**
         * @private
         *
         * @param value
         */
        p.setPlayTimes = function (value) {
            if (value < 0 || value >= 1) {
                this.playTimes = value < 0 ? -1 : Math.floor(value);
            }
        };
        /**
         * @private
         *
         * @param value
         */
        p.setIsStopped = function (value) {
            if (this.isStopped == value) {
                return;
            }
            this.isStopped = value;
            if (value) {
                this.playTimes = 0;
                egret.sys.$ticker.$stopTick(this.advanceTime, this);
            }
            else {
                this.playTimes = this.playTimes == 0 ? 1 : this.playTimes;
                this.lastTime = egret.getTimer();
                egret.sys.$ticker.$startTick(this.advanceTime, this);
            }
        };
        return MovieClip;
    }(egret.DisplayObject));
    egret.MovieClip = MovieClip;
    egret.registerClass(MovieClip,'egret.MovieClip');
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither th


 = (target_vco_out + (vco_in >> 1)) / vco_in;
                let vco_out = vco_in * n;
                if !(100_000_000..=432_000_000).contains(&vco_out) {
                    return None;
                }
                let output = vco_out / outdiv;
                let error = (output as i32 - target as i32).abs() as u32;
                Some((n, outdiv, output, error))
            })
            .min_by_key(|(_, _, _, error)| *error)?;
        Some((
            SingleOutputPll {
                m: m as u8,
                n: n as u16,
                outdiv: outdiv as u8,
            },
            output,
            error,
        ))
    }
}
<reponame>neufeldm/tock<gh_stars>1-10
//! Component for the MX25R6435F flash chip.
//!
//! Usage
//! -----
//! ```rust
//! let mx25r6435f = components::mx25r6435f::Mx25r6435fComponent::new(
//!     &gpio_port[driver.write_protect_pin],
//!     &gpio_port[driver.hold_pin],
//!     &gpio_port[driver.chip_select] as &dyn kernel::hil::gpio::Pin,
//!     mux_alarm,
//!     mux_spi,
//! )
//! .finalize(components::mx25r6435f_component_helper!(
//!     nrf52::spi::SPIM,
//!     nrf52::gpio::GPIOPin,
//!     nrf52::rtc::Rtc
//! ));
//! ```
use capsules::mx25r6435f::MX25R6435F;
use capsules::virtual_alarm::{MuxAlarm, VirtualMuxAlarm};
use capsules::virtual_spi::{MuxSpiMaster, VirtualSpiMasterDevice};
use core::mem::MaybeUninit;
use kernel::component::Component;
use kernel::hil;
use kernel::hil::spi::SpiMasterDevice;
use kernel::hil::time::Alarm;
use kernel::static_init_half;

// Setup static space for the objects.
#[macro_export]
macro_rules! mx25r6435f_component_helper {
    ($S:ty, $P:ty, $A:ty $(,)?) => {{
        use capsules::mx25r6435f::MX25R6435F;
        use capsules::virtual_alarm::VirtualMuxAlarm;
        use capsules::virtual_spi::VirtualSpiMasterDevice;
        use core::mem::MaybeUninit;
        static mut BUF1: MaybeUninit<VirtualSpiMasterDevice<'static, $S>> = MaybeUninit::uninit();
        static mut BUF2: MaybeUninit<VirtualMuxAlarm<'static, $A>> = MaybeUninit::uninit();
        static mut BUF3: MaybeUninit<
            MX25R6435F<
                'static,
                VirtualSpiMasterDevice<'static, $S>,
                $P,
                VirtualMuxAlarm<'static, $A>,
            >,
        > = MaybeUninit::uninit();
        (&mut BUF1, &mut BUF2, &mut BUF3)
    };};
}

pub struct Mx25r6435fComponent<
    S: 'static + hil::spi::SpiMaster,
    P: 'static + hil::gpio::Pin,
    A: 'static + hil::time::Alarm<'static>,
> {
    write_protect_pin: Option<&'static P>,
    hold_pin: Option<&'static P>,
    chip_select: S::ChipSelect,
    mux_alarm: &'static MuxAlarm<'static, A>,
    mux_spi: &'static MuxSpiMaster<'static, S>,
}

impl<
        S: 'static + hil::spi::SpiMaster,
        P: 'static + hil::gpio::Pin,
        A: 'static + hil::time::Alarm<'static>,


}

        if (isKeyEvent(event)) {
          if (isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers)) {
            return;
          }
        }

        if (modifiers.includes('prevent')) e.preventDefault();
        if (modifiers.includes('stop')) e.stopPropagation(); // If the .self modifier isn't present, or if it is present and
        // the target element matches the element we are registering the
        // event on, run the handler

        if (!modifiers.includes('self') || e.target === el) {
          const returnValue = runListenerHandler(component, expression, e, extraVars);
          returnValue.then(value => {
            if (value === false) {
              e.preventDefault();
            } else {
              if (modifiers.includes('once')) {
                listenerTarget.removeEventListener(event, handler, options);
              }
            }
          });
        }
      };

      if (modifiers.includes('debounce')) {
        let nextModifier = modifiers[modifiers.indexOf('debounce') + 1] || 'invalid-wait';
        let wait = isNumeric(nextModifier.split('ms')[0]) ? Number(nextModifier.split('ms')[0]) : 250;
        handler = debounce(handler, wait);
      }

      listenerTarget.addEventListener(event, handler, options);
    }
  }

  function runListenerHandler(component, expression, e, extraVars) {
    return component.evaluateCommandExpression(e.target, expression, () => {
      return _objectSpread2(_objectSpread2({}, extraVars()), {}, {
        '$event': e
      });
    });
  }

  function isKeyEvent(event) {
    return ['keydown', 'keyup'].includes(event);
  }

  function isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers) {
    let keyModifiers = modifiers.filter(i => {
      return !['window', 'document', 'prevent', 'stop'].includes(i);
    });

    if (keyModifiers.includes('debounce')) {
      let debounceIndex = keyModifiers.indexOf('debounce');
      keyModifiers.splice(debounceIndex, isNumeric((keyModifiers[debounceIndex + 1] || 'invalid-wait').split('ms')[0]) ? 2 : 1);
    } // If no modifier is specified, we'll call it a press.

    if (keyModifiers.length === 0) return false; // If one is passed, AND it matches the key pressed, we'll call it a press.

    if (keyModifiers.length === 1 && keyModifiers[0] === keyToModifier(e.key)) return false; // The user is listening for key combinations.

    const systemKeyModifiers = ['ctrl', 'shift', 'alt', 'meta', 'cmd', 'super'];
    const selectedSystemKeyModifiers = systemKeyModifiers.filter(modifier => keyModifiers.includes(modifier));
    keyModifiers = keyModifiers.filter(i => !selectedSystemKeyModifiers.includes(i));

    if (selectedSystemKeyModifiers.length > 0) {
      const activelyPressedKeyModifiers = selectedSystemKeyModifiers.filter(modifier => {
        // Alias "cmd" and "super" to "meta"
        if (modifier === 'cmd' || modifier === 'super') modifier = 'meta';
        return e[`${modifier}Key`];
      }); // If all the modifiers selected are pressed, ...

      if (activelyPressedKeyModifiers.length === selectedSystemKeyModifiers.length) {
        // AND the remaining key is pressed as well. It's a press.
        if (keyModifiers[0] === keyToModifier(e.key)) return false;
      }
    } // We'll call it NOT a valid keypress.

    return true;
  }

  function keyToModifier(key) {
    switch (key) {
      case '/':
        return 'slash';

      case ' ':
      case 'Spacebar':
        return 'space';

      default:
        return key && kebabCase(key);
    }
  }

  function registerModelListener(


git"] .. " Git bash", args = { "sh", "-l" }, cwd = "~" },
  }

  -- ref: https://wezfurlong.org/wezterm/config/lua/WslDomain.html
  Config.wsl_domains = {
    {
      name = "WSL:Ubuntu",
      distribution = "Ubuntu",
      username = "sravioli",
      default_cwd = "~",
      default_prog = { "bash", "-i", "-l" },
    },
    {
      name = "WSL:Alpine",
      distribution = "Alpine",
      username = "sravioli",
      default_cwd = "/home/sravioli",
    },
  }
end

Config.default_cwd = fs.home()

-- ref: https://wezfurlong.org/wezterm/config/lua/SshDomain.html
Config.ssh_domains = {}

-- ref: https://wezfurlong.org/wezterm/multiplexing.html#unix-domains
Config.unix_domains = {}

return Config


وم" +
	"یزولویامدورسیمگاہیمیتھیلیمکاسرماسایموکشامیندےمیروموریسیینماخاوا-ميتومیٹ" +
	"امکمیکمنانگکباؤمنی پوریموہاکموسیمنڈانگمتعدد زبانیںکریکمیرانڈیزارزیامزند" +
	"رانیnanنیاپولیٹنناماادنی جرمننیوارینیاسنیویائیكوايسونگیمبوننوگائیاینکوش" +
	"مالی سوتھونویرنینکولپنگاسنانپامپنگاپاپیامینٹوپالاوننائجیریائی پڈگنپارسی" +
	"كيشیرپانویراروتونگانرومبوارومانیرواسنڈاوےساکھاسامبوروسنتالینگامبےسانگوس" +
	"یسیلینسکاٹجنوبی کردسیناكويرابورو سينیتشلحيتشانجنوبی سامیلول سامیاناری س" +
	"امیسکولٹ سامیسوننکےسرانن ٹونگوساہوسکوماکوموریائیسریانیٹمنےتیسوٹیٹمٹگرےک" +
	"لنگنٹوک پِسِنٹوروکوٹمبوکاتووالوتاساواقتووینینسینٹرل ایٹلس ٹمازائٹادمورت" +
	"اومبوندونامعلوم زبانوائیونجووالسروولایتاوارےوارلپیریwuuکالمیکسوگایانگبی" +
	"نیمباکینٹونیزاسٹینڈرڈ مراقشی تمازیقیزونیکوئی لسانی مواد نہیںزازاماڈرن ا" +
	"سٹینڈرڈ عربیآزربائیجانی (عربی)آسٹریائی جرمنسوئس ہائی جرمنآسٹریلیائی انگ" +
	"ریزیکینیڈین انگریزیبرطانوی انگریزیامریکی انگریزیلاطینی امریکی ہسپانوییو" +
	"رپی ہسپانویمیکسیکن ہسپانویکینیڈین فرانسیسیسوئس فرینچادنی سیکسنفلیمِشبرا" +
	"زیلی پرتگالییورپی پرتگالیمالدوواسربو-کروئیشینکانگو سواحلیچینی (آسان کرد" +


,
		})
		messageChannelMap[fakeChannelID] = list
	}
	m.mutex.Lock()
	// 查询已经存在的消息扩展数据
	messageExtras, err := m.messageExtraDB.queryWithMessageIDs(messageIds)
	if err != nil {
		m.mutex.Unlock()
		m.Error("查询消息扩展数据错误", zap.Error(err))
		return
	}
	tx, err := m.ctx.DB().Begin()
	if err != nil {
		m.mutex.Unlock()
		m.Error("开启事务失败！", zap.Error(err))
		return
	}
	defer func() {
		if err := recover(); err != nil {
			m.mutex.Unlock()
			tx.RollbackUnlessCommitted()
			panic(err)
		}
	}()
	type sendCMDVO struct {
		ChannelID   string
		ChannelType uint8
		LoginUID    string
		FromUIDs    []string
	}
	sendCmds := make([]*sendCMDVO, 0)
	for fakeChannelID, msgs := range messageChannelMap {
		messageIDStrs := make([]string, 0)
		reqChannelType := common.ChannelTypePerson.Uint8()
		reqChannelID := ""
		reqLoginUID := ""
		if len(msgs) > 0 {
			reqChannelType = msgs[0].ReqChannelType
			reqChannelID = msgs[0].ReqChannelID
			reqLoginUID = msgs[0].LoginUID
			for _, tempMsg := range msgs {
				messageIDStrs = append(messageIDStrs, tempMsg.MessageIDStr)
			}
		}
		messageReadedCountMap, err := m.memberReadedDB.queryCountWithMessageIDs(fakeChannelID, reqChannelType, messageIDStrs)
		if err != nil {
			m.mutex.Unlock()
			tx.Rollback()
			m.Error("获取消息已读数量map失败！", zap.Error(err))
			return
		}
		fromUIDs := make([]string, 0, len(messages)) // 消息发送者
		for _, message := range msgs {
			fromUIDs = append(fromUIDs, message.FromUID)
			version := m.genMessageExtraSeq(fakeChannelID)
			count := messageReadedCountMap[message.MessageID]
			if message.ChannelType == common.ChannelTypePerson.Uint8() {
				count = 1
			}

			var tempMsgExtra *messageExtraModel
			for _, messageExtra := range messageExtras {
				if messageExtra.MessageID == message.MessageIDStr {
					tempMsgExtra = messageExtra
					tempMsgExtra.ReadedCount = count
					tempMsgExtra.Version = version
					break
				}
			}
			if tempMsgExtra == nil {
				err = m.messageExtraDB.insertTx(&messageExtraModel{
					MessageID:   message.MessageIDStr,
					MessageSeq:  message.MessageSeq,
					FromUID:     message.FromUID,
					ChannelID:   fakeChannelID,
					ChannelType: reqChannelType,
					ReadedCount: count,
					Version:     version,
				}, tx)
				if err != nil {
					m.mutex.Unlock()
					tx.Rollback()
					m.Error("添加消息扩展数据失败！", zap.Error(err), zap.Int64("messageID", message.MessageID), zap.String("channelID", fakeChannelID))
					return
				}
			} else {
				err = m.messageExtraDB.updateTx(tempMsgExtra, tx)
				if err != nil {
					m.mutex.Unlock()
					tx.Rollback()
					m.Error("更新消息扩展数据失败！", zap.Error(err), zap.Int64("messageID", message.MessageID), zap.String("channelID", fakeChannelID))
					return
				}


2y15e2d,'
    // #2629: 5 fonts: HK 50₇₇, JP 32₁₆₈, KR 80₃₄₀, SC 77₄₆₁, TC 43₅₂₈.
    '2z3m6p4q2o,'
    // #2630: 5 fonts: HK 50₇₇, JP 32₁₆₈, KR 80₃₄₀, SC 78₄₆₂, TC 43₅₂₈.
    '2z3m6p4r2n,'
    // #2631: 5 fonts: HK 50₇₇, JP 32₁₆₈, KR 80₃₄₀, SC 78₄₆₂, TC 44₅₂₉.
    '2z3m6p4r2o,'
    // #2632: 5 fonts: HK 50₇₇, JP 32₁₆₈, KR 80₃₄₀, SC 80₄₆₄, TC 44₅₂₉.
    '2z3m6p4t2m,'
    // #2633: 3 fonts: HK 50₇₇, JP 32₁₆₈, SC 41₄₂₅.
    '2z3m9w,'
    // #2634: 3 fonts: HK 50₇₇, JP 32₁₆₈, SC 42₄₂₆.
    '2z3m9x,'
    // #2635: 4 fonts: HK 50₇₇, JP 32₁₆₈, SC 82₄₆₆, TC 43₅₂₈.
    '2z3m11l2j,'
    // #2636: 4 fonts: HK 50₇₇, JP 32₁₆₈, SC 85₄₆₉, TC 43₅₂₈.
    '2z3m11o2g,'
    // #2637: 4 fonts: HK 50₇₇, JP 32₁₆₈, SC 87₄₇₁, TC 44₅₂₉.
    '2z3m11q2f,'
    // #2638: 4 fonts: HK 50₇₇, JP 33₁₆₉, KR 80₃₄₀, TC 44₅₂₉.
    '2z3n6o7g,'
    // #2639: 5 fonts: HK 50₇₇, JP 68₂₀₄, KR 80₃₄₀, SC 41₄₂₅, TC 43₅₂₈.
    '2z4w5f3g3y,'
    // #2640: 4 fonts: HK 50₇₇, JP 70₂₀₆, SC 41₄₂₅, TC 43₅₂₈.
    '2z4y8k3y,'
    // #2641: 5 fonts: HK 50₇₇, JP 73₂₀₉, KR 80₃₄₀, SC 84₄₆₈, TC 44₅₂₉.
    '2z5b5a4x2i,'
    // #2642: 4 fonts: HK 50₇₇, KR 80₃₄₀, SC 41₄₂₅, TC 43₅₂₈.
    '2z10c3g3y,'
    // #2643: 3 fonts: HK 50₇₇, KR 80₃₄₀, TC 44₅₂₉.
    '2z10c7g,'
    // #2644: 2 fonts: HK 50₇₇, SC 42₄₂₆.
    '2z13k,'
    // #2645: 3 fonts: HK 50₇₇, SC 42₄₂₆, TC 44₅₂₉.
    '2z13k3y,'
    // #2646: 3 fonts: HK 50₇₇, SC 79₄₆₃, TC 44₅₂₉.


 // include all README files
      `!${root}**/solution2/**`, // exclude the solution 2 folder entirely
      `${root}**/*.sln`, // include all sln files
      `!${root}**/proj2/README.txt` // exclude proj2 README files
    ].map(x => new Pattern(x))
    const matched = itemPaths.filter(
      x => patternHelper.match(patterns, x) === MatchKind.All
    )
    expect(matched).toEqual([
      `${root}solution1/proj1/proj1.proj`,
      `${root}solution1/proj1/README.txt`,
      `${root}solution1/proj2/proj2.proj`,
      `${root}solution1/solution1.sln`,
      `${root}solution2/solution2.sln`
    ])
  })

  it('match supports excluding directories', () => {
    const root = IS_WINDOWS ? 'C:\\' : '/'
    const itemPaths = [
      root,
      `${root}foo`,
      `${root}foo/bar`,
      `${root}foo/bar/baz`
    ]
    const patterns = [
      `${root}foo/**`, // include all files and directories
      `!${root}foo/**/` // exclude directories
    ].map(x => new Pattern(x))
    const matchKinds = itemPaths.map(x => patternHelper.match(patterns, x))
    expect(matchKinds).toEqual([
      MatchKind.None,
      MatchKind.File,
      MatchKind.File,
      MatchKind.File
    ])
  })

  it('match supports including directories only', () => {
    const root = IS_WINDOWS ? 'C:\\' : '/'
    const itemPaths = [
      root,
      `${root}foo/`,
      `${root}foo/bar`,
      `${root}foo/bar/baz`
    ]
    const patterns = [
      `${root}foo/**/` // include directories only
    ].map(x => new Pattern(x))
    const matchKinds = itemPaths.map(x => patternHelper.match(patterns, x))
    expect(matchKinds).toEqual([
      MatchKind.None,
      MatchKind.Directory,
      MatchKind.Directory,
      MatchKind.Directory
    ])
  })

  it('partialMatch skips negate patterns', () => {
    const root = IS_WINDOWS ? 'C:\\' : '/'
    const patterns = [
      `${root}search1/foo/**`,
      `${root}search2/bar/**`,
      `!${root}search2/bar/**`,
      `!${root}search3/baz/**`
    ].map(x => new Pattern(x))
    expect(patternHelper.partialMatch(patterns, `${root}search1`)).toBeTruthy()
    expect(
      patternHelper.partialMatch(patterns, `${root}search1/foo`)
    ).toBeTruthy()
    expect(patternHelper.partialMatch(patterns, `${root}search2`)).toBeTruthy()
    expect(
      patternHelper.partialMatch(patterns, `${root}search2/bar`)
    ).toBeTruthy()
    expect(patternHelper.partialMatch(patterns, `${root}search3`)).toBeFalsy()
    expect(
      patternHelper.partialMatch(patterns, `${root}search3/bar`)
    ).toBeFalsy()
  })
})
import {IAction, createAction, IActionCallback, IDispatchFunction} from "../util/ActionUtil";

export const GET_DATA: string = "GET_DATA";
export function getData(): IActionCallback {
    return (dispatch: IDispatchFunction): Promise<any> => {
        return dispatch(createAction(GET_DATA, Promise.all([
                dispatch(getFoo()),
                dispatch(getBar())
            ])
        ));
    };
}

export const GET_FOO: string = "GET_FOO";
export function getFoo(): IActionCallback {


/*
 * Copyright (C) 2014 SCALITY SA. All rights reserved.
 * http://www.scality.com
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY SCALITY SA ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL SCALITY SA OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation
 * are those of the authors and should not be interpreted as representing
 * official policies, either expressed or implied, of SCALITY SA.
 *
 * https://github.com/scality/Droplet
 */

#include <dropletp.h>
#include <droplet/s3/s3.h>

dpl_status_t
dpl_s3_stream_resume(dpl_ctx_t *ctx, dpl_stream_t *stream,
                     struct json_object *status)
{
  json_object_put(stream->status);
  json_object_get(status);
  stream->status = status;

  return DPL_SUCCESS;
}


Search = stringResource(id = R.string.tip_equip_search)
                    MainSmallFab(
                        iconType = MainIconType.SEARCH,
                        text = stringResource(id = R.string.equip_search),
                        onClick = {
                            if (searchEquipIdList.isNotEmpty()) {
                                toSearchEquipQuest(searchEquipIdList.listJoinStr)
                            } else {
                                ToastUtil.short(tipSearch)
                            }
                        }
                    )
                }

            }
        } else {
            //切换至选择模式
            MainSmallFab(
                iconType = MainIconType.SEARCH,
                text = stringResource(id = R.string.equip_search_mode),
                onClick = {
                    changeSearchMode()
                }
            )
        }
    }
}

@Composable
private fun EquipListFabContent(
    count: Int,
    scrollState: LazyListState,
    filter: FilterEquip?,
    resetFilter: () -> Unit,
    toFilterEquip: (String) -> Unit
) {
    val coroutineScope = rememberCoroutineScope()

    //回到顶部
    MainSmallFab(
        iconType = MainIconType.TOP,
        onClick = {
            coroutineScope.launch {
                scrollState.scrollToItem(0)
            }
        }
    )

    //重置筛选
    if (filter?.isFilter() == true) {
        MainSmallFab(
            iconType = MainIconType.RESET,
            onClick = {
                resetFilter()
            }
        )
    }

    // 数量显示&筛选按钮
    MainSmallFab(
        iconType = MainIconType.EQUIP,
        text = "$count",
        onClick = {
            filter?.let {
                toFilterEquip(Json.encodeToString(filter))
            }
        }
    )
}

@OptIn(ExperimentalSharedTransitionApi::class)
@Composable
private fun SharedTransitionScope.EquipListContent(
    animatedVisibilityScope: AnimatedVisibilityScope,
    equipList: List<EquipmentBasicInfo>,
    scrollState: LazyListState,
    favoriteIdList: List<Int>,
    searchEquipMode: Boolean,
    searchEquipIdList: List<Int>,
    toEquipDetail: (Int) -> Unit,
    toEquipMaterial: (Int, String) -> Unit,
    selectEquip: (Int) -> Unit,
) {

    //分组
    val equipGroupList = arrayListOf<EquipGroupData>()
    equipList.forEach { equip ->
        var group = equipGroupList.find {
            it.promotionLevel == equip.promotionLevel && it.requireLevel == equip.requireLevel
        }
        if (group == null) {
            group = EquipGroupData(equip.promotionLevel, equip.requireLevel)
            equipGroupList.add(group)
        }
        group.equipIdList.add(equip)
    }

    LazyColumn(state = scrollState) {
        items(items = equipGroupList,
            key = {
                "${it.requireLevel}-${it.promotionLevel}"
            }
        ) { equipGroupData ->
            //分组标题
            CommonGroupTitle(
                titleStart = stringResource(
                    id = R.string.equip_require_level,
                    equipGroupData.requireLevel
                ),
                titleEnd = equipGroupData.equipIdList.size.toString(),
                modifier = Modifier.padding(Dimen.mediumPadding),
                backgroundColor = getEquipColor(equipGroupData.promotionLevel)
            )

            //分组内容
            VerticalGridList(
                itemCount = equipGroupData.equipIdList.size,
                itemWidth = if (searchEquipMode) Dimen.iconSize else Dimen.iconSize * 3,
                contentPadding = Dimen.mediumPadding,
                modifier = if (searchEquipMode) {
                    Modifier
                } else {
                    Modifier.padding(
                        horizontal = Dimen.commonItemPadding
                    )
                }
            ) {


                    token.type = TokenType.CODE_POINT;
                }
                break;
            } // switch

        } else if (c == '[') {
            fetchTokenInCCFor_posixBracket();
        } else if (c == '&') {
            fetchTokenInCCFor_and();
        }
        return token.type;
    }

    protected final int backrefRelToAbs(int relNo) {
        return env.numMem + 1 + relNo;
    }

    private void fetchTokenFor_repeat(int lower, int upper) {
        token.type = TokenType.OP_REPEAT;
        token.setRepeatLower(lower);
        token.setRepeatUpper(upper);
        greedyCheck();
    }

    private void fetchTokenFor_openBrace() {
        switch (fetchRangeQuantifier()) {
        case 0:
            greedyCheck();
            break;
        case 2:
            if (syntax.fixedIntervalIsGreedyOnly()) {
                possessiveCheck();
            } else {
                greedyCheck();
            }
            break;
        default: /* 1 : normal char */
        } // inner switch
    }

    private void fetchTokenFor_anchor(int subType) {
        token.type = TokenType.ANCHOR;
        token.setAnchorSubtype(subType);
    }

    private void fetchTokenFor_xBrace() {
        if (!left()) return;

        int last = p;
        if (peekIs('{') && syntax.opEscXBraceHex8()) {
            inc();
            int num = scanUnsignedHexadecimalNumber(0, 8);
            if (num < 0) newValueException(ERR_TOO_BIG_WIDE_CHAR_VALUE);
            if (left()) {
                if (enc.isXDigit(peek())) newValueException(ERR_TOO_LONG_WIDE_CHAR_VALUE);
            }

            if (p > last + enc.length(bytes, last, stop) && left() && peekIs('}')) {
                inc();
                token.type = TokenType.CODE_POINT;
                token.setCode(num);
            } else {
                /* can't read nothing or invalid format */
                p = last;
            }
        } else if (syntax.opEscXHex2()) {
            int num = scanUnsignedHexadecimalNumber(0, 2);
            if (num < 0) newValueException(TOO_BIG_NUMBER);
            if (p == last) { /* can't read nothing. */
                num = 0; /* but, it's not error */
            }
            token.type = TokenType.RAW_BYTE;
            token.base = 16;
            token.setC(num);
        }
    }

    private void fetchTokenFor_uHex() {
        if (!left()) return;
        int last = p;

        if (syntax.op2EscUHex4()) {
            int num = scanUnsignedHexadecimalNumber(4, 4);
            if (num < -1) newValueException(TOO_SHORT_DIGITS);
            if (num < 0) newValueException(TOO_BIG_NUMBER);
            if (p == last) { /* can't read nothing. */
                num = 0; /* but, it's not error */
            }
            token.type = TokenType.CODE_POINT;
            token.base = 16;
            token.setCode(num);
        }
    }

    private void fetchTokenFor_digit() {
        unfetch();
        int last = p;
        int num = scanUnsignedNumber();
        if (num < 0 || num > Config.MAX_BACKREF_NUM) { // goto skip_backref
        } else if (syntax.opDecimalBackref() && (num <= env.numMem || num <= 9)) { /* This spec. from GNU regex */
            if (syntax.strictCheckBackref()) {
                if (num > env.numMem || env.memNodes == null || env.memNodes[num] == null) newValueException(INVALID_BACKREF);
            }
            token.type = TokenType.BACKREF;
            token.setBackrefNum(1);
            token.setBackrefRef1(num);
            token.setBackrefByName(false);
            if (Config.USE_BACKREF_WITH_LEVEL) token.setBackrefExistLevel(false);


) of those
		// sizes on every call, which is a contradiction, although it's allowed
		// as a denormalized uninstantiable type.  For now just treat a spread
		// of sizes like bottom (i.e., the count is not known).
		val argumentCount = arguments.size
		val sizeRange = functionToCallReg.type().argsTupleType.sizeRange
		assert(
			sizeRange.isBottom
				|| !sizeRange.lowerBound.equals(sizeRange.upperBound)
				|| sizeRange.rangeIncludesLong(argumentCount.toLong()))
		val guaranteedResultType: A_Type
		val rawFunction = generator.determineRawFunction(functionToCallReg)
		val primitive = rawFunction?.codePrimitive()
		if (primitive !== null)
		{
			val argsTupleType = rawFunction.functionType().argsTupleType
			val argumentTypes: List<A_Type>
			val generated: Boolean
			if (tryToGenerateSpecialPrimitiveInvocation)
			{
				// We are not recursing here from a primitive override of
				// tryToGenerateSpecialPrimitiveInvocation(), so try to generate
				// a special primitive invocation.  Note that this lookup was
				// monomorphic *in the event of success*, so we can safely
				// tighten the argument types here to conform to the only
				// possible found function.
				val manifest = currentManifest
				val strongArguments = (0 until argumentCount).map {
					val arg = arguments[it]
					val argSemanticValue = arg.semanticValue()
					val strongRestriction = arg.restriction()
						.intersection(manifest.restrictionFor(argSemanticValue))
						.intersectionWithType(argsTupleType.typeAtIndex(it + 1))
					manifest.setRestriction(argSemanticValue, strongRestriction)
					L2ReadBoxedOperand(
						argSemanticValue, strongRestriction, manifest)
				}
				argumentTypes = strongArguments.map { it.type() }
				generated = tryToGenerateSpecialInvocation(
					functionToCallReg,
					rawFunction,
					primitive,
					strongArguments,
					callSiteHelper)
			}
			else
			{
				// We are recursing here from a primitive override of
				// tryToGenerateSpecialPrimitiveInvocation(), so do not
				// recurse again; just generate the best invocation possible
				// given what we know.
				argumentTypes = arguments.mapIndexed { zeroIndex, argument ->
					argument.type().typeIntersection(
						argsTupleType.typeAtIndex(zeroIndex + 1))
				}
				if (primitive.fallibilityForArgumentTypes(argumentTypes)
					=== CallSiteCannotFail)
				{
					// The primitive cannot fail at this site. Output code
					// to run the primitive as simply as possible, feeding a
					// register with as strong a type as possible.
					var resultType = primitive.returnTypeGuaranteedByVM(
						rawFunction, argumentTypes)
					if (resultType.isBottom)
					{
						// Even though the P_InvokeWithTuple primitive can't
						// fail, the ultimately called function won't return.
						// In this case, weaken the resultType to avoid ⊥, just
						// to keep the call machinery happy.
						resultType = Types.ANY.o
					}
					val writer = generator.boxedWriteTemp(
						restrictionForType(resultType, BOXED_FLAG))
					addInstruction(
						L2_RUN_INFALLIBLE_PRIMITIVE.forPrimitive(primitive),
						L2ConstantOperand(rawFunction),
						L2PrimitiveOperand(primitive),
						L2ReadBoxedVectorOperand(arguments),
						writer)
					callSiteHelper.useAnswer(readBoxed(writer))
					generated = true
				}
				else
				{
					generated = false
				}
			}
			if (generated)
			{
				assert(!generator.currentlyReachable())
				return
			}
			// The raw function is known.  Ask the primitive what it guarantees
			// if successful, and take the union with what the raw function says
			// it'll produce if the primitive is unsuccessful.  Take into
			// account whether the primitive will never, always, or sometimes
			// fail


HJpZXMSQgoOZGhjcF9zZWNzX2VxXzAY0QggASgLMhwuZ29v'
    'Z2xlLnByb3RvYnVmLlVJbnQzMlZhbHVlUgtkaGNwU2Vjc0VxMBJCCg5kaGNwX3NlY3NfZ3RfMB'
    'jSCCABKAsyHC5nb29nbGUucHJvdG9idWYuVUludDMyVmFsdWVSC2RoY3BTZWNzR3QwEkQKD2Ro'
    'Y3Bfc2Vjc19ndF8xMBjTCCABKAsyHC5nb29nbGUucHJvdG9idWYuVUludDMyVmFsdWVSDGRoY3'
    'BTZWNzR3QxMBJECg9kaGNwX3NlY3NfZ3RfMzAY1AggASgLMhwuZ29vZ2xlLnByb3RvYnVmLlVJ'
    'bnQzMlZhbHVlUgxkaGNwU2Vjc0d0MzASRAoPZGhjcF9zZWNzX2d0XzYwGNUIIAEoCzIcLmdvb2'
    'dsZS5wcm90b2J1Zi5VSW50MzJWYWx1ZVIMZGhjcFNlY3NHdDYw');

@$core.Deprecated('Use starlink_router_alertsDescriptor instead')
const starlink_router_alerts$json = {
  '1': 'starlink_router_alerts',
  '2': [
    {'1': 'name', '3': 1, '4': 1, '5': 9, '10': 'name'},
    {'1': 'source', '3': 2, '4': 1, '5': 9, '10': 'source'},
    {'1': 'active', '3': 3, '4': 1, '5': 8, '10': 'active'},
    {'1': 'start', '3': 4, '4': 1, '5': 11, '6': '.SpaceX.API.Telemetron.Public.Common.TimestampInfo', '10': 'start'},
    {'1': 'end', '3': 5, '4': 1, '5': 11, '6': '.SpaceX.API.Telemetron.Public.Common.TimestampInfo', '10': 'end'},
  ],
};

/// Descriptor for `starlink_router_alerts`. Decode as a `google.protobuf.DescriptorProto`.
final $typed_data.Uint8List starlink_router_alertsDescriptor = $convert.base64Decode(
    'ChZzdGFybGlua19yb3V0ZXJfYWxlcnRzEhIKBG5hbWUYASABKAlSBG5hbWUSFgoGc291cmNlGA'
    'IgASgJUgZzb3VyY2USFgoGYWN0aXZlGAMgASgIUgZhY3RpdmUSSAoFc3RhcnQYBCABKAsyMi5T'
    'cGFjZVguQVBJLlRlbGVtZXRyb24uUHVibGljLkNvbW1vbi5UaW1lc3RhbXBJbmZvUgVzdGFydB'
    'JECgNlbmQYBSABKAsyMi5TcGFjZVguQVBJLlRlbGVtZXRyb24uUHVibGljLkNvbW


Light")
F_14:defineIndicatorLight("PLT_SPDBRK_FULL_LIGHT", 8308, "Gauges as Light", "PILOT Speedbrake Full Indicator as Light")
F_14:defineIndicatorLightRed("PLT_WEAPON_STORE_1A_STORE_L", 9221, "Gauges as Light", "PILOT Weapon Store 1A as Light (STORE)")
F_14:defineIndicatorLightRed("PLT_WEAPON_STORE_1B_STORE_L", 9222, "Gauges as Light", "PILOT Weapon Store 1B as Light (STORE)")
F_14:defineIndicatorLightRed("PLT_WEAPON_STORE_3_STORE_L", 9223, "Gauges as Light", "PILOT Weapon Store 3 as Light (STORE)")
F_14:defineIndicatorLightRed("PLT_WEAPON_STORE_4_STORE_L", 9224, "Gauges as Light", "PILOT Weapon Store 4 as Light (STORE)")
F_14:defineIndicatorLightRed("PLT_WEAPON_STORE_5_STORE_L", 9225, "Gauges as Light", "PILOT Weapon Store 5 as Light (STORE)")
F_14:defineIndicatorLightRed("PLT_WEAPON_STORE_6_STORE_L", 9226, "Gauges as Light", "PILOT Weapon Store 6 as Light (STORE)")
F_14:defineIndicatorLightRed("PLT_WEAPON_STORE_8B_STORE_L", 9227, "Gauges as Light", "PILOT Weapon Store 8B as Light (STORE)")
F_14:defineIndicatorLightRed("PLT_WEAPON_STORE_8A_STORE_L", 9228, "Gauges as Light", "PILOT Weapon Store 8A as Light (STORE)")
F_14:defineIndicatorLightGreen("PLT_WEAPON_STORE_1A_READY_L", 9221, "Gauges as Light", "PILOT Weapon Store 1A as Light (READY)")
F_14:defineIndicatorLightGreen("PLT_WEAPON_STORE_1B_READY_L", 9222, "Gauges as Light", "PILOT Weapon Store 1B as Light (READY)")
F_14:defineIndicatorLightGreen("PLT_WEAPON_STORE_3_READY_L", 9223, "Gauges as Light", "PILOT Weapon Store 3 as Light (READY)")
F_14:defineIndicatorLightGreen("PLT_WEAPON_STORE_4_READY_L", 9224, "Gauges as Light", "PILOT Weapon Store 4 as Light (READY)")
F_14:defineIndicatorLightGreen("PLT_WEAPON_STORE_5_READY_L", 9225, "Gauges as Light", "PILOT Weapon Store 5 as Light (READY)")
F_14:defineIndicatorLightGreen("PLT_WEAPON_STORE_6_READY_L", 9226, "Gauges as Light", "PILOT Weapon Store 6 as Light (READY)")
F_14:defineIndicatorLightGreen("PLT_WEAPON_STORE_8B_READY_L", 9227, "Gauges as Light", "PILOT Weapon Store 8B as Light (READY)")
F_14:defineIndicatorLightGreen("PLT_WEAPON_STORE_8A_READY_L", 9228, "Gauges as Light", "PILOT Weapon Store 8A as Light (READY)")
F_14:defineIndicatorLight("PLT_GEAR_NOSE_OFF_L", 8300, "Gauges as Light", "PILOT Nose Gear OFF Flag as Light")
F_14:defineIndicatorLight("PLT_GEAR_NOSE_IND_L", 8301, "Gauges as Light", "PILOT Nose Gear Indicator as Light")
F_14:defineIndicatorLight("PLT_GEAR_L_OFF_L", 8303, "Gauges as Light", "PILOT Left Gear OFF Flag as Ligh


using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Linq;
using Akka.Actor;
using Xunit;
using Xunit.Abstractions;

namespace Akka.Interfaced
{
    public class GracefulShutdownTest : TestKit.Xunit2.TestKit
    {
        public GracefulShutdownTest(ITestOutputHelper output)
            : base(output: output)
        {
        }

        public class TestGracefulShutdownActor : InterfacedActor, IWorker
        {
            private readonly LogBoard<string> _log;

            public TestGracefulShutdownActor(LogBoard<string> log)
            {
                _log = log;
            }

            protected override async Task OnGracefulStop()
            {
                _log.Add("OnGracefulStop");
                await Task.Delay(10);
                _log.Add("OnGracefulStop done");
            }

            async Task IWorker.Atomic(int id)
            {
                _log.Add($"Atomic({id})");
                await Task.Delay(10);
                _log.Add($"Atomic({id}) done");
            }

            [Reentrant]
            async Task IWorker.Reentrant(int id)
            {
                _log.Add($"Reentrant({id})");
                await Task.Delay(10);
                _log.Add($"Reentrant({id}) done");
            }
        }

        [Fact]
        public async Task GetInterfacedPoisonPill_WaitForAllAtomicHandlersDone()
        {
            // Arrange
            var log = new LogBoard<string>();
            var a =


06666z" fill="#C1272D" ></path><path d="M981.76 383.146667h-180.266667c11.52 0 20.906667 9.386667 20.906667 20.906666 0 233.386667-174.72 425.813333-400.426667 453.973334 18.773333 2.346667 37.76 3.626667 57.173334 3.626666h65.92c252.8 0 457.813333-205.013333 457.813333-457.813333-0.213333-11.306667-9.6-20.693333-21.12-20.693333z" fill="#A51620" ></path></symbol><symbol id="icon-icon-8" viewBox="0 0 1024 1024"><path d="M143.4 405.31c33.22-106.06 214-206 376-196s354 64 390 288-152 504.63-383 509.88c-227.97 5.17-497-237.88-383-601.88z" fill="#E8E8E8" ></path><path d="M149.9 376.47c16.54-52.8 163.49-163.49 355.48-165 219-1.71 343.94 107.35 362 219.83 36 224-152 504.63-383 509.88C256.43 946.36 35.9 740.47 149.9 376.47z" fill="#FFFFFF" ></path><path d="M149.9 376.47c16.54-52.8 163.49-163.49 355.48-165 219-1.71 343.94 107.35 362 219.83 36 224-152 504.63-383 509.88C256.43 946.36 35.9 740.47 149.9 376.47z" fill="#FFFFFF" ></path><path d="M538.52 216S498 483 592.44 651C662.68 776 811 835.31 811 835.31s231.82-295.53 10-518C717 213 538.52 216 538.52 216zM485.48 216S526 483 431.56 651C361.32 776 213 835.31 213 835.31s-231.82-295.53-10-518C307 213 485.48 216 485.48 216z" fill="#FFBD7B" ></path><path d="M656.87 223.48S724.37 123 781.37 81s135-63 135-63 73.5 52.5 72 154.49-24 136.49-24 136.49-21 144-45 174c0 0-54-130.49-114-183s-148.5-76.5-148.5-76.5z" fill="#FFBD7B" ></path><path d="M821 317.31c-43.83-44-100.87-68.86-152.22-83 117.9 37.69 185.67 116.44 198.62 197 20.19 125.6-30.07 269-118.83 371.69C784.5 824.7 811 835.31 811 835.31s231.85-295.53 10-518z" fill="#F4A660" ></path><path d="M373.39 223.48s-150-207-255-207S32.9 213 32.9 213l24 79.5 9 84L112.4 495s27-96 85.5-165 175.49-106.52 175.49-106.52z" fill="#FFBD7B" ></path><path d="M665.4 583.31m-24.5 0a24.5 24.5 0 1 0 49 0 24.5 24.5 0 1 0-49 0Z" fill="#FFFFFF" ></path><path d="M764.4 272.31s73-119 110-99-30 166-30 166z" fill="#FF7B7B" ></path><path d="M358.4 581.81m-24.5 0a24.5 24.5 0 1 0 49 0 24.5 24.5 0 1 0


// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0

using System.Diagnostics;
using System.Text;
using OpenTelemetry.Internal;

namespace OpenTelemetry.Context.Propagation;

/// <summary>
/// Extension methods to extract TraceState from string.
/// </summary>
internal static class TraceStateUtils
{
    private const int KeyMaxSize = 256;
    private const int ValueMaxSize = 256;
    private const int MaxKeyValuePairsCount = 32;

    /// <summary>
    /// Extracts tracestate pairs from the given string and appends it to provided tracestate list.
    /// </summary>
    /// <param name="traceStateString">String with comma separated tracestate key value pairs.</param>
    /// <param name="tracestate"><see cref="List{T}"/> to set tracestate pairs on.</param>
    /// <returns>True if string was parsed successfully and tracestate was recognized, false otherwise.</returns>
    internal static bool AppendTraceState(string traceStateString, List<KeyValuePair<string, string>> tracestate)
    {
        Debug.Assert(tracestate != null, "tracestate list cannot be null");

        if (string.IsNullOrEmpty(traceStateString))
        {
            return false;
        }

        bool isValid = true;
        try
        {
            var names = new HashSet<string>();

            var traceStateSpan = traceStateString.AsSpan().Trim(' ').Trim(',');
            do
            {
                // tracestate: rojo=00-0af7651916cd43dd8448eb211c80319c-00f067aa0ba902b7-01,congo=BleGNlZWRzIHRohbCBwbGVhc3VyZS4

                int pairEnd = traceStateSpan.IndexOf(',');
                if (pairEnd < 0)
                {
                    pairEnd = traceStateSpan.Length;
                }

                if (!TryParseKeyValue(traceStateSpan.Slice(0, pairEnd), out var key, out var value))
                {
                    isValid = false;
                    break;
                }

                var keyStr = key.ToString();
                if (names.Add(keyStr))
                {
                    tracestate!.Add(new KeyValuePair<string, string>(keyStr, value.ToString()));
                }
                else
                {
                    isValid = false;
                    break;
                }

                if (tracestate.Count > MaxKeyValuePairsCount)
                {
                    OpenTelemetryApiEventSource.Log.TooManyItemsInTracestate();
                    isValid = false;
                    break;
                }

                if (pairEnd == traceStateSpan.Length)
                {
                    break;
                }

                traceStateSpan = traceStateSpan.Slice(pairEnd + 1);
            }
            while (!traceStateSpan.IsEmpty);

            if (!isValid)
            {
                tracestate!.Clear();
                return false;
            }

            return true;
        }
        catch (Exception ex)
        {
            OpenTelemetryApiEventSource.Log.TracestateExtractException(ex);
        }

        return false;
    }

    internal static string GetString(IEnumerable<KeyValuePair<string, string>>? traceState)
    {
#pragma warning disable CA1851 // Possible multiple enumerations of 'IEnumerable' collection
        if (traceState == null || !traceState.Any())
        {
            return string.Empty;
        }

        // it's supposedly cheaper to iterate over very short collection a couple of times
        // than to convert it to array.
        var pairsCount = traceState.Count();
        if (pairsCount > MaxKeyValuePairsCount)
        {
            OpenTelemetryApiEventSource.Log.TooManyItemsInTracestate();
        }

        var sb = new StringBuilder();

        int ind = 0;
        foreach (var entry


-1.02 1.139a5.768 5.768 0 00-4.455-.165c-2.287.984-3.623 3.787-4.729 6.671a.434.434 0 00.674.498 5.708 5.708 0 015.44-.749L5.6 13.856a.432.432 0 00.187.479 19.184 19.184 0 013.863 3.857.433.433 0 00.482.188l1.963-.539a5.62 5.62 0 01-.749 5.456.436.436 0 00.499.674c2.883-1.109 5.686-2.443 6.665-4.722a5.767 5.767 0 00-.161-4.451c.395-.326.772-.672 1.133-1.036 3.381-3.44 5-8.241 4.392-13.026 0 0 .076-.352-.096-.524V.203zM21.339.87c.563 0 1.127.029 1.688.088.079.771.103 1.548.07 2.322a2.743 2.743 0 01-1.623-.771 2.686 2.686 0 01-.777-1.623c.209-.011.422-.018.636-.018l.006.002zM10.846 5.112A14.579 14.579 0 0119.828.94c.07.677.33 1.318.749 1.855l-2.698 2.697a3.522 3.522 0 00-4.946 4.946l-3.147 3.147a19.348 19.348 0 00-2.626-2.131 14.452 14.452 0 013.686-6.342zm7.524 3.159a2.657 2.657 0 01-2.657 2.66 2.659 2.659 0 01-.003-5.317h.003a2.658 2.658 0 012.657 2.657zM1.314 11.269c.941-2.254 2.09-4.268 3.779-4.994a4.792 4.792 0 013.559.09 15.357 15.357 0 00-2.265 4.668 6.079 6.079 0 00-5.074.233l.001.003zm8.891 6.19a21.538 21.538 0 00-3.683-3.677l.395-1.434a18.64 18.64 0 014.722 4.718l-1.434.393zm7.508 1.425c-.727 1.698-2.737 2.848-4.989 3.789a6.086 6.086 0 00.225-5.074 15.437 15.437 0 004.679-2.278 4.8 4.8 0 01.083 3.566l.002-.003zm-5.186-2.06a19.218 19.218 0 00-2.123-2.628l3.147-3.148a3.52 3.52 0 004.945-4.946l2.698-2.698a3.645 3.645 0 001.85.75 14.577 14.577 0 01-4.166 8.979 14.446 14.446 0 01-6.343 3.684l-.008.007z"/></svg>';
  static const String skynet =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="24" height="24" preserveAspectRatio="xMidYMid meet" viewBox="0 0 24 24"><path fill="currentColor" d="m0 6.46 21.389 11.297a.917.917 0 01.2 1.485h-.011a10.04 10.04 0 01-2.234 1.53c-6.912 3.474-14.991-1.837-14.543-9.56l2.86 1.975c.856 4.508 5.618 7.11 9.874 5.393zm8.647 3.151 14.366 5.679a.87.87 0 01.52 1.046v.018


"7605677598556816505", "fingers2_L" ],
   [ "5659928769071759416", "thumb1_L" ],
   [ "4160905267466177100", "index1_L" ],
   [ "4160905271777933619", "index2_L" ],
   [ "31052060296923197", "neck" ],
   [ "8513946362961011567", "shoulder_R" ],
   [ "4603981025052233954", "elbow_R" ],
   [ "2709397971726096358", "wrist_R" ],
   [ "7605677611475293152", "fingers1_R" ],
   [ "7605677598556816487", "fingers2_R" ],
   [ "5659928769071759398", "thumb1_R" ],
   [ "4160905267466177106", "index1_R" ],
   [ "4160905271777933613", "index2_R" ],
   [ "11743703306975505354", "sh_dogdish" ],
   [ "3284052096157759737", "sh_dogdishShape" ],
   [ "16238952091312578721", "maggie_meshShape" ],
   [ "8339538816886826125", "MotionRootShape" ],
   [ "9324413423443562827", "tv_glow_back.bmp" ],
   [ "16496045336639075077", "tv_glow_back2.bmp" ],
   [ "10422929630217262783", "glow2-blue.bmp" ],
   [ "8711862398251856874", "tv_glow_back2_m" ],
   [ "10204768480520196516", "tv_glow_back_m" ],
   [ "7240069740603248930", "glow2_blue_m" ],
   [ "2879278903058120429", "BQG_tvback_glow_billboardShape" ],
   [ "13924074929728943592", "tvback_glow_billboardShape" ],
   [ "11653525139834504186", "BQG_tvglow_blue_billboardShape" ],
   [ "12894031226421247775", "tvglow_blue_billboardShape" ],
   [ "14858505560522425386", "tvback_glow_billboardShape2" ],
   [ "1604190997543025761", "BQG_tvback_glow_billboardShape2" ],
   [ "5095709017672425392", "tvglow_blue_billboard" ],
   [ "2451399130202790553", "tvback_glow_billboard" ],
   [ "9063451646696049557", "tvback_glow_billboard2" ],
   [ "8792199540041888870", "mis04_01.png" ],
   [ "3318711332954932897", "l4_doorstars_shadow" ],
   [ "8320579577878298648", "l4_doorstars_shadow_controller" ],
   [ "5527872189521252812", "l4i02.p3d" ],
   [ "16478740569472660376", "l4z1.p3d" ],
   [ "10487588177812704437", "Oak_splinter_m" ],
   [ "14888722624075102245", "OakS_leaves_m" ],
   [ "2399311836046225767", "glow_add_m" ],
   [ "17074594601697698615", "glow_beam_m" ],
   [ "10351903111795943980", "PTRN_ned_switch1" ],
   [ "10552014825295531221", "ned_switch1" ],
   [ "798


break;
              };
              if (!AlreadyBad)
                if (Switch[3]==0)
                  CommentCharset=FilelistCharset=rch;
                else
                  for (int I=3;Switch[I]!=0 && !AlreadyBad;I++)
                    switch(etoupper(Switch[I]))
                    {
                      case 'C':
                        CommentCharset=rch;
                        break;
                      case 'L':
                        FilelistCharset=rch;
                        break;
                      default:
                        BadSwitch(Switch);
                        AlreadyBad=true;
                        break;
                    }
            }
            break;

        }
      break;
    case 'C':
      if (Switch[2]==0)
        switch(etoupper(Switch[1]))
        {
          case '-':
            DisableComment=true;
            break;
          case 'U':
            ConvertNames=NAMES_UPPERCASE;
            break;
          case 'L':
            ConvertNames=NAMES_LOWERCASE;
            break;
        }
      break;
    case 'K':
      switch(etoupper(Switch[1]))
      {
        case 'B':
          KeepBroken=true;
          break;
        case 0:
          Lock=true;
          break;
      }
      break;
#ifndef GUI
    case '?' :
      OutHelp();
      break;
#endif
    default :
      BadSwitch(Switch);
      break;
  }
}
#endif

#ifndef SFX_MODULE
void CommandData::BadSwitch(const char *Switch)
{
  mprintf(St(MUnknownOption),Switch);
  ErrHandler.Exit(USER_ERROR);
}
#endif

#ifndef GUI
void CommandData::OutTitle()
{
  if (BareOutput || DisableCopyright)
    return;
#if defined(__GNUC__) && defined(SFX_MODULE)
  mprintf(St(MCopyrightS));
#else
#ifndef SILENT
  static bool TitleShown=false;
  if (TitleShown)
    return;
  TitleShown=true;
  char Version[50];
  int Beta=RARVER_BETA;
  if (Beta!=0)
    sprintf(Version,"%d.%02d %s %d",RARVER_MAJOR,RARVER_MINOR,St(MBeta),RARVER_BETA);
  else
    sprintf(Version,"%d.%02d",RARVER_MAJOR,RARVER_MINOR);
#ifdef UNRAR
  mprintf(St(MUCopyright),Version,RARVER_YEAR);
#else
#endif
#endif
#endif
}
#endif

inline bool CmpMSGID(MSGID i1,MSGID i2)
{
#ifdef MSGID_INT
  return(i1==i2);
#else
  // If MSGID is const char*, we cannot compare pointers only.
  // Pointers to different instances of same strings can differ,
  // so we need to compare complete strings.
  return(strcmp(i1,i2)==0);
#endif
}

void CommandData::OutHelp()
{
#if !defined(GUI) && !defined(SILENT)
  OutTitle();
  static MSGID Help[]={
#ifdef SFX_MODULE
    // Console SFX switches definition.
    MCHelpCmd,MSHelpCmdE,MSHelpCmdT,MSHelpCmdV
#elif defined(UNRAR)
    // UnRAR switches definiti


 MapleMap map, final int portalid) {
        for (MapleCharacter chr : members) {
            chr.changeMap(map, map.getPortal(portalid));
        }
    }

    public void warpOut() {
        if (winner == true)
            warpOut(980000003 + (leader.getMonsterCarnival().getRoom() * 100));
        else
            warpOut(980000004 + (leader.getMonsterCarnival().getRoom() * 100));
    }

    public boolean allInMap(MapleMap map) {
        boolean status = true;
        for (MapleCharacter chr : members) {
            if (chr.getMap() != map) {
                status = false;
            }
        }
        return status;
    }

    public void removeMember(MapleCharacter chr) {
        members.remove(chr);
        chr.changeMap(980000010);
        chr.setMonsterCarnivalParty(null);
        chr.setMonsterCarnival(null);
    }

    public boolean isWinner() {
        return winner;
    }

    public void setWinner(boolean status) {
        winner = status;
    }

    public void displayMatchResult() {
        final String effect = winner ? "quest/carnival/win" : "quest/carnival/lose";

        for (final MapleCharacter chr : members) {
            chr.announce(MaplePacketCreator.showEffect(effect));
        }
    }

    public void summon() {
        this.summons--;
    }

    public boolean canSummon() {
        return this.summons > 0;
    }
}
package server.gachapon;

/**
*
* @author Alan (SharpAceX) - gachapon source classes stub
* @author Ronan - parsed MapleSEA loots
*
* MapleSEA-like loots thanks to AyumiLove - src: https://ayumilovemaple.wordpress.com/maplestory-gachapon-guide/
*/

public class MushroomShrine extends GachaponItems {

	@Override
	public int[] getCommonItems() {
		return new int [] {

                        /* Scroll */
                        2040305, 2040306, 2040308, 2044604, 2041039, 2041037, 2041035, 2041034, 2041041, 2040608, 2040605, 2040604, 2040611,
                        2040610, 2040813, 2040808, 2043004, 2040017, 2040015, 2040011, 2040013, 2040405, 2040406, 2040410, 2040511, 2040509,
                        2040508, 2040519, 2040521, 2040108, 2040904, 2040908, 2043104, 2044104, 2043005, 2043004, 2043006, 2044004, 2044205,
                        2043304, 2040607, 2040715, 2040713, 2044305, 2044904,

                        /* Common equipment */
                        1102040, 1002392, 1432009, 1002393, 1002394, 1082147, 1082148, 1032028, 1002585, 1002586, 1432013, 1022047, 1322027,
                        1012056, 1432018,

                        /* Beginner equipment */
                        1072264, 1072262, 1072263,

                        /* Warrior equipment */
                        1060074, 1322002, 1002340, 1442004, 1402037, 1422008, 1050022,

                        /* Mage equipment */
                        1382037, 1060014, 1051026, 1050056, 1050029, 1051030, 1382036, 1372032, 1041015, 1382015, 1372008, 1382008,

                        /* Bowman equipment */
                        1452018, 1041068, 1462007,

                        /* Thief equipment */
                        1060052, 1472013, 1002180


 Wilhelm at Light\'s Hope Chapel in the Eastern Plaguelands wants 8 Frozen Runes, 16 Enchanted Leathers, 5 Essences of Water, 5 Cured Rugged Hides and 300 gold. You must also be of Exalted reputation with the Argent Dawn.",
    ["T"] = "북극의 튜닉",
  },
  [9244] = {
    ["D"] = "Thanks to you and Omarion, may he rest in peace, I am now able to create Icy Scale bracers. All you need to do is bring me the materials and pay a small crafting fee.",
    ["O"] = "Craftsman Wilhelm at Light\'s Hope Chapel in the Eastern Plaguelands wants 4 Frozen Runes, 16 Heavy Scorpid Scales, 5 Essences of Water, 3 Cured Rugged Hides and 200 gold.",
    ["T"] = "얼어붙은 미늘 팔보호구",
  },
  [9245] = {
    ["D"] = "Thanks to you and Omarion (May he rest in peace), I am now able to create Icy Scale gauntlets. All you need to do is bring me the materials and pay a small crafting fee.",
    ["O"] = "Craftsman Wilhelm at Light\'s Hope Chapel in the Eastern Plaguelands wants 5 Frozen Runes, 16 Heavy Scorpid Scale, 5 Essence of Water, 3 Cured Rugged Hides and 200 gold.",
    ["T"] = "얼어붙은 미늘 건틀릿",
  },
  [9246] = {
    ["D"] = "Thanks to you and Omarion (May he rest in peace), I am now able to create an Icy Scale breastplate. All you need to do is bring me the materials and pay a small crafting fee.",
    ["O"] = "Craftsman Wilhelm at Light\'s Hope Chapel in the Eastern Plaguelands wants 8 Frozen Runes, 24 Heavy Scorpid Scale, 7 Essence of Water, 5 Cured Rugged Hides and 300 gold. You must also be of Exalted reputation with the Argent Dawn.",
    ["T"] = "얼어붙은 미늘 가슴보호갑",
  },
  [9247] = {
    ["D"] = "당신은 한때 은빛 여명회를 위해 봉사했으며 언제나 최선을 다했습니다. 지금 이 세계는 또다시 우리를 간절히 부르고 있습니다.$B$B다시 한 번 우리를 도와주실 생각이 있다면 동부 역병지대의 희망의 빛 예배당에 있는 기록 보관원에게 이 편지를 가져가시기 바랍니다.",
    ["O"] = "동부 역병지대의 희망의 빛 예배당에 있는 기록 보관원에게 기록 보관원의 편지를 가져가야 합니다.",
    ["T"] = "기록 보관원의 부름",
  },
  [9248] = {
    ["D"] = "이시누 알라. 심연의 군주가 죽었다는 증거를 보여 주십시오. 그러면 보상으로 퀴라지와 전투를 치를 때 도움이 될 만한 물건을 드리겠습니다.",
    ["O"] = "실리더스의 세나리온 요새에 있는 오렐 골드리프가 심연의 홀 1개를 가져다 달라고 했습니다. 또한 세나리온 의회로부터 우호적 평판을 얻어야 합니다.",
    ["T"] = "겸손한 제안",
  },
  [9249] = {
    ["D"] = "",
    ["O"] = "",
    ["T"] = "상품권 40매 - 설계도: 통통 전차 조종기",
  },
  [9252] = {
    ["D"] = "�


getMemberGroups() {
        return memberGroups;
    }

    public void setMembers(List<String> members) {
        this.members = members;
    }

    public void setMemberGroups(List<String> memberGroups) {
        this.memberGroups = memberGroups;
    }

    @XmlElementWrapper(name = "outcasts")
    @XmlElement(name = "outcast")
    public List<String> getOutcasts() {
        return outcasts;
    }

    @XmlElementWrapper(name = "outcastGroups")
    @XmlElement(name = "outcastGroup")
    public List<String> getOutcastGroups() {
        return outcastGroups;
    }

    public void setOutcasts(List<String> outcasts) {
        this.outcasts = outcasts;
    }

    public void setOutcastGroups(List<String> outcastGroups) {
        this.outcastGroups = outcastGroups;
    }

    @XmlElementWrapper(name = "admins")
    @XmlElement(name = "admin")
    public List<String> getAdmins() {
        return admins;
    }

    @XmlElementWrapper(name = "adminGroups")
    @XmlElement(name = "adminGroup")
    public List<String> getAdminGroups() {
        return adminGroups;
    }

    public void setAdmins(List<String> admins) {
        this.admins = admins;
    }

    public void setAdminGroups(List<String> adminGroups) {
        this.adminGroups = adminGroups;
    }

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

import java.awt.Color;
import java.awt.Cursor;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Insets;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

import javax.swing.Icon;
import javax.swing.JButton;

/**
 */
public class RosterMemberCallButton extends JButton implements MouseListener {

	private static final long serialVersionUID = 8056708231977922612L;
	private Icon normalIcon;
    private Icon hoverIcon;
    private Icon downIcon;
    private Image backgroundImage;
    private String text;

    private boolean selected;

    public RosterMemberCallButton(Image image, String text) {
        super();

        this.text = text;

        normalIcon = JinglePhoneRes.getImageIcon("ROSTERPANEL_BUTTON");
        hoverIcon = JinglePhoneRes.getImageIcon("ROSTERPANEL_BUTTON_HOVER");
        downIcon = JinglePhoneRes.getImageIcon("ROSTERPANEL_BUTTON_DOWN");
        backgroundImage = image;

        setIcon(normalIcon);

        decorate();

        addMouseListener(this);
    }

    /**
     * Decorates the button with the approriate UI configurations.
     */
    private void decorate() {
        setBorderPainted(false);
        setOpaque(true);

        setContentAreaFilled(false);
        setMargin(new Insets(0, 0, 0, 0));
    }

    public void mouseClicked(MouseEvent e) {
    }

    public void mousePressed(MouseEvent e) {
        setIcon(downIcon);
    }

    public void mouseReleased(MouseEvent e) {
        if (!selected) {
            setIcon(normalIcon);
        }

    }

    public void mouseEntered(MouseEvent e) {
        if


' => crate::pac::GPIOI::ptr() as _,
            'J' => crate::pac::GPIOJ::ptr() as _,
            'K' => crate::pac::GPIOK::ptr() as _,
            _ => crate::pac::GPIOA::ptr(),
        }
    }
}
use super::{ClusterChain, Directory, DirectoryEntry, FatEntry, FatType};
use crate::{
    byte_getter,
    fmt::{ByteArray, ByteString},
};
use core::{
    convert::TryFrom,
    fmt::{self, DebugStruct},
    mem,
    ops::Range,
    slice,
};

#[repr(C)]
pub(crate) struct BpbCommon {
    jump_boot: [u8; 3],             // offset:  0 ([u8; 3])
    oem_name: [u8; 8],              // offset:  3 ([u8; 8])
    bytes_per_sector: [u8; 2],      // offset: 11 (u16)
    sectors_per_cluster: [u8; 1],   // offset: 13 (u8)
    reserved_sector_count: [u8; 2], // offset: 14 (u16)
    num_fats: [u8; 1],              // offset: 16 (u8)
    root_entry_count: [u8; 2],      // offset: 17 (u16)
    total_sectors_16: [u8; 2],      // offset: 19 (u16)
    media: [u8; 1],                 // offset: 21 (u8)
    fat_size_16: [u8; 2],           // offset: 22 (u16)
    sectors_per_track: [u8; 2],     // offset: 24 (u16)
    num_heads: [u8; 2],             // offset: 26 (u16)
    hidden_sectors: [u8; 4],        // offset: 28 (u32)
    total_sectors_32: [u8; 4],      // offset: 32 (u32)
}
static_assertions::const_assert_eq!(mem::size_of::<BpbCommon>(), 36);
static_assertions::const_assert_eq!(mem::align_of::<BpbCommon>(), 1);

#[repr(C)]
struct BpbFat12_16 {
    common: BpbCommon,
    drive_number: [u8; 1],   // offset: 36 (u8)
    _reserved: [u8; 1],      // offset: 37 (u8)
    boot_signature: [u8; 1], // offset: 38 (u8)
    volume_id: [u8; 4],      // offset: 39 ([u8; 4])
    volume_label: [u8; 11],  // offset: 43 ([u8; 11])
    fs_type: [u8; 8],        // offset: 54 ([u8; 8])
    _boot_code: [u8; 448],   // offset: 62 ([u8; 448])
    boot_sign: [u8; 2],      // offset: 510 (u16)
}
static_assertions::const_assert_eq!(mem::size_of::<BpbFat12_16>(), 512);
static_assertions::const_assert_eq!(mem::align_of::<BpbFat12_16>(), 1);

#[repr(transparent)]
struct BpbFat12(BpbFat12_16);
#[repr(transparent)]
struct BpbFat16(BpbFat12_16);

#[repr(C)]
struct BpbFat32 {
    common: BpbCommon,
    fat_size_32: [u8; 4],        // offset: 36 (u32)
    ext_flags: [u8; 2],          // offset: 40 (u16)
    fs_version: [u8; 2],         // offset: 42 (u16)
    root_cluster: [u8; 4],       // offset: 44 (u32)
    fs_info: [u8; 2],            // offset: 48 (u16)
    backup_boot_sector: [u8; 2], // offset: 50 (u16)
    _reserved: [u8; 12],         // offset:


}% reduced Lightning Damage with Weapons"
			}
		},
		stats={
			[1]="weapon_lightning_damage_+%"
		}
	},
	[1967]={
		[1]={
			[1]={
				limit={
					[1]={
						[1]=1,
						[2]="#"
					}
				},
				text="{0}% increased Chaos Damage with Weapons"
			},
			[2]={
				[1]={
					k="negate",
					v=1
				},
				limit={
					[1]={
						[1]="#",
						[2]=-1
					}
				},
				text="{0}% reduced Chaos Damage with Weapons"
			}
		},
		stats={
			[1]="weapon_chaos_damage_+%"
		}
	},
	[1968]={
		[1]={
			[1]={
				limit={
					[1]={
						[1]=1,
						[2]="#"
					}
				},
				text="{0}% increased Spell Elemental Damage"
			}
		},
		stats={
			[1]="spell_elemental_damage_+%"
		}
	},
	[1969]={
		[1]={
			[1]={
				limit={
					[1]={
						[1]=1,
						[2]="#"
					}
				},
				text="Gain Added Chaos Damage equal to {0}% of Ward"
			}
		},
		stats={
			[1]="global_added_chaos_damage_%_of_ward"
		}
	},
	[1970]={
		[1]={
			[1]={
				limit={
					[1]={
						[1]="#",
						[2]="#"
					},
					[2]={
						[1]="#",
						[2]="#"
					}
				},
				text="{0} to {1} Added Physical Damage with Axe Attacks"
			}
		},
		stats={
			[1]="attack_minimum_added_physical_damage_with_axes",
			[2]="attack_maximum_added_physical_damage_with_axes"
		}
	},
	[1971]={
		[1]={
			[1]={
				limit={
					[1]={
						[1]="#",
						[2]="#"
					},
					[2]={
						[1]="#",
						[2]="#"
					}
				},
				text="{0} to {1} Added Physical Damage with Bow Attacks"
			}
		},
		stats={
			[1]="attack_minimum_added_physical_damage_with_bow",
			[2]="attack_maximum_added_physical_damage_with_bow"
		}
	},
	[1972]={
		[1]={
			[1]={
				limit={
					[1]={
						[1]="#",
						[2]="#"
					},
					[2]={
						[1]="#",
						[2]="#"
					}
				},
				text="{0} to {1} Added Physical Damage with Claw Attacks"
			}
		},
		stats={
			[1]="attack_minimum_added_physical_damage_with_claws",
			[2]="attack_maximum_added_physical_damage_with_claws"
		}
	},
	[1973]={
		[1]={
			[1]={
				[1]={
					k="reminderstring",
					v="ReminderTextDaggerRuneDagger"
				},
				limit={
					[1]={
						[1]="#",
						[2]="#"
					},
					[2]={
						[1]="#",
						[2]="#"
					}
				},
				text="{0} to {1} Added Physical Damage with Dagger Attacks"
			}
		},
		stats={
			[1]="attack_minimum_added_physical_damage_with_daggers",


 the maxVersion.
	 *     {@code 0} if the version is between minVersion and maxVersion.
	 */
	public static int compareVersionToRange(Version version, Version minVersion, Version maxVersion) {
		assert minVersion == null || maxVersion == null || minVersion.compareTo(maxVersion) < 0;
		if (version == null) {
			return Integer.MIN_VALUE;
		}
		if (minVersion != null && compareVersionsNoQualifier(version, minVersion) < 0) {
			return -1;
		}
		if (maxVersion != null && compareVersionsNoQualifier(version, maxVersion) >= 0) {
			return 1;
		}
		return 0;
	}

	private static int compareVersionsNoQualifier(Version firstVersion, Version secondVersion) {
		if (firstVersion == secondVersion) {
			return 0;
		}

		int result = firstVersion.getMajor() - secondVersion.getMajor();
		if (result != 0) {
			return result;
		}

		result = firstVersion.getMinor() - secondVersion.getMinor();
		if (result != 0) {
			return result;
		}

		return firstVersion.getMicro() - secondVersion.getMicro();
	}

	/** Null-safe comparison.
	 *
	 * @param <T> - type of the comparable element.
	 * @param object1 the first object.
	 * @param object2 the second object.
	 * @return Negative number if a lower than b.
	 *     Positive number if a greater than b.
	 * {@code 0} if a is equal to b.
	 */
	public static <T> int compareTo(Comparable<T> object1, T object2) {
		if (object1 == object2) {
			return 0;
		}
		if (object1 == null) {
			return Integer.MIN_VALUE;
		}
		if (object2 == null) {
			return Integer.MAX_VALUE;
		}
		assert object1 != null && object2 != null;
		return object1.compareTo(object2);
	}

	/** Replies the fully qualified name with generic parameters.
	 *
	 * @param type the type. Never {@code null}.
	 * @return the qualified name.
	 */
	public static String getNameWithTypeParameters(IType type) {
		assert type != null;
		final var superName = type.getFullyQualifiedName('.');
		try {
			final var typeParameters = type.getTypeParameters();
			if (typeParameters != null && typeParameters.length > 0) {
				final var buf = new StringBuffer(superName);
				buf.append('<');
				for (var k = 0; k < typeParameters.length; ++k) {
					if (k != 0) {
						buf.append(',').append(' ');
					}
					buf.append(typeParameters[k].getElementName());
				}
				buf.append('>');
				return buf.toString();
			}
		} catch (JavaModelException e) {
			// ignore
		}
		return superName;

	}

	/** Create the classpath library linked to the bundle with the given name.
	 *
	 * @param bundle the bundle to point to. Never {@code null}.
	 * @param precomputedBundlePath the path to the bundle that is already available. If {@code null},
	 *      the path is computed from the bundle with {@code org.eclipse.ui.internal.util.BundleUtility}.
	 * @param javadocURLs the mappings from the bundle to the javadoc URL. It is used for linking the javadoc to the bundle if
	 *      the bundle platform does not know the Javadoc file. If {@code null}, no mapping is defined.
	 * @return the classpath entry.
	 * @throws BundleException if a bundle cannot be resolved.
	 */
	public static IClasspathEntry newLibraryEntry(Bundle bundle, IPath precomputedBundlePath, BundleURLMappings javadocURLs) throws BundleException {
		if (bundle == null) {
			throw new ExpectingBundleException();
		}
		final IPath bundlePath;
		if (precomputedBundlePath == null) {
			bundlePath = Bundles.getBundlePath(bundle);
		} else {
			bundlePath = precomputedBundl


// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.

using System;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics;
using osu.Game.Beatmaps.ControlPoints;
using osu.Game.Beatmaps.Timing;
using osu.Game.Graphics.UserInterfaceV2;
using osu.Game.Overlays.Settings;

namespace osu.Game.Screens.Edit.Timing
{
    internal class TimingSection : Section<TimingControlPoint>
    {
        private SettingsSlider<double> bpmSlider;
        private SettingsEnumDropdown<TimeSignatures> timeSignature;
        private BPMTextBox bpmTextEntry;

        [BackgroundDependencyLoader]
        private void load()
        {
            Flow.AddRange(new Drawable[]
            {
                bpmTextEntry = new BPMTextBox(),
                bpmSlider = new BPMSlider(),
                timeSignature = new SettingsEnumDropdown<TimeSignatures>
                {
                    LabelText = "Time Signature"
                },
            });
        }

        protected override void OnControlPointChanged(ValueChangedEvent<TimingControlPoint> point)
        {
            if (point.NewValue != null)
            {
                bpmSlider.Current = point.NewValue.BeatLengthBindable;
                bpmSlider.Current.BindValueChanged(_ => ChangeHandler?.SaveState());

                bpmTextEntry.Bindable = point.NewValue.BeatLengthBindable;
                // no need to hook change handler here as it's the same bindable as above

                timeSignature.Current = point.NewValue.TimeSignatureBindable;
                timeSignature.Current.BindValueChanged(_ => ChangeHandler?.SaveState());
            }
        }

        protected override TimingControlPoint CreatePoint()
        {
            var reference = Beatmap.Value.Beatmap.ControlPointInfo.TimingPointAt(SelectedGroup.Value.Time);

            return new TimingControlPoint
            {
                BeatLength = reference.BeatLength,
                TimeSignature = reference.TimeSignature
            };
        }

        private class BPMTextBox : LabelledTextBox
        {
            private readonly BindableNumber<double> beatLengthBindable = new TimingControlPoint().BeatLengthBindable;

            public BPMTextBox()
            {
                Label = "BPM";

                OnCommit += (val, isNew) =>
                {
                    if (!isNew) return;

                    try
                    {
                        if (double.TryParse(Current.Value, out double doubleVal) && doubleVal > 0)
                            beatLengthBindable.Value = beatLengthToBpm(doubleVal);
                    }
                    catch
                    {


1, Windows 10 v20H2
    // dxgkrnl.sys PAGE:0x238320, 0x762b0 bytes
    // dxgkrnl.sys PAGE:0x369580, 0x84380 bytes
    // dxgkrnl.sys PAGE:0x238450, 0x762b0 bytes
    //
    _n4(sdk::unknown_ptr) vm_bus_channel_suspend;

    // [VmBusCloseAdapter@DXG_HOST_VIRTUALGPU_VMBUS]
    // Ldr = [dxgkrnl.sys]
    // => Windows 10 v2004, Windows 11, Windows 10 v20H2
    // dxgkrnl.sys PAGE:0x238360, 0x762b0 bytes
    // dxgkrnl.sys PAGE:0x3695c0, 0x84380 bytes
    // dxgkrnl.sys PAGE:0x238490, 0x762b0 bytes
    //
    _n5(sdk::unknown_ptr) vm_bus_close_adapter;

    // [VmBusCommandTableVgpuToHost@DXG_HOST_VIRTUALGPU_VMBUS]
    // Ldr = [dxgkrnl.sys]
    // => Windows 10 v2004, Windows 11, Windows 10 v20H2
    // dxgkrnl.sys .rdata:0x70620, 0x762b0 bytes
    // dxgkrnl.sys .rdata:0x871d0, 0x84380 bytes
    // dxgkrnl.sys .rdata:0x70620, 0x762b0 bytes
    //
    _n6(sdk::unknown_ptr) vm_bus_command_table_vgpu_to_host;

    // [VmBusCreateAllocation@DXG_HOST_VIRTUALGPU_VMBUS]
    // Ldr = [dxgkrnl.sys]
    // => Windows 10 v2004, Windows 11, Windows 10 v20H2
    // dxgkrnl.sys PAGE:0x2384c0, 0x762b0 bytes
    // dxgkrnl.sys PAGE:0x369730, 0x84380 bytes
    // dxgkrnl.sys PAGE:0x2385f0, 0x762b0 bytes
    //
    _n7(sdk::unknown_ptr) vm_bus_create_allocation;

    // [VmBusCreateContextVirtual@DXG_HOST_VIRTUALGPU_VMBUS]
    // Ldr = [dxgkrnl.sys]
    // => Windows 10 v2004, Windows 11, Windows 10 v20H2
    // dxgkrnl.sys PAGE:0x238db0, 0x762b0 bytes
    // dxgkrnl.sys PAGE:0x36a240, 0x84380 bytes
    // dxgkrnl.sys PAGE:0x238ee0, 0x762b0 bytes
    //
    _n8(sdk::unknown_ptr) vm_bus_create_context_virtual;

    // [VmBusCreateDevice@DXG_HOST_VIRTUALGPU_VMBUS]
    // Ldr = [dxgkrnl.sys]
    // => Windows 10 v2004, Windows 11, Windows 10 v20H2
    // dxgkrnl.sys PAGE:0x238f40, 0x762b0 bytes
    // dxgkrnl.sys PAGE:0x36a440, 0x84380 bytes
    // dxgkrnl.sys PAGE:0x239070, 0x762b0 bytes
    //
    _n9(sdk::unknown_ptr) vm_bus_create_device;

    // [VmBusCreateHwQueue@DXG_HOST_VIRTUALGPU_VMBUS]
    // Ldr = [dxgkrnl.sys]
    // => Windows 10 v2004, Windows 11, Windows 10 v20H2
    // dxgkrnl.sys PAGE:0x239330, 0x762b0 bytes
    // dxgkrnl.sys PAGE:0x36a900, 0x84380 bytes
    // dxgkrnl.sys PAGE:0x239460, 0x762b0 bytes
    //
    _o0(sdk::unknown_ptr


2022_H5N1|OQ958812.1|2022-04-04", "frac_divergence": 0.004, "retained": true}, {"name": "A/Backyard_bird/New_York/22-010321-003/2022_H5N1|OQ958820.1|2022-04-04", "frac_divergence": 0.004, "retained": true}, {"name": "A/Backyard_bird/North_Carolina/22-009583-001/2022_H5N1|OQ958828.1|2022-03-27", "frac_divergence": 0.0, "retained": true}, {"name": "A/Backyard_bird/North_Dakota/22-010141-001/2022_H5N1|OQ958836.1|2022-04-04", "frac_divergence": 0.002, "retained": true}, {"name": "A/Backyard_bird/North_Dakota/22-010657-001/2022_H5N1|OQ958844.1|2022-04-06", "frac_divergence": 0.0, "retained": true}, {"name": "A/Backyard_bird/North_Dakota/22-010657-002/2022_H5N1|OQ958852.1|2022-04-06", "frac_divergence": 0.0, "retained": true}, {"name": "A/Backyard_bird/North_Dakota/22-010977-001/2022_H5N1|OQ958860.1|2022-04-10", "frac_divergence": 0.0, "retained": true}, {"name": "A/Backyard_bird/North_Dakota/22-010977-003/2022_H5N1|OQ958868.1|2022-04-10", "frac_divergence": 0.002, "retained": true}, {"name": "A/Backyard_bird/North_Dakota/22-011778-001/2022_H5N1|OQ958876.1|2022-04-18", "frac_divergence": 0.0, "retained": true}, {"name": "A/Backyard_bird/North_Dakota/22-012100-001/2022_H5N1|OQ958884.1|2022-04-19", "frac_divergence": 0.0, "retained": true}, {"name": "A/Backyard_bird/Ohio/22-009419-001/2022_H5N1|OQ958892.1|2022-03-26", "frac_divergence": 0.002, "retained": true}, {"name": "A/Backyard_bird/South_Dakota/22-009194-002/2022_H5N1|OQ958900.1|2022-03-25", "frac_divergence": 0.002, "retained": true}, {"name": "A/Backyard_bird/Virginia/22-004415-001/2022_H5N1|OQ958908.1|2022-02-11", "frac_divergence": 0.0, "retained": true}, {"name": "A/Backyard_bird/Wisconsin/22-009934-002/2022_H5N1|OQ958916.1|2022-03-31", "frac_divergence": 0.002, "retained": true}, {"name": "A/Backyard_bird/Wisconsin/22-010325-001/2022_H5N1|OQ958924.1|2022-04-05", "frac_divergence": 0.002, "retained": true}, {"name": "A/Backyard_bird/Wisconsin/22-010325-003/2022_H5N1|OQ958932.1|2022-04-05", "frac_divergence": 0.004, "retained": true}, {"name": "A/Backyard_bird/Wisco