} else if field_index == 1 {
        Box::new(sqlx::query!(
            "DELETE FROM casbin_rule WHERE
                    ptype = $1 AND
                    (v1 is NULL OR v1 = $2) AND
                    (v2 is NULL OR v2 = $3) AND
                    (v3 is NULL OR v3 = $4) AND
                    (v4 is NULL OR v4 = $5) AND
                    (v5 is NULL OR v5 = $6)",
            pt,
            field_values[1],
            field_values[2],
            field_values[3],
            field_values[4],
            field_values[5]
        ))
    } else {
        Box::new(sqlx::query!(
            "DELETE FROM casbin_rule WHERE
                    ptype = $1 AND
                    (v0 is NULL OR v0 = $2) AND
                    (v1 is NULL OR v1 = $3) AND
                    (v2 is NULL OR v2 = $4) AND
                    (v3 is NULL OR v3 = $5) AND
                    (v4 is NULL OR v4 = $6) AND
                    (v5 is NULL OR v5 = $7)",
            pt,
            field_values[0],
            field_values[1],
            field_values[2],
            field_values[3],
            field_values[4],
            field_values[5]
        ))
    };

    boxed_query
        .execute(conn)
        .await
        .map(|n| PgQueryResult::rows_affected(&n) >= 1)
        .map_err(|err| CasbinError::from(AdapterError(Box::new(Error::SqlxError(err)))))
}

#[cfg(feature = "sqlite")]
pub async fn remove_filtered_policy(
    conn: &ConnectionPool,
    pt: &str,
    field_index: usize,
    field_values: Vec<String>,
) -> Result<bool> {
    let field_values = normalize_casbin_rule(field_values, field_index);
    let boxed_query = if field_index == 5 {
        Box::new(sqlx::query!(
            "DELETE FROM casbin_rule WHERE
                    ptype = $1 AND
                    (v5 is NULL OR v5 = $2)",
            pt,
            field_values[5]
        ))
    } else if field_index == 4 {
        Box::new(sqlx::query!(
            "DELETE FROM casbin_rule WHERE
                    ptype = ?1 AND
                    (v4 is NULL OR v4 = ?2) AND
                    (v5 is NULL OR v5 = ?3)",
            pt,
            field_values[4],
            field_values[5]
        ))
    } else if field_index == 3 {
        Box::new(sqlx::query!(
            "DELETE FROM casbin_rule WHERE
                    ptype = ?1 AND
                    (v3 is NULL OR v3 = ?2) AND
                    (v4 is NULL OR v4 = ?3) AND
                    (v5 is NULL OR v5 = ?4)",
            pt,
            field_values[3],
            field_values[4],
            field_values[5]
        ))
    } else if field_index == 2 {
        Box::new(sqlx::query!(
            "DELETE FROM casbin_rule WHERE
                    ptype = ?1 AND
                    (v2 is NULL OR v2 = ?2) AND
                    (v3 is NULL OR v3 = ?3) AND
                    (v4 is NULL OR v4 = ?4) AND
                    (v5 is NULL OR v5 = ?5)",
            pt,
            field_values[2],
            field_values[3],
            field_values[4],
            field_values[5]
        ))
    } else if field_index == 1 {
        Box::new(sqlx::query!(
            "DELETE FROM casbin_rule WHERE
                    ptype = ?1 AND
                    (v1 is NULL OR v1 = ?2) AND
                    (v2 is NULL OR v2 = ?3) AND
                    (v3 is NULL OR v3 = ?4) AND
                    (v4 i


        node.anchor?.destroy()
        animationJobs[node]?.cancel()
    }

    fun removeArrowWithAnim(node: ArNode) {
        node.model as ViewRenderable? ?: throw Exception("No view renderable")
        node.animateViewDisappear(arrowScale, arrowAnimationDelay, arrowAnimationPart)
    }

    fun removeLabelWithAnim(node: ArNode) {
        node.model as ViewRenderable? ?: throw Exception("No view renderable")
        node.animateViewDisappear(arrowScale, labelAnimationDelay, labelAnimationPart)
    }

    fun drawLine(
        from: ArNode,
        to: ArNode,
        modelsToLinkModels: MutableBiMap<Pair<ArNode, ArNode>, ArNode>,
        surfaceView: ArSceneView
    ){

        val fromVector = from.position.toVector3()
        val toVector = to.position.toVector3()

        // Compute a line's length
        val lineLength = Vector3.subtract(fromVector, toVector).length()

        // Prepare a color
        val colorOrange = com.google.ar.sceneform.rendering.Color(Color.parseColor("#ffffff"))

        // 1. make a material by the color
        MaterialFactory.makeOpaqueWithColor(fragment.requireContext(), fragment.lifecycle, colorOrange)
            .thenAccept { material: Material? ->
                // 2. make a model by the material
                val model = ShapeFactory.makeCylinder(
                    fragment.lifecycle,
                    0.01f, lineLength,
                    Vector3(0f, lineLength / 2, 0f), material
                )

                model.isShadowCaster = false
                model.isShadowReceiver = false

                // 3. make node
                val node = ArNode()
                node.setModel(model)
                node.parent = from
                surfaceView.addChild(node)

                // 4. set rotation
                val difference = Vector3.subtract(toVector, fromVector)
                val directionFromTopToBottom = difference.normalized()
                val rotationFromAToB: Quaternion =
                    Quaternion.lookRotation(
                        directionFromTopToBottom,
                        Vector3.up()
                    )

                val rotation = Quaternion.multiply(
                    rotationFromAToB,
                    Quaternion.axisAngle(Vector3(1.0f, 0.0f, 0.0f), 270f)
                )

                node.modelQuaternion = rotation.toNewQuaternion()
                node.position = from.position

                modelsToLinkModels[Pair(from, to)] = node
            }
    }

    private fun ArNode.animateViewAppear(targetScale: Scale, delay: Long, part: Int) {
        animateView(true, targetScale, delay, part, end = null)
    }

    private fun ArNode.animateViewDisappear(targetScale: Scale, delay: Long, part: Int) {
        animateView(false, targetScale, delay, part) {
            removeNode(it)
        }
    }

    private fun ArNode.animateView(appear: Boolean, targetScale: Scale, delay: Long, part: Int, end: ((ArNode) -> Unit)?) {
        val renderable = this.model as ViewRenderable? ?: throw Exception("No view renderable")
        var size = renderable.sizer.getSize(renderable.view)
        val xPart = targetScale.x/part
        val yPart = targetScale.y/part
        val zPart = targetScale.z/part
        animationJobs[this]?.cancel()
        animationJobs[this] = fragment.viewLifecycleOwner.lifecycleScope.launch {
            while (true) {
                if (size.x >= targetScale.toVector3().x && appear) {
                    break
                }
                else if(size.x <= 0 && !appear){
                    break


    private fun sortByKeyIfNeeded(
        entries: Collection<Map.Entry<String, JsonElement>>,
        comparator: Comparator<String>?
    ): Collection<Map.Entry<String, JsonElement>> {
        if (comparator == null) return entries
        return entries.sortedWith(java.util.Map.Entry.comparingByKey(comparator))
    }
}
/*
 * This file is part of the Krypton project, licensed under the Apache License v2.0
 *
 * Copyright (C) 2021-2023 KryptonMC and the contributors of the Krypton project
 *
 * 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.kryptonmc.krypton.util.bits

class ZeroBitStorage(size: Int) : AbstractBitStorage(size) {

    override val bits: Int
        get() = 0
    override val data: LongArray
        get() = RAW

    override fun getAndSet(index: Int, value: Int): Int {
        checkIndex(index)
        checkValue(value)
        return 0
    }

    override fun get(index: Int): Int {
        checkIndex(index)
        return 0
    }

    override fun set(index: Int, value: Int) {
        checkIndex(index)
        checkValue(value)
    }

    private fun checkValue(value: Int) {
        require(value == 0) { "Value must be 0, was $value!" }
    }

    override fun forEach(consumer: StorageConsumer) {
        for (i in 0 until size) {
            consumer.accept(i, 0)
        }
    }

    override fun unpack(output: IntArray) {
        output.fill(0)
    }

    override fun copy(): BitStorage = this

    companion object {

        private val RAW = LongArray(0)
    }
}
/*
 * This file is part of the Krypton project, licensed under the Apache License v2.0
 *
 * Copyright (C) 2021-2023 KryptonMC and the contributors of the Krypton project
 *
 * 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.kryptonmc.krypton.util.random

import kotlin.math.ln
import kotlin.math.sqrt

class MarsagliaPolarGaussian(private val randomSource: RandomSource) {

    private var nextNextGaussian = 0.0
    private var haveNextNextGaussian = false

    fun reset() {
        haveNextNextGaussian = false
    }

    fun nextGaussian(): Double {
        if (haveNextNextGaussian) {
            haveNextNextGaussian = false
            return nextNextGaussian
        }
        var u: Double
        var v: Double
        var s: Double
        do {
            u = randomSource.nextDouble() * 2.0 - 1.0
            v = randomSource.nextDouble() * 2.0 - 1.0
            s = u * u + v * v
        } while (s >= 1.0 || s == 0.0)
        val result = sqrt(-2.0 * ln(s) / s)
        nextNextGaussian = v * s
        haveNext


        let mut number_of_G_y = self.NUMBER_OF_ATTRIBUTES;

        if number_of_G_y < 3 {
            number_of_G_y = 3;
        }

        for i in 0..number_of_G_y as usize {
            v.extend(self.G_y[i].compress().to_bytes().iter());
        }

        for i in 0..self.NUMBER_OF_ATTRIBUTES as usize {
            v.extend(self.G_m[i].compress().to_bytes().iter());
        }

        v.extend(self.G_V.compress().to_bytes().iter());
        v.extend(self.G_a.compress().to_bytes().iter());
        v.extend(self.G_a0.compress().to_bytes().iter());
        v.extend(self.G_a1.compress().to_bytes().iter());
        v
    }
}

impl_serde_with_to_bytes_and_from_bytes!(SystemParameters,
                                         "A valid byte sequence representing a SystemParameters");

impl SystemParameters {
    /// Generate the [`SystemParameters`] randomly via an RNG.
    ///
    /// In order to never have a secret scalar in memory for generating the
    /// orthogonal basepoint, this method can be used to obtain bytes from the
    /// `csprng` and attempt to decompress them into a basepoint.
    pub fn hash_and_pray<R>(
        csprng: &mut R,
        number_of_attributes: u32,
    ) -> Result<SystemParameters, CredentialError>
    where
        R: RngCore + CryptoRng,
    {
        let mut tmp: [u8; 32] = [0u8; 32];
        let mut G_w: Option<RistrettoPoint> = None;
        let mut G_w_prime: Option<RistrettoPoint> = None;
        let mut G_x_0: Option<RistrettoPoint> = None;
        let mut G_x_1: Option<RistrettoPoint> = None;
        let mut G_y: Vec<RistrettoPoint> = Vec::with_capacity(number_of_attributes as usize);
        let mut G_m: Vec<RistrettoPoint> = Vec::with_capacity(number_of_attributes as usize);
        let mut G_V: Option<RistrettoPoint> = None;
        let mut G_a: Option<RistrettoPoint> = None;
        let mut G_a0: Option<RistrettoPoint> = None;
        let mut G_a1: Option<RistrettoPoint> = None;

        while G_w.is_none() {
            csprng.fill_bytes(&mut tmp);
            G_w = CompressedRistretto(tmp).decompress();
        }

        while G_w_prime.is_none() {
            csprng.fill_bytes(&mut tmp);
            G_w_prime = CompressedRistretto(tmp).decompress();
        }

        while G_x_0.is_none() {
            csprng.fill_bytes(&mut tmp);
            G_x_0 = CompressedRistretto(tmp).decompress();
        }

        while G_x_1.is_none() {
            csprng.fill_bytes(&mut tmp);
            G_x_1 = CompressedRistretto(tmp).decompress();
        }

        // The number of elements in G_y must always be at least three in order
        // to support encrypted group element attributes.
        let mut number_of_G_y: usize = number_of_attributes as usize;

        if number_of_G_y < 3 {
            number_of_G_y = 3;
        }

        for _ in 0..number_of_G_y {
            let mut G_y_i: Option<Ristretto


##############################################################################
# For copyright and license notices, see __manifest__.py file in module root
# directory
##############################################################################
from . import res_partner_update_from_padron_wizard
from . import upload_certificate_wizard


#userTextInput').val(userInput);
	}
	if ((typeof userInput !== "string") || (userInput.length = 0)) {
		$("tr").show();
	}
	else {
		$("#tb_body").find("tr").hide();
		var re = new RegExp(userInput, "i");
		$("tr").filter(function () { return re.test($(this).find(".tb_col1").text());}).show();
	}
}

</script>

<!DOCTYPE html>

  <meta charset="utf-8">
  <meta name="description" content="STEPBible reports on Places (Maps)">
  <title>STEP with another frame</title>
  <link rel="shortcut icon" href="/images/step-favicon.ico"/>

  Adjust width:<input type="range" min="30" max="70" value="50" id="myRange">
  2nd URL:<input type="url" id="url2">

	<button id="createURL" type="button" title="copy URL to clipboard" onclick="copyURLToClipboard()" onmouseout="outFunc()">
	Copy to clipboardCopy URL</button>


ssage2.set_optional_string(message1.optional_string());
  message1.set_optional_string("something else");

  // This tests concatenating.
  message2.add_repeated_int32(message1.repeated_int32(1));
  int32 i = message1.repeated_int32(0);
  message1.clear_repeated_int32();
  message1.add_repeated_int32(i);

  message1.MergeFrom(message2);

  TestUtil::ExpectAllFieldsSet(message1);
}

#if !defined(PROTOBUF_TEST_NO_DESCRIPTORS) || \
    !defined(GOOGLE_PROTOBUF_NO_RTTI)
#ifdef PROTOBUF_HAS_DEATH_TEST

TEST(GeneratedMessageTest, MergeFromSelf) {
  unittest::TestAllTypes message;
  EXPECT_DEATH(message.MergeFrom(message), "&from");
  EXPECT_DEATH(message.MergeFrom(implicit_cast<const Message&>(message)),
               "&from");
}

#endif  // PROTOBUF_HAS_DEATH_TEST
#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS || !GOOGLE_PROTOBUF_NO_RTTI

// Test the generated SerializeWithCachedSizesToArray(),
TEST(GeneratedMessageTest, SerializationToArray) {
  unittest::TestAllTypes message1, message2;
  string data;
  TestUtil::SetAllFields(&message1);
  int size = message1.ByteSize();
  data.resize(size);
  uint8* start = reinterpret_cast<uint8*>(string_as_array(&data));
  uint8* end = message1.SerializeWithCachedSizesToArray(start);
  EXPECT_EQ(size, end - start);
  EXPECT_TRUE(message2.ParseFromString(data));
  TestUtil::ExpectAllFieldsSet(message2);

}

TEST(GeneratedMessageTest, PackedFieldsSerializationToArray) {
  unittest::TestPackedTypes packed_message1, packed_message2;
  string packed_data;
  TestUtil::SetPackedFields(&packed_message1);
  int packed_size = packed_message1.ByteSize();
  packed_data.resize(packed_size);
  uint8* start = reinterpret_cast<uint8*>(string_as_array(&packed_data));
  uint8* end = packed_message1.SerializeWithCachedSizesToArray(start);
  EXPECT_EQ(packed_size, end - start);
  EXPECT_TRUE(packed_message2.ParseFromString(packed_data));
  TestUtil::ExpectPackedFieldsSet(packed_message2);
}

// Test the generated SerializeWithCachedSizes() by forcing the buffer to write
// one byte at a time.
TEST(GeneratedMessageTest, SerializationToStream) {
  unittest::TestAllTypes message1, message2;
  TestUtil::SetAllFields(&message1);
  int size = message1.ByteSize();
  string data;
  data.resize(size);
  {
    // Allow the output stream to buffer only one byte at a time.
    io::ArrayOutputStream array_stream(string_as_array(&data), size, 1);
    io::CodedOutputStream output_stream(&array_stream);
    message1.SerializeWithCachedSizes(&output_stream);
    EXPECT_FALSE(output_stream.HadError());
    EXPECT_EQ(size, output_stream.ByteCount());
  }
  EXPECT_TRUE(message2.ParseFromString(data));
  TestUtil::ExpectAllFieldsSet(message2);

}

TEST(GeneratedMessageTest, PackedFieldsSerializationToStream) {
  unittest::TestPackedTypes message1, message2;
  TestUtil::SetPackedFields(&message1);
  int size = message1.ByteSize();
  string data;
  data.resize(size);
  {
    // Allow the output stream to buffer only one byte at a time.
    io::ArrayOutputStream array_stream(string_as_array(&data), size, 1);
    io::CodedOutputStream output_stream


-azul-claro);
      border-radius: 3px;
    }

    ::-webkit-scrollbar-thumb:hover {
      background: #0077b6;
    }
  </style>

      SpeedCool

      <button class="theme-button" onclick="toggleTheme()" aria-label="Alternar tema">
        <svg class="sun" viewBox="0 0 24 24"><path d="M6.76 4.84l-1.8-1.79L3.5 4.5l1.79 1.8 1.47-1.46zm10.45 0l1.47 1.46 1.79-1.8-1.46-1.47-1.8 1.79zM12 4V1h-1v3h1zm0 19v-3h-1v3h1zm8-10h3v-1h-3v1zM1 13h3v-1H1v1zm16.24 6.76l1.8 1.79 1.46-1.46-1.79-1.8-1.47 1.47zM4.84 17.24l-1.79 1.8 1.46 1.46 1.8-1.79-1.47-1.47zM12 6a6 6 0 100 12 6 6 0 000-12z"/></svg>
        <svg class="moon" viewBox="0 0 24 24"><path d="M21 12.79A9 9 0 0111.21 3a7 7 0 108.58 8.58 8.96 8.96 0 011.21 1.21z"/></svg>
      </button>

      <button class="menu-button" onclick="toggleMenu()" aria-label="Abrir menu" id="menuButton">

      </button>

    Sobre
    Recursos
    Como Usar
    GitHub Oficial
    Grupo no Telegram

      <button onclick="changeLanguage('pt')" id="lang-pt">Português</button>
      <button onclick="changeLanguage('en')" id="lang-en">English</button>
      <button onclick="changeLanguage('es')" id="lang-es">Español</button>
      <button onclick="changeLanguage('ru')" id="lang-ru">Русский</button>

SpeedCool

Resfriamento inteligente. Desempenho adaptativo. Total controle térmico no seu Android.

Sobre o SpeedCool

        SpeedCool é um módulo Magisk feito para melhorar o desempenho do seu celular sem deixar ele esquentar demais.
        Com inteligência térmica, modos por aplicativo e perfis que se adaptam ao uso, ele entrega mais fluidez, menor aquecimento e mais controle sobre o sistema.

Recursos Principais

        <li data-i18


 "0")
							append("ageVerificationForm.ageVerification", "PROHIBITED")
							append("placeVerificationForm.placeToVerify", "02760401100000")
							append("placeVerificationForm.placeVerification", "PROHIBITED")
							append("eidTypesForm.cardCertified", "ALLOWED")
							append("eidTypesForm.seCertified", "ALLOWED")
							append("eidTypesForm.seEndorsed", "ALLOWED")
							append("eidTypesForm.hwKeyStore", "ALLOWED")
							append("transactionInfo", "")
							append("levelOfAssurance", "BUND_HOCH")
							append("transactionAttestationForm.selectedTransactionAttestation", "")
							append("transactionAttestationForm.selectedContextData", "null")
							append("transactionAttestationForm.contextInformation", "")
						},
				) {
				}.headers["Location"]
		checkNotNull(localhostUrl)
		val tokenUrl = Url(localhostUrl).parameters["tcTokenURL"]
		return checkNotNull(tokenUrl)
	}
}
package org.openecard.addons.tr03124.eac

import io.github.oshai.kotlinlogging.KotlinLogging
import org.openecard.addons.tr03124.BindingResponse
import org.openecard.addons.tr03124.InvalidServerData
import org.openecard.addons.tr03124.UserCanceled
import org.openecard.addons.tr03124.runEacCatching
import org.openecard.addons.tr03124.transport.EidServerInterface
import org.openecard.addons.tr03124.transport.EserviceClient
import org.openecard.addons.tr03124.xml.DidAuthenticateRequest
import org.openecard.addons.tr03124.xml.Eac1Input
import org.openecard.addons.tr03124.xml.Eac1Output
import org.openecard.addons.tr03124.xml.Eac2Input
import org.openecard.addons.tr03124.xml.EacAdditionalInput
import org.openecard.addons.tr03124.xml.TcToken
import org.openecard.cif.bundled.NpaDefinitions
import org.openecard.cif.definition.acl.PaceAclQualifier
import org.openecard.sal.iface.DeviceConnection
import org.openecard.sal.iface.DeviceUnsupported
import org.openecard.sal.iface.dids.PaceDid
import org.openecard.sal.sc.SmartcardDeviceConnection
import org.openecard.sal.sc.SmartcardSalSession
import org.openecard.sal.sc.dids.SmartcardPaceDid
import org.openecard.sc.iface.CardDisposition
import org.openecard.sc.iface.feature.PaceEstablishChannelResponse
import org.openecard.sc.iface.feature.PacePinId
import org.openecard.sc.pace.asn1.EfCardAccess.Companion.toEfCardAccess
import org.openecard.sc.pace.cvc.AuthenticatedAuxiliaryData
import org.openecard.sc.pace.cvc.AuthenticatedAuxiliaryData.Companion.toAuthenticatedAuxiliariyData
import org.openecard.sc.pace.cvc.AuthenticationTerminalChat
import org.openecard.sc.pace.cvc.CardVerifiableCertificate
import org.openecard.sc.pace.cvc.CardVerifiableCertificate.Companion.toCardVerifiableCertificate
import org.openecard.sc.pace.cvc.CertificateDescription
import org.openecard.sc.pace.cvc.CertificateDescription.Companion.toCertificateDescription
import org.openecard.sc.pace.cvc.Chat.Companion.toChat
import org.openecard.sc.pace.cvc.CvcChain.Companion.toChain
import org.openecard.sc.pace.cvc.PublicKeyReference.Companion.toPublicKeyReference
import org.openecard.sc.tlv.toTlvBer
import org.openecard.utils.common.cast
import org.open


�，可以识别一组特定的SIM卡          |
| EFPUCT单位价格/货币表  | 6F41  | PUCT    | 呼叫单位的价格和货币表                              | PUCT是与计费通知有关的信息，ME用这个信息结合EFACM，以用户选择的货币来计算呼叫费用 |
| EFCBMI小区广播识别号   | 6F45  | CBMI    | 小区广播信息标识符                                | 规定了用户希望MS采纳的小区广播消息内容的类型                  |
| EFSPN服务提供商      | 6F46  | SPN     | 服务提供商名称                                  | 包含服务提供商的名称和ME显示的相应要求                     |
| EFCBMID         | 6F48  | CBMID   | 数据下载的小区广播消息识别符                           | 移动台将收到的CBMID传送给SIM卡                      |
| EFSUME          | 6F54  | SUME    | 建立菜单单元                                   | 建立SIM卡中的菜单                               |
| EFBCCH广播信道      | 6F74  | BCCH    | 广播控制信道                                   | 由于BCCH的存储，在选择小区时，MS可以缩小对BCCH载波的搜索范围      |
| EFACC访问控制级别     | 6F78  | ACC     | 访问控制级别                                   | SIM卡有15个级别，10个普通级别，5个高级级别                |
| EFFPLMN禁止网络号    | 6F7B  | FPLMN   | 禁用的PLMN                                  | 禁止选择除中国移动以外的其他运营商，比如中国联通、中国卫通等           |
| EFLOCI位置信息      | 6F7E  | LOCI    | 位置信息                                     | 存储临时移动用户识别符、位置区信息等内容                     |
| EFAD管理数据        | 6FAD  | AD      | 管理数据                                     | 包括关于不同类型SIM卡操作模式的信息。例如：常规模式（PLMN用户用于GSM网络操作），型号认证模式（允许ME在无线设备的认证期间的特殊应用）；小区测试模式（在小区商用之前，进行小区测试），制造商特定模式（允许ME制造商在维护阶段进行特定的性能自动测试） |
| EFPHASE阶段       | 6FAE  | PHASE   | 阶段标识                                     | 标识SIM卡所处的阶段信息，比如是普通SIM卡还是STK卡等           |
| DFTELECOM       | 7F10  | 电信目录    |                                          |                                          |
| EFADN缩位拨号       | 6F3A  | AND     | 电话簿


idepose3d_h36m.md](./h36m/videpose3d_h36m.md) |
| [VideoPose3D-supervised-CPN-243frm](/configs/body_3d_keypoint/video_pose_lift/h36m/video-pose-lift_tcn-243frm-supv-cpn-ft_8xb128-200e_h36m.py) | 47.9  |  38.0   |    /    | [ckpt](https://download.openmmlab.com/mmpose/body3d/videopose/videopose_h36m_243frames_fullconv_supervised_cpn_ft-88f5abbb_20210527.pth) | [log](https://download.openmmlab.com/mmpose/body3d/videopose/videopose_h36m_243frames_fullconv_supervised_cpn_ft_20210527.log.json) | [videpose3d_h36m.md](./h36m/videpose3d_h36m.md) |
| [VideoPose3D-semi-supervised-27frm](/configs/body_3d_keypoint/video_pose_lift/h36m/video-pose-lift_tcn-27frm-semi-supv_8xb64-200e_h36m.py) | 57.2  |  42.4   |  54.2   | [ckpt](https://download.openmmlab.com/mmpose/body3d/videopose/videopose_h36m_27frames_fullconv_semi-supervised-54aef83b_20210527.pth) | [log](https://download.openmmlab.com/mmpose/body3d/videopose/videopose_h36m_27frames_fullconv_semi-supervised_20210527.log.json) | [videpose3d_h36m.md](./h36m/videpose3d_h36m.md) |
| [VideoPose3D-semi-supervised-CPN-27frm](/configs/body_3d_keypoint/video_pose_lift/h36m/video-pose-lift_tcn-27frm-semi-supv-cpn-ft_8xb64-200e_h36m.py) | 67.3  |  50.4   |  63.6   | [ckpt](https://download.openmmlab.com/mmpose/body3d/videopose/videopose_h36m_27frames_fullconv_semi-supervised_cpn_ft-71be9cde_20210527.pth) | [log](https://download.openmmlab.com/mmpose/body3d/videopose/videopose_h36m_27frames_fullconv_semi-supervised_cpn_ft_20210527.log.json) | [videpose3d_h36m.md](./h36m/videpose3d_h36m.md) |

HRNet (CVPR'2019)

```bibtex
@inproceedings{sun2019deep,
  title={Deep high-resolution representation learning for human pose estimation},
  author={Sun, Ke and Xiao, Bin and Liu, Dong and Wang, Jingdong},
  booktitle={Proceedings of the IEEE conference on computer vision and pattern recognition},
  pages={5693--5703},
  year={2019}
}
```

UDP (CVPR'2020)</a


4FC6");
			Assert.IsTrue(g1 is Guid);
			Assert.IsTrue(g2 is Guid);
			Assert.IsTrue(g3 is Guid);
			Assert.IsTrue(g4 is Guid);
			Assert.AreEqual(g1.ToString(), "a6993c0a-a8cb-45d9-994b-90e7203e4fc6", "g1");
			Assert.AreEqual(g2.ToString(), "a6993c0a-a8cb-45d9-994b-90e7203e4fc6", "g2");
			Assert.AreEqual(g3.ToString(), "a6993c0a-a8cb-45d9-994b-90e7203e4fc6", "g3");
			Assert.AreEqual(g4.ToString(), "a6993c0a-a8cb-45d9-994b-90e7203e4fc6", "g4");
			Assert.Throws(() => Guid.Parse("x"), typeof(FormatException), "Invalid should throw");
		}

		[Test]
		public void ParseExactWorks() {
			object g1 = Guid.ParseExact("A6993C0A-A8CB-45D9-994B-90E7203E4FC6", "D");
			object g2 = Guid.ParseExact("{A6993C0A-A8CB-45D9-994B-90E7203E4FC6}", "B");
			object g3 = Guid.ParseExact("(A6993C0A-A8CB-45D9-994B-90E7203E4FC6)", "P");
			object g4 = Guid.ParseExact("A6993C0AA8CB45D9994B90E7203E4FC6", "N");
			Assert.IsTrue(g1 is Guid);
			Assert.IsTrue(g2 is Guid);
			Assert.IsTrue(g3 is Guid);
			Assert.IsTrue(g4 is Guid);
			Assert.AreEqual(g1.ToString(), "a6993c0a-a8cb-45d9-994b-90e7203e4fc6", "g1");
			Assert.AreEqual(g2.ToString(), "a6993c0a-a8cb-45d9-994b-90e7203e4fc6", "g2");
			Assert.AreEqual(g3.ToString(), "a6993c0a-a8cb-45d9-994b-90e7203e4fc6", "g3");
			Assert.AreEqual(g4.ToString(), "a6993c0a-a8cb-45d9-994b-90e7203e4fc6", "g4");
			Assert.Throws(() => Guid.ParseExact("A6993C0A-A8CB-45D9-994B-90E7203E4FC6", "B"), typeof(FormatException), "Invalid B should throw");
			Assert.Throws(() => Guid.ParseExact("A6993C0A-A8CB-45D9-994B-90E7203E4FC6", "P"), typeof(FormatException), "Invalid P should throw");
			Assert.Throws(() => Guid.ParseExact("A6993C0A-A8CB-45D9-994B-90E7203E4FC6", "N"), typeof(FormatException), "Invalid N should throw");
			Assert.Throws(() => Guid.ParseExact("A6993C0AA8CB45D9994B90E7203E4FC6", "D"), typeof(FormatException), "Invalid D should throw");
		}

		[Test]
		public void TryParseWorks() {
			Guid g1, g2, g3, g4, g5;
			Assert.IsTrue (Guid.TryParse("A6993C0A-A8CB-45D9-994B-90E7203E4FC6", out g1), "g1 result");
			Assert.IsTrue (Guid.TryParse("{A6993C0A-A8CB-45D9-994B-90E7203E4FC6}", out g2), "g2 result");


())
                    {
                        std::cerr << fmt::format("Could not start query with error {}\n", started.error().what());
                        return 1;
                    }
                    std::cout << queryId.value().getRawValue();
                    startedQuery = std::make_optional(queryId.value());
                }
            }
            else
            {
                std::cerr << std::format("Could not register query: {}\n", queryId.error().what());
                return 1;
            }
        }

        if (program.is_used("-w"))
        {
            if (startedQuery.has_value())
            {
                auto status = queryManager->status(startedQuery.value());
                while (status.has_value() && status.value().state != NES::QueryState::Stopped
                       && status.value().state != NES::QueryState::Failed)
                {
                    std::this_thread::sleep_for(std::chrono::milliseconds(50));
                    status = queryManager->status(startedQuery.value());
                }
            }
        }

        return 0;
    }
    CPPTRACE_CATCH(...)
    {
        NES::tryLogCurrentException();
        return NES::getCurrentErrorCode();
    }
}
/*
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        https://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/

#include <LegacyOptimizer/OriginIdInferencePhase.hpp>

#include <algorithm>
#include <iterator>
#include <ranges>
#include <unordered_set>
#include <utility>
#include <vector>

#include <Identifiers/Identifiers.hpp>
#include <Operators/LogicalOperator.hpp>
#include <Operators/OriginIdAssigner.hpp>
#include <Operators/Sources/SourceDescriptorLogicalOperator.hpp>
#include <Plans/LogicalPlan.hpp>
#include <Traits/OutputOriginIdsTrait.hpp>
#include <Traits/Trait.hpp>
#include <Traits/TraitSet.hpp>
#include <ErrorHandling.hpp>

namespace NES
{

namespace
{
LogicalOperator propagateOriginIds(const LogicalOperator& visitingOperator, OriginId& lastOriginId)
{
    std::vector<LogicalOperator> newChildren;
    std::vector<OutputOriginIdsTrait> childOriginIds;
    for (const auto& child : visitingOperator.getChildren())
    {
        auto newChild = propagateOriginIds(child, lastOriginId);
        newChildren.push_back(newChild);
        const auto childOriginIdsOpt = getTrait<OutputOriginIdsTrait>(newChild.getTraitSet());
        INVARIANT(childOriginIdsOpt.has_value(), "Child operator must have origin ids trait");
        childOriginIds.push_back(childOriginIdsOpt.value());
    }

    auto traitSet = visitingOperator.getTraitSet();

    if (visitingOperator.tryGetAs<OriginIdAssigner>().has_value())
    {
        lastOriginId = OriginId{lastOriginId.getRawValue() + 1};
        const auto success = tryInsert(traitSet, OutputOriginIdsTrait{{lastOriginId}});
        INVARIANT(success, "Failed to insert origin id trait, did another phase already assign them?");
    }
    else
    {
        const auto success = tryInsert(
            traitSet,
            OutputOriginIdsTrait{
                childOriginIds | std::views::join | std::r


dark-mode.accent-purple .page-item .page-link:hover{color:#7e55c7}.dark-mode .accent-pink .btn-link,.dark-mode .accent-pink .nav-tabs .nav-link,.dark-mode .accent-pink a:not(.dropdown-item):not(.btn-app):not(.nav-link):not(.brand-link):not(.page-link):not(.badge):not(.btn){color:#e83e8c}.dark-mode .accent-pink .btn-link:hover,.dark-mode .accent-pink .nav-tabs .nav-link:hover,.dark-mode .accent-pink a:not(.dropdown-item):not(.btn-app):not(.nav-link):not(.brand-link):not(.page-link):not(.badge):not(.btn):hover{color:#c21766}.dark-mode .accent-pink .dropdown-item.active,.dark-mode .accent-pink .dropdown-item:active{background-color:#e83e8c;color:#fff}.dark-mode .accent-pink .custom-control-input:checked~.custom-control-label::before{background-color:#e83e8c;border-color:#ac145a}.dark-mode .accent-pink .custom-control-input:checked~.custom-control-label::after{background-image:url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3E%3Cpath fill='%23fff' d='M6.564.75l-3.59 3.612-1.538-1.55L0 4.26 2.974 7.25 8 2.193z'/%3E%3C/svg%3E")}.dark-mode .accent-pink .custom-control-input:focus:not(:checked)~.custom-control-label::before,.dark-mode .accent-pink .custom-file-input:focus~.custom-file-label,.dark-mode .accent-pink .custom-select:focus,.dark-mode .accent-pink .form-control:focus:not(.is-invalid):not(.is-warning):not(.is-valid){border-color:#f6b0d0}.dark-mode .accent-pink .page-item .page-link{color:#e83e8c}.dark-mode .accent-pink .page-item.active .page-link,.dark-mode .accent-pink .page-item.active a{background-color:#e83e8c;border-color:#e83e8c;color:#fff}.dark-mode .accent-pink .page-item.disabled .page-link,.dark-mode .accent-pink .page-item.disabled a{background-color:#fff;border-color:#dee2e6;color:#6c757d}.dark-mode .accent-pink [class*=sidebar-dark-] .sidebar a:not(.dropdown-item):not(.btn-app):not(.nav-link):not(.brand-link){color:#c2c7d0}.dark-mode .accent-pink [class*=sidebar-dark-] .sidebar a:not(.dropdown-item):not(.btn-app):not(.nav-link):not(.brand-link):hover{color:#fff}.dark-mode .accent-pink [class*=sidebar-light-] .sidebar a:not(.dropdown-item):not(.btn-app):not(.nav-link):not(.brand-link){color:#343a40}.dark-mode .accent-pink [class*=sidebar-light-] .sidebar a:not(.dropdown-item):not(.btn-app):not(.nav-link):not(.brand-link):hover{color:#212529}.dark-mode .dark-mode.accent-pink .page-item .page-link:focus,.dark-mode .dark-mode.accent-pink .page-item .page-link:hover{color:#eb559a}.dark-mode .accent-red .btn-link,.dark-mode .accent-red .nav-tabs .nav-link,.dark-mode .accent-red a:not(.dropdown-item):not(.btn-app):not(.nav-link):n


	psrlw		%mm2, 8
	psllw		%mm3, 8
	psrlw		%mm4, 8
	por		%mm1, %mm2
	por		%mm3, %mm4

	movq		[%ecx], %mm1
	movq		[%ecx+8], %mm3
	add		%edx, 16
	add		%ecx, 16
	dec		%eax
	jnz		1b

	emms
2:
	ret

.balign 16
#################################################################################
##
##	IN: %eax -- number of pixels to convert
##	    %edx -- input
##          %ecx -- output

EXPORT(x86_mmx_convert_2be555_to_2le565):
	add		%eax, 7
	shr		%eax, 3		# we can convert 8 pixels at a time
	movq		%mm0, [d1]
	movq		%mm7, [d2]
	jz		2f
1:
	movq		%mm1, [%edx]
	movq		%mm3, [%edx+8]
	## convert big to little endian
	movq		%mm2, %mm1
	movq		%mm4, %mm3
	pand		%mm1, %mm0
	pand		%mm2, %mm7
	pand		%mm3, %mm0
	pand		%mm4, %mm7
	psllw		%mm1, 8
	psrlw		%mm2, 8
	psllw		%mm3, 8
	psrlw		%mm4, 8
	por		%mm1, %mm2
	por		%mm4, %mm3

	movq		%mm2, %mm1
	movq		%mm3, %mm1
	movq		%mm5, %mm4
	movq		%mm6, %mm4
	pand		%mm1, [_2be555_mask_r]
	pand		%mm2, [_2be555_mask_g]
	pand		%mm3, [_2be555_mask_b]
	pand		%mm4, [_2be555_mask_r]
	pand		%mm5, [_2be555_mask_g]
	pand		%mm6, [_2be555_mask_b]
	psllw		%mm1, 1		# red
	psllw		%mm2, 1		# green
#	psllw		%mm3, 0		# blue
	psllw		%mm4, 1		# red
	psllw		%mm5, 1		# green
#	psllw		%mm6, 0		# blue
	por		%mm1, %mm2
	por		%mm4, %mm5
	por		%mm1, %mm3
	por		%mm4, %mm6
	movq		[%ecx], %mm1
	movq		[%ecx+8], %mm4
	add		%edx, 16
	add		%ecx, 16
	dec		%eax
	jnz		1b

	emms
2:
	ret

.balign 16
#################################################################################
##
##	IN: %eax -- number of pixels to convert
##	    %edx -- input
##          %ecx -- output

EXPORT(x86_mmx_convert_2be555_to_4le888):
	add		%eax, 3
	shr		%eax, 2		# we can convert 4 pixels at a time
	movq		%mm7, [d1]
	jz		2f

	pxor		%mm0, %mm0
1:
	movq		%mm1, [%edx]

	## convert big to little endian
	movq		%mm3, %mm1
	pand		%mm1, %mm7
	pand		%mm3, [d2]
	psllw		%mm1, 8
	psrlw		%mm3, 8
	por		%mm1, %mm3

	movq		%mm2, %mm1
	movq		%mm3, %mm1
	pand		%mm1, [_2be555_mask_r]
	pand		%mm2, [_2be555_mask_g]
	pand		%mm3, [_2be


.21 7.622-5.495 9.524a1 1 0 01-1.506-.862c0-.359.194-.687.505-.867a9.019 9.019 0 001.86-1.43 8.944 8.944 0 002.635-6.46 9.004 9.004 0 00-4.493-7.698Z"/></g></svg>';
  static const String speaker_low_volume =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="32" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 32 32"><path fill="currentColor" d="M8.012 9.013V9h-4.21C2.808 9 2 9.847 2 10.892v10.216C2 22.153 2.807 23 3.803 23h4.195l8.613 3.83a1.693 1.693 0 002.425-1.525v-6.228a3.055 3.055 0 000-6.107V6.497c0-1.242-1.866-1.794-2.989-1.265l-8.035 3.78Zm9.024 15.818-7.038-3.13V10.29l6.893-3.244h.002a.384.384 0 01.114-.013h.029v17.8Z"/></svg>';
  static const String speaker_medium_volume =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="32" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 32 32"><g fill="currentColor"><path d="m16.61 26.83-8.612-3.829L3.803 23C2.807 23 2 22.153 2 21.108V10.892C2 9.847 2.807 9 3.803 9h4.21v.012l8.034-3.78c1.123-.529 2.989.023 2.989 1.264v6.474a3.055 3.055 0 010 6.107v6.227a1.693 1.693 0 01-2.425 1.527Zm.426-1.999v-17.8h-.03c-.067.001-.105.011-.113.013h-.002L9.998 10.29V21.7l7.038 3.13Z"/><path d="M24.11 11.07a7.3 7.3 0 00-.438-.442c-.637-.59-1.672-.137-1.672.732v.028c0 .271.118.528.317.713a4.986 4.986 0 011.604 3.667 4.98 4.98 0 01-1.604 3.668c-.205.19-.317.46-.317.74 0 .871 1.037 1.322 1.676.73a6.958 6.958 0 002.242-5.354 6.987 6.987 0 00-1.808-4.482Z"/></g></svg>';
  static const String speaking_head =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="32" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 32 32"><path fill="currentColor" d="M24.726 14.62c.445.467.66.692.724 1.23a1.79 1.79 0 01-1.83 1.98l.043.44c.05.491.097.967.097 1.43a.58.58 0 01-.55.59l-1.68.06a.38.38 0 000 .65l1.67 1.07a.77.77 0 01.34.83c-.55 2.04-2.01 3.44-5.3 3


trize(
        "chunks",
        [
            [],
            [b"data"],
            [b"echo1", b"echo2"],
        ],
        ids=["empty_stream", "single_chunk", "multiple_chunks"],
    )
    async def test_echo_success(self, mock_bidirectional_stream: Any, chunks: list[bytes]) -> None:
        mock_bidirectional_stream.read_iter.return_value = AsyncIterator(items=chunks)

        await echo_stream(stream=mock_bidirectional_stream)

        assert mock_bidirectional_stream.write.await_count == len(chunks)
        for i, chunk in enumerate(chunks):
            assert mock_bidirectional_stream.write.await_args_list[i].kwargs == {"data": chunk}
        mock_bidirectional_stream.close.assert_awaited_once()
        mock_bidirectional_stream.abort.assert_not_awaited()

    async def test_echo_read_error(self, mocker: MockerFixture, mock_bidirectional_stream: Any) -> None:
        mock_logger = mocker.patch("pywebtransport.stream.utils.logger")
        read_error = StreamError(message="Read failed")
        mock_bidirectional_stream.read_iter.return_value = AsyncIterator(items=[], exception=read_error)

        await echo_stream(stream=mock_bidirectional_stream)

        mock_logger.error.assert_called_once_with("Error in echo stream: %s", read_error, exc_info=True)
        mock_bidirectional_stream.abort.assert_awaited_once_with(code=1)
        mock_bidirectional_stream.close.assert_not_awaited()

    async def test_echo_write_error(self, mocker: MockerFixture, mock_bidirectional_stream: Any) -> None:
        mock_logger = mocker.patch("pywebtransport.stream.utils.logger")
        mock_bidirectional_stream.read_iter.return_value = AsyncIterator(items=[b"data"])
        write_error = StreamError(message="Write failed")
        mock_bidirectional_stream.write.side_effect = write_error

        await echo_stream(stream=mock_bidirectional_stream)

        mock_logger.error.assert_called_once_with("Error in echo stream: %s", write_error, exc_info=True)
        mock_bidirectional_stream.abort.assert_awaited_once_with(code=1)
        mock_bidirectional_stream.close.assert_not_awaited()


eMismatch();
  }

  /**
   * Not in use.
   */
  public boolean next()
  {
    return false;
  }

  /**
   * Not in use.
   */
  public void rewind()
  {
  }

  /**
   * Not in use.
   */
  public boolean seek(int p)
  {
    return false;
  }

  /**
   * Get the typecode of this enumeration.
   */
  public TypeCode type()
  {
    return official_type;
  }

  /**
   * Compares with other DynAny for equality.
   */
  public boolean equals(java.lang.Object other)
  {
    if (other instanceof DynAny)
      return equal((DynAny) other);
    else
      return false;
  }

  /**
   * This depends on an object.
   */
  public abstract boolean equal(DynAny other);

}
/* PrintAttributeException.java --
   Copyright (C) 2006 Free Software Foundation, Inc.

This file is part of GNU Classpath.

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

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

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */

package gnu.javax.print;

import javax.print.AttributeException;
import javax.print.PrintException;
import javax.print.attribute.Attribute;

/**
 * A PrintException further refining the exception
 * cause by providing an implementation of the print exception
 * interface AttributeException.
 *
 * @see javax.print.PrintException
 * @see javax.print.AttributeException
 *
 * @author Wolfgang Baer (WBaer@gmx.de)
 */
public final class PrintAttributeException extends PrintException
  implements AttributeException
{
  private Class[] categories;
  private Attribute[] values;

  /**
   * Constructs a PrintAttributeException
   * with the given unsupported attributes and/or values.
   *
   * @param unsupportedAttributes the unsupported categories,
   * may be null.
   * @param unsupportedValues the


body>

{% extends 'basemain.html' %}
{% block title %}   添加漏洞 {% endblock %}

{% block link %}

{% endblock %}
{% block content %}

        新增漏洞

        <form enctype="multipart/form-data" method="post">

漏洞名称：

                    <input type="text" class="form-control" placeholder="漏洞名称" name="bug_name">

漏洞详情：

                    <textarea id="ck-editor" name="bug_content" class="form-control" rows="3"></textarea>

                    <input type="button"  class="btn btn-primary" value="保存" id = "btnaddbug">

        </form>

{% endblock %}

{% block vuejs %}

{% endblock %}

<!DOCTYPE html>

	<meta charset="utf-8">
	<title>XHTML Compliant Output — CKEditor Sample</title>
	<meta name="ckeditor-sample-required-plugins" content="sourcearea">

	<link href="sample.css" rel="stylesheet">

		CKEditor Samples » Producing XHTML Compliant Output

		This sample is not maintained anymore. Check out its brand new version in CKEditor SDK.

			This sample shows how to configu


-radius:.2rem .2rem 0 0}[data-components=pdr-signin-form] [data-components=pdr-password-input] .textfield{border-radius:0 0 .2rem .2rem}.textfield[readonly]{border:0}.textfield-indicator-wrapper{height:2.6rem}.textfield-indicator-text{margin-right:.3rem}.textfield-indicator{height:.3rem;margin-left:.3rem;width:1.3rem}.text-input-error-wrapper{margin-top:.6rem;margin-bottom:.6rem}.text-input-error-row{font-size:1.3rem;line-height:1.8rem;overflow-wrap:break-word;text-align:left}.pin-input{width:3.6rem;text-align:center}[data-components=pdr-pin-number] .notification-message{padding-left:1.4rem;display:inline;white-space:nowrap;text-align:left}.iti-mobile .iti.iti--container ul.iti__country-list li.iti__country .iti__flag-box,[data-components=pdr-text-field-v2] .iti .iti__flag-container ul.iti__country-list li.iti__country .iti__flag-box,[data-components=pdr-text-field-v2] .iti.iti--separate-dial-code .iti__flag-container .iti__flag{display:none}[data-components=pdr-password-input] [data-components=pdr-text-field-v2]{position:relative}[data-components=pdr-password-input] input{padding-right:4rem}[data-components=pdr-signin-form] [data-components=pdr-password-input] input{padding-right:4.4rem}[data-components=pdr-signin-form] [data-components=pdr-password-input]{margin-top:-1px}[data-components=pdr-button] input[type=file]+label{cursor:pointer}[data-components=pdr-button] input[type=file]:active+label{box-shadow:0 0 .2rem .1rem #fff,0 0 .2rem .3rem #4d90fe;opacity:.6}input::-ms-clear{visibility:hidden}input::-ms-reveal{visibility:hidden}[data-components=pdr-text-field-v2] .iti{height:100%}[data-components=pdr-text-field-v2] .iti input[type=tel]{padding:0 1rem!important}[data-components=pdr-text-field-v2] .iti .iti__flag-container{bottom:auto;height:inherit;margin-right:1rem;padding:0;position:relative;top:auto}[data-components=pdr-text-field-v2] .iti .iti__flag-container .iti__flag{background-size:5630px;background-image:url(images/flags@2x.png)}[data-components=pdr-text-field-v2] .iti .iti__flag-container .iti__selected-flag .iti__arrow{border:0;margin-left:0}[data-components=pdr-text-field-v2] .iti.iti--separate-dial-code .iti__flag-container .iti__selected-flag{width:7.4rem}[data-components=pdr-text-field-v2] .iti.iti--separate-dial-code .iti__flag-container .iti__selected-flag .iti__selected-dial-code{margin-left:0}.popup-content{padding:0 2.8rem}.popup-header-icon{background-position:50% 50%;background-repeat:no-repeat;background-size:4rem 4rem;margin:.8rem 1rem;border:0;cursor:pointer;height:4rem;position:absolute;width:4rem}.popup-header-icon.back{left:0}.popup-header-icon.close{right:0}.popup-header{display:table;hei


Continue, true), //
    FLOAT_TO_DOUBLE(0x89, "float-to-double", kFmt12x, kIndexNone, kInstrCanContinue, true), //
    DOUBLE_TO_INT(0x8a, "double-to-int", kFmt12x, kIndexNone, kInstrCanContinue, true), //
    DOUBLE_TO_LONG(0x8b, "double-to-long", kFmt12x, kIndexNone, kInstrCanContinue, true), //
    DOUBLE_TO_FLOAT(0x8c, "double-to-float", kFmt12x, kIndexNone, kInstrCanContinue, true), //
    INT_TO_BYTE(0x8d, "int-to-byte", kFmt12x, kIndexNone, kInstrCanContinue, true), //
    INT_TO_CHAR(0x8e, "int-to-char", kFmt12x, kIndexNone, kInstrCanContinue, true), //
    INT_TO_SHORT(0x8f, "int-to-short", kFmt12x, kIndexNone, kInstrCanContinue, true), //
    ADD_INT(0x90, "add-int", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    SUB_INT(0x91, "sub-int", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    MUL_INT(0x92, "mul-int", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    DIV_INT(0x93, "div-int", kFmt23x, kIndexNone, kInstrCanContinue | kInstrCanThrow, true), //
    REM_INT(0x94, "rem-int", kFmt23x, kIndexNone, kInstrCanContinue | kInstrCanThrow, true), //
    AND_INT(0x95, "and-int", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    OR_INT(0x96, "or-int", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    XOR_INT(0x97, "xor-int", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    SHL_INT(0x98, "shl-int", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    SHR_INT(0x99, "shr-int", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    USHR_INT(0x9a, "ushr-int", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    ADD_LONG(0x9b, "add-long", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    SUB_LONG(0x9c, "sub-long", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    MUL_LONG(0x9d, "mul-long", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    DIV_LONG(0x9e, "div-long", kFmt23x, kIndexNone, kInstrCanContinue | kInstrCanThrow, true), //
    REM_LONG(0x9f, "rem-long", kFmt23x, kIndexNone, kInstrCanContinue | kInstrCanThrow, true), //
    AND_LONG(0xa0, "and-long", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    OR_LONG(0xa1, "or-long", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    XOR_LONG(0xa2, "xor-long", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    SHL_LONG(0xa3, "shl-long", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    SHR_LONG(0xa4, "shr-long", kFmt23x, kIndexNone, kInstrCanContinue, true), //
    USHR_LONG(0xa5, "ushr-long", kFmt23x, kIndexNone, kInstrCanContinue, true), //


	clientv3 "go.etcd.io/etcd/client/v3"
	"time"
)

func main() {
	cli, err := clientv3.New(clientv3.Config{
		Endpoints:   []string{"localhost:2379"},
		DialTimeout: 5 * time.Second,
	})
	if err != nil {
		// handle error!
		fmt.Printf("连接etcd失败%v\n",err)
	}
	defer cli.Close()
	rch := cli.Watch(context.Background(), "testkey")
	for wresp := range rch {
		for _, ev := range wresp.Events {
			fmt.Printf("%s %q : %q\n", ev.Type, ev.Kv.Key, ev.Kv.Value)
		}
	}

}
````
可在修改testkey值，观察其变化
### 删除
示例
````
package main

import (
	"context"
	"fmt"
	clientv3 "go.etcd.io/etcd/client/v3"
	"time"
)

func main() {
	cli, err := clientv3.New(clientv3.Config{
		Endpoints:   []string{"localhost:2379"},
		DialTimeout: 5 * time.Second,
	})
	if err != nil {
		// handle error!
		fmt.Printf("连接etcd失败%v\n",err)
	}
	defer cli.Close()

	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	resp, err := cli.Delete(ctx, "testkey")
	cancel()
	if err != nil {
		// handle error!
		fmt.Printf("delete操作失败%v\n",err)
	}
	fmt.Println(resp.Deleted) //是否被删除
}
````
### lease租约
示例
````
package main

import (
	"context"
	"fmt"
	clientv3 "go.etcd.io/etcd/client/v3"

	"time"
)

func main() {
	cli, err := clientv3.New(clientv3.Config{
		Endpoints:   []string{"localhost:2379"},
		DialTimeout: 5 * time.Second,
	})
	if err != nil {
		// handle error!
		fmt.Printf("连接etcd失败%v\n",err)
	}
	defer cli.Close()
	//设置租约为5秒
	resp, err := cli.Grant(context.TODO(), 5)
	if err != nil {
		fmt.Printf("设置lease失败%v\n",err)
	}

	// 5秒后 ‘foo’ 将被移除
	r, err := cli.Put(context.TODO(), "foo", "bar", clientv3.WithLease(resp.ID))
	if err != nil {
		fmt.Printf("lease失败%v\n",err)
	}
	fmt.Println(r.OpResponse())
}
````
### keep-alive查看租约是否存活
示例
````
package main

import (
	"context"
	"fmt"
	clientv3 "go.etcd.io/etcd/client/v3"
	"log"

	"time"
)

func main() {
	cli, err := clientv3.New(clientv3.Config{
		Endpoints:   []string{"localhost:2379"},
		Dial


/*

Copyright (c) 2007-2008  Michael G Schwern

This software originally derived from Paul Sheer's pivotal_gmtime_r.c.

The MIT License:

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

Origin: http://code.google.com/p/y2038
Modified for Bionic by the Android Open Source Project

*/
#ifndef TIME64_H
#define TIME64_H

#include <sys/cdefs.h>
#include <time.h>
#include <stdint.h>

__BEGIN_DECLS

typedef int64_t  time64_t;

struct tm *gmtime64_r (const time64_t *, struct tm *);
struct tm *localtime64_r (const time64_t *, struct tm *);
struct tm *gmtime64 (const time64_t *);
struct tm *localtime64 (const time64_t *);

char *asctime64 (const struct tm *);
char *asctime64_r (const struct tm *, char *);

char *ctime64 (const time64_t*);
char *ctime64_r (const time64_t*, char*);

time64_t timegm64 (const struct tm *);
time64_t mktime64 (const struct tm *);
time64_t timelocal64 (const struct tm *);

__END_DECLS

#endif /* TIME64_H */


-- List or manage map features & enable magma furnaces
local help = [====[

feature
=======
Enables management of map features.

* Discovering a magma feature (magma pool, volcano, magma sea, or curious
  underground structure) permits magma workshops and furnaces to be built.
* Discovering a cavern layer causes plants (trees, shrubs, and grass) from
  that cavern to grow within your fortress.

Options:

:list:          Lists all map features in your current embark by index.
:magma:         Enable magma furnaces (discovers a random magma feature).
:show X:        Marks the selected map feature as discovered.
:hide X:        Marks the selected map feature as undiscovered.

]====]

local map_features = df.global.world.features.map_features

function toggle_feature(idx, discovered)
    idx = tonumber(idx) --luacheck: retype
    if idx < 0 or idx >= #map_features then
        qerror('Invalid feature ID')
    end
    map_features[tonumber(idx)].flags.Discovered = discovered
end

function list_features()
    local name = df.new('string')
    for idx, feat in ipairs(map_features) do
        local tags = ''
        if feat:isWater() then
            tags = tags .. ' [water]'
        end
        if feat:isM


Spaces(key);
            NStr::TruncateSpaces(val);
            if (key == "ncbi") {
                val = traceparent;
                if (!new_ts.empty()) val += ",";
                new_ts = key + "=" + val + new_ts; // the updated 'ncbi' state goes first
                continue;
            }
        }
        if (!new_ts.empty()) new_ts += ",";
        new_ts += state;
    }
    return new_ts;
}

void COpentelemetryTracer::OnRequestStart(CRequestContext& context)
{
    auto tracer = s_GetTracer();
    if (!tracer) return;

    if (!context.IsSetHitID()) context.SetHitID();
    auto& current_ctx = CDiagContext::GetRequestContext();
    if (&current_ctx != &context) {
        // NOTE: Since ID generator is installed globally, it uses current request context
        // rather than the one passed as an argument to the tracer. Normally they are
        // the same but if they are not issue a warning.
        string phid_cur = current_ctx.IsSetHitID() ? current_ctx.GetHitID() : "<empty>";
        string phid_arg = context.IsSetHitID() ? context.GetHitID() : "<empty>";
        ERR_POST(Warning <<
            "Request context is not current, trace and span ids may be incorrect. Current context phid=" <<
            phid_cur << "; tracer context phid=" << phid_arg);
    }

    trace::TraceId context_tid;
    trace::SpanId context_pid;
    int flags = 0;
    s_ParseIds(current_ctx, context_tid, context_pid, flags);

    trace::SpanContext parent_ctx(context_tid, context_pid, trace::TraceFlags(0), false);
    trace::StartSpanOptions options;
    options.parent = parent_ctx;

    switch (context.GetTracerSpanKind()) {
    case ITracerSpan::eKind_Internal:
        options.kind = trace::SpanKind::kInternal;
        break;
    case ITracerSpan::eKind_Server:
        options.kind = trace::SpanKind::kServer;
        break;
    case ITracerSpan::eKind_Client:
        options.kind = trace::SpanKind::kClient;
        break;
    default:
        options.kind = m_SpanKind;
    }

    auto span = tracer->StartSpan(s_DefaultSpanNamePrefix + "/request-start", {}, options);

    CDiagContext& diag_context = GetDiagContext();
    char buf[17];
    diag_context.GetStringUID(diag_context.GetUID(), buf, 17);

    span->SetStatus(trace_api::StatusCode::kOk);

    // Some values (e.g. SemanticConventions::kClientAddress) can be set
    // by CGIs or other external code. Opentelemetry span's SetAttribute()
    // creates multiple attributes with the same name instead of replacing
    // the value (despite what the documentation says). To avoid having
    // duplicate names the values from request context are added as 'ncbi.*'
    // rather than using SemanticConventions::* names.
    span->SetAttribute("ncbi.guid", buf);
    span->SetAttribute("ncbi.pid", diag_context.GetPID());
    span->SetAttribute("ncbi.tid", (Uint8)GetCurrentThreadSystemID());
    span->SetAttribute("ncbi.host", diag_context.GetHost());
    span->SetAttribute("ncbi.request_id", context.GetRequestID());
    span->SetAttribute("ncbi.phid", context.GetHitID());
    string s = context.GetClientIP();
    if ( !s


_end0);
    __action45(
        __temp0,
    )
}

fn __action58<
    'input,
>(
    __0: (ByteIndex, ::std::vec::Vec<Item>, ByteIndex),
) -> File
{
    let __start0 = __0.0.clone();
    let __end0 = __0.2.clone();
    let __temp0 = __action20(
        __0,
    );
    let __temp0 = (__start0, __temp0, __end0);
    __action45(
        __temp0,
    )
}

pub trait __ToTriple<'input, > {
    type Error;
    fn to_triple(value: Self) -> Result<(ByteIndex,Token<'input>,ByteIndex),Self::Error>;
}

impl<'input, > __ToTriple<'input, > for (ByteIndex, Token<'input>, ByteIndex) {
    type Error = ParseError<ByteIndex, Token<'input>, Void>;
    fn to_triple(value: Self) -> Result<(ByteIndex,Token<'input>,ByteIndex),ParseError<ByteIndex, Token<'input>, Void>> {
        Ok(value)
    }
}
impl<'input, > __ToTriple<'input, > for Result<(ByteIndex, Token<'input>, ByteIndex),ParseError<ByteIndex, Token<'input>, Void>> {
    type Error = ParseError<ByteIndex, Token<'input>, Void>;
    fn to_triple(value: Self) -> Result<(ByteIndex,Token<'input>,ByteIndex),ParseError<ByteIndex, Token<'input>, Void>> {
        value
    }
}
/**
 * \file flow-rs/src/config/mod.rs
 * MegFlow is Licensed under the Apache License, Version 2.0 (the "License")
 *
 * Copyright (c) 2019-2021 Megvii Inc. All rights reserved.
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 */
pub mod graphviz;
pub mod interlayer;
pub mod presentation;

use crate::node::{inputs, outputs};
use anyhow::{anyhow, Result};
use std::collections::HashMap;

struct PortUtility {
    ty: interlayer::PortTy,
    mapping: fn(&str) -> String,
}
static MAPPING: &[PortUtility] = &[
    PortUtility {
        ty: interlayer::PortTy::Unit,
        mapping: |p| p.to_owned(),
    },
    PortUtility {
        ty: interlayer::PortTy::List,
        mapping: |p| format!("[{}]", p),
    },
    PortUtility {
        ty: interlayer::PortTy::Dyn,
        mapping: |p| format!("dyn@{}", p),
    },
];

fn translate_node(local_key: u64, p: presentation::Node) -> Result<interlayer::Node> {
    let inputs = inputs(local_key, &p.entity.ty)?
        .into_iter()
        .map(|n| (n, "".to_owned()))
        .collect();
    let outputs = outputs(local_key, &p.entity.ty)?
        .into_iter()
        .map(|n| (n, "".to_owned()))
        .collect();
    Ok(interlayer::Node {
        entity: p.entity,
        res: p.res,
        cloned: p.cloned,
        inputs,
        outputs,
        is_dyn: false,
    })
}

fn translate_conn(
    name: &str,
    p: presentation::Connection,
    nodes: &mut HashMap


1);
        },
        Key::Ctrl('h') | Key::Backspace => {
            linebuffer.backspace(1);
        },
        Key::Ctrl('d') | Key::Delete => {
            linebuffer.delete(1);
        },
        Key::Ctrl('a') | Key::Home => {
            linebuffer.move_home();
        },
        Key::Ctrl('e') | Key::End => {
            linebuffer.move_end();
        },
        Key::Ctrl('k') => {
            linebuffer.kill_line();
        },
        Key::Ctrl('u') => {
            linebuffer.discard_line();
        },
        Key::Ctrl('w') | Key::AltBackspace | Key::CtrlBackspace => {
            linebuffer.delete_prev_word(Word::Emacs, 1);
        },
        Key::Alt('d') | Key::AltDelete | Key::CtrlDelete => {
            linebuffer.delete_word(At::AfterEnd, Word::Emacs, 1);
        },
        Key::Alt('f') => {
            linebuffer.move_to_next_word(At::AfterEnd, Word::Emacs, 1);
        },
        Key::Alt('b') => {
            linebuffer.move_to_prev_word(Word::Emacs, 1);
        },
        Key::Alt('t') => {
            linebuffer.transpose_words(1);
        },
        Key::Char(c) => {
            linebuffer.insert(c, 1);
        },
        _ => {},
    }
}

/// Return styled text for the context in the help menu
fn styled_context<'a>(text: &'a str, color: Color, app: &UiApp) -> Text<'a> {
    Text::from(
        text.lines()
            .map(|v| {
                let mut values = v.trim().split(':').collect::<Vec<&str>>();
                Spans::from(if values.len() >= 2 {
                    vec![
                        Span::styled(values[0], Style::default().fg(Color::Reset)),
                        Span::styled(":", Style::default().fg(Color::DarkGray)),
                        Span::styled(
                            values.drain(1..).collect::<Vec<&str>>().join(":"),
                            Style::default()
                                .fg(if app.config.ui.flashy && app.is_colored() {
                                    app.gen_random_color()
                                } else if app.is_colored() {
                                    color
                                } else {
                                    Color::Reset
                                })
                                .add_modifier(Modifier::BOLD),
                        ),
                    ]
                } else {
                    vec![Span::styled(v, Style::default().fg(Color::Reset))]
                })
            })
            .collect::<Vec<Spans>>(),
    )
}
fn is_pythagorean_triplet(a: i32, b: i32, c: i32) -> bool {
    a * a + b * b == c * c
}

fn solve() -> i32 {
    let mut product = 0;

    for a in 0..500 {
        for b in a..500 {
            let c = 1000 - a - b;
            let sum = a + b + c;
            if is_pythagorean_triplet(a, b, c) && sum == 1000 {
                product = a * b * c;
                break;
            }
        }
    }
    product
}

fn main() {
    let result = solve();
    println!("{}", result);
}
<reponame>dakom/jigsaw-puzzle<filename>frontend/src/dom.rs<gh_stars>1-10
use shipyard::*;
use wasm_bindgen::JsCast;
use web_sys::{Window, Document, HtmlElement, HtmlCanvasElement, WebGlRendering


 ? K : never
}[number];

type _ArgumentTypes<
	Confs extends ArgumentConfigs,
	_Args extends Arguments<Confs> = Arguments<Confs>,
	Req extends string = Any.Cast<RequiredArgIndices<_Args, true>, string>,
	NonReq extends string = Any.Cast<RequiredArgIndices<_Args, false>, string>,
> = Any.Compute<
	{ [I in Req]-?: TypeOf<Any.Cast<_Args[Str.Format<I, 'n'>], {type: InputType}>['type']> }
	& { [I in NonReq]+?: TypeOf<Any.Cast<_Args[Str.Format<I, 'n'>], {type: InputType}>['type']> }
>;

// TODO: convert to tuple with optional values?
export type ArgumentTypes<Confs extends ArgumentConfigs> = _ArgumentTypes<Confs>;
/* eslint-disable @typescript-eslint/no-explicit-any */
import { createStore } from 'vuex';
import {
  FETCH_IMAGE_REQUEST,
  FETCH_IMAGE_SUCCESS,
  FETCH_IMAGE_FAILURE,
  TOGGLE_SETTINGS_MODAL,
  UPDATE_SEARCH_TAGS,
  SET_THEME,
  SET_REFRESH_REQUIRED,
} from '../helpers/constants/actions';
import { createError, textToArray, applyThemeToBody } from '../helpers/utils';
import imageApi from '../api/image';
import { getStorage, updateStorage } from '../helpers/storage';

const getTagsFromStorage = () => {
  const { tags = [] } = getStorage();

  return tags;
};

const getthemeFromStorage = () => {
  const { theme = 'light' } = getStorage();

  return theme;
};

const store = createStore({
  state() {
    return {
      images: {
        isFetching: false,
        errorMessage: '',
        data: [],
        activeImageRank: null,
        isRefreshRequired: false,
      },
      theme: getthemeFromStorage(),
      tags: getTagsFromStorage(),
      settingsModalOpen: false,
    };
  },
  mutations: {
    [FETCH_IMAGE_REQUEST](state: any) {
      state.images.isFetching = true;
      state.images.isRefreshRequired = false;
      state.images.errorMessage = '';

      state.images.activeImageRank = null;
    },
    [FETCH_IMAGE_SUCCESS](state, image) {
      const dataLength = state.images.data.length;
      state.images.isFetching = false;
      state.images.errorMessage = '';

      state.images.data.push(image);

      state.images.activeImageRank = dataLength;
    },
    [FETCH_IMAGE_FAILURE](state, errorMessage = '') {
      state.images.isFetching = false;
      state.images.errorMessage = errorMessage;
    },
    [TOGGLE_SETTINGS_MODAL](state) {
      state.settingsModalOpen = !state.settingsModalOpen;
    },
    [UPDATE_SEARCH_TAGS](state, tags = []) {
      state.tags = tags;
      updateStorage({ tags });
    },
    [SET_REFRESH_REQUIRED](state) {
      state.images.isRefreshRequired = true;
    },
    [SET_THEME](state, isDarkTheme = false) {
      const theme = isDarkTheme ? 'dark' : 'light';
      state.theme = theme;
      updateStorage({ theme });
    },
  },
  actions: {
    fetchImage({ state, commit }, payload) {
      if (state.images.isFetching) {
        return;
      }

      commit(FETCH_IMAGE_REQUEST);

      imageApi
        .fetchImage({ tags: state.tags })
        .then((res: any) => {
          if (res && res.url) {
            if (payload && payload.firstLoad) {
              commit(FETCH_IMAGE_SUCCESS, res.url);
            } else {
              setTimeout(() => {
                commit(FETCH_IMAGE_SUCCESS, res.url);


ступай на юг, к Логову Хаал\'еш. Разыщи гнезда с яйцами, из которых должны вылупиться птенцы. Если ты раздобудешь юную самку калири, я награжу тебя по-царски.",
    ["O"] = "Отправляйтесь к Логову Хаал\'еш на Полуострове Адского Пламени и найдите молодую самку калири в гнезде калири. Посадите птенца в пустую клетку и принесите сокольничему Дренне Речной Ветер в Соколиный Дозор.",
    ["T"] = "Пух и перья",
  },
  [9398] = {
    ["D"] = "В Запределье Сломленные не испытывали ничего, кроме насилия и жестокости. Не удивительно, как только открылся Темный портал, они кинулись к нему, стремясь выбраться из этого мира.$B$BК несчастью для наших ошеломленных братьев и сестер, пришедших с юга, они стали легкой добычей для камнедеров Глубокого Разлома. Если хочешь помочь выжить моему племени, отправляйся к Разлому и уничтожь хищников.",
    ["O"] = "Убейте 8 детенышей камнеруба и 4 камнерубов-вожаков по просьбе разведчицы Вануры из Храма Телхамата на Полуострове Адского Пламени.",
    ["T"] = "Смертельно опасные хищники",
  },
  [9399] = {
    ["D"] = "Ты думаешь, все Сломленные несут в себе семена зла? На самом деле, очень многое зависит от обстоятельств. Пока я не встретил Оменай, меня тоже можно было считать потерянным.$B$BНаш разум сильно пострадал от воздействия демонической магии орков. В таком состоянии очень легко сбиться с пути и лишиться воли.$B$BДемоны, заключившие союз с Иллиданом, день за днем обыскивали Адское Пламя, находили нас и делали своими рабами. Оменай принесли нам надежду. Если хочешь, чтобы мои родичи обрели свободу, отправляйся к Руинам Ша\'наара, что на юго-западе отсюда, и убей иллидарских надсмотрщиков.",
    ["O"] = "Убейте 4 иллидарских надсмотрщиков на Руинах Ша\'наара и возвращайтесь к Икану в Храм Телхамата на Полуострове Адского Пламени.",
    ["T"] = "Безжалостные десятники",
  },
  [9400] = {
    ["D"] = "$N,


PreviewClick { key, color ->
                themeEditorEventProvider.eventFlow.update { ThemeEditorEvent.OpenColorPicker(key, color) }
            }
            setUpResetButton {
                themeEditorEventProvider.eventFlow.update { ThemeEditorEvent.ResetOverwrittenColors }
            }
        }
    }

    override fun detachView() {
        themeEditorEventProvider.eventFlow.update {
            ThemeEditorEvent.UnsubscribeFromColorChanges(this@AdvancedThemeEditPresenter)
        }
        currentState = null
        super.detachView()
    }

    override fun onStateChange(themeState: ThemeState) {
        if (themeState == currentState) return

        val model = getPreviewColorsModel(themeState)
        view.setPreviewColors(model)

        currentState = themeState
    }
}package com.therxmv.telegramthemer.domain.model

import android.graphics.Color

/**
 * Specific list of all [TintedColor].
 */
data class TintedThemeColors(
    val colors: List<TintedColor>,
) {
    operator fun get(name: String): Int =
        getHex(name)?.let { Color.parseColor(it) } ?: Color.BLACK

    private fun getHex(name: String): String? =
        colors.firstOrNull { it.name == name }?.value
}

/**
 * [name] consists of actual name and luminosity number, the higher number - the lighter color.
 * From 1 to 9, 5 is default.
 * [value] represents color in hexadecimal format
 */
data class TintedColor(
    val name: String,
    val value: String,
)

fun gray(luminosity: Int) = "gray_$luminosity"
fun accent(luminosity: Int) = "accent_$luminosity"

fun red(luminosity: Int) = "red_$luminosity"
fun orange(luminosity: Int) = "orange_$luminosity"
fun yellow(luminosity: Int) = "yellow_$luminosity"
fun green(luminosity: Int) = "green_$luminosity"
fun blue(luminosity: Int) = "blue_$luminosity"
fun purple(luminosity: Int) = "purple_$luminosity"

fun transparent(luminosity: Int) = "transparent_$luminosity"
fun trAccent(luminosity: Int) = "tr_accent_$luminosity"
fun trGray(luminosity: Int) = "tr_gray_$luminosity"package com.therxmv.preview.utils

/**
 * Each entry contains all relatable theme keys.
 * [similarKeys] list will be used to change values with the Advanced mode.
 */
@Suppress("EnumEntryName")
enum class AtthemePreviewKeys(val similarKeys: List<String>) {
    tt_background(listOf(tt_background.name)),
    tt_onBackground(listOf(tt_onBackground.name)),
    actionBarDefaultIcon(listOf(
        actionBarDefaultIcon.name,
        "actionBarActionModeDefaultIcon",
        "actionBarDefaultSubmenuItemIcon",
        "avatar_actionBarIconBlue",
        "avatar_actionBarIconCyan",
        "avatar_actionBarIconGreen",
        "avatar_actionBarIconOrange",
        "avatar_actionBarIconPink",
        "avatar_actionBarIconRed",
        "avatar_actionBarIconViolet",
    )),
    actionBarDefaultTitle(listOf(actionBarDefaultTitle.name)),
    actionBarDefaultSubtitle(listOf(actionBarDefaultSubtitle.name)),
    chats_actionBackground(listOf(chats_actionBackground.name)),
    actionBarTabUnactiveText(listOf(actionBarTabUnactiveText.name)),
    actionBarTabActiveText(listOf(actionBarTabActiveText.name)),
    actionBarTabLine(listOf(actionBarTab


s":[1222624,22456],"eu":[1094592,22456],"sh":[1071104,22456]}],
"actors/yoshi_egg/yoshi_egg_1_unused.rgba16.png": [32,32,2048,{"jp":[1215456,24504],"us":[1222624,24504],"eu":[1094592,24504],"sh":[1071104,24504]}],
"actors/yoshi_egg/yoshi_egg_2_unused.rgba16.png": [32,32,2048,{"jp":[1215456,26552],"us":[1222624,26552],"eu":[1094592,26552],"sh":[1071104,26552]}],
"actors/yoshi_egg/yoshi_egg_3_unused.rgba16.png": [32,32,2048,{"jp":[1215456,28600],"us":[1222624,28600],"eu":[1094592,28600],"sh":[1071104,28600]}],
"actors/yoshi_egg/yoshi_egg_4_unused.rgba16.png": [32,32,2048,{"jp":[1215456,30648],"us":[1222624,30648],"eu":[1094592,30648],"sh":[1071104,30648]}],
"actors/yoshi_egg/yoshi_egg_5_unused.rgba16.png": [32,32,2048,{"jp":[1215456,32696],"us":[1222624,32696],"eu":[1094592,32696],"sh":[1071104,32696]}],
"actors/yoshi_egg/yoshi_egg_6_unused.rgba16.png": [32,32,2048,{"jp":[1215456,34744],"us":[1222624,34744],"eu":[1094592,34744],"sh":[1071104,34744]}],
"actors/yoshi_egg/yoshi_egg_7_unused.rgba16.png": [32,32,2048,{"jp":[1215456,36792],"us":[1222624,36792],"eu":[1094592,36792],"sh":[1071104,36792]}],
"assets/demos/bbh.bin": [988,{"jp":[5733368],"us":[5741664],"eu":[5620584],"sh":[5589632]}],
"assets/demos/bitdw.bin": [1412,{"us":[5747100],"sh":[5595068]}],
"assets/demos/ccm.bin": [1320,{"jp":[5734356],"us":[5742652],"eu":[5621572],"sh":[5590620]}],
"assets/demos/hmc.bin": [980,{"jp":[5735676],"us":[5743972],"eu":[5622892],"sh":[5591940]}],
"assets/demos/jrb.bin": [620,{"jp":[5736656],"us":[5744952],"eu":[5623872],"sh":[5592920]}],
"assets/demos/pss.bin": [748,{"jp":[5737948],"us":[5746244],"eu":[5625164],"sh":[5594212]}],
"assets/demos/unused.bin": [108,{"jp":[5738696],"us":[5746992],"eu":[5625912],"sh":[5594960]}],
"assets/demos/wf.bin": [672,{"jp":[5737276],"us":[5745572],"eu":[5624492],"sh":[5593540]}],
"levels/bbh/0.rgba16.png": [32,64,4096,{"jp":[3604960,0],"us":[3611712,0],"eu":[3485312,0],"sh":[3459680,0]}],
"levels/bbh/1.rgba16.png": [32,32,2048,{"jp":[3604960,4096],"us":[3611712,4096],"eu":[3485312,4096],"sh":[3459680,4096]}],
"levels/bbh/2.


// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2016, NVIDIA CORPORATION.
 */

#include <common.h>
#include <dm.h>
#include <log.h>
#include <mailbox-uclass.h>
#include <malloc.h>
#include <asm/io.h>
#include <asm/mbox.h>

#define SANDBOX_MBOX_CHANNELS 2

struct sandbox_mbox_chan {
	bool rx_msg_valid;
	uint32_t rx_msg;
};

struct sandbox_mbox {
	struct sandbox_mbox_chan chans[SANDBOX_MBOX_CHANNELS];
};

static int sandbox_mbox_request(struct mbox_chan *chan)
{
	debug("%s(chan=%p)\n", __func__, chan);

	if (chan->id >= SANDBOX_MBOX_CHANNELS)
		return -EINVAL;

	return 0;
}

static int sandbox_mbox_free(struct mbox_chan *chan)
{
	debug("%s(chan=%p)\n", __func__, chan);

	return 0;
}

static int sandbox_mbox_send(struct mbox_chan *chan, const void *data)
{
	struct sandbox_mbox *sbm = dev_get_priv(chan->dev);
	const uint32_t *pmsg = data;

	debug("%s(chan=%p, data=%p)\n", __func__, chan, data);

	sbm->chans[chan->id].rx_msg = *pmsg ^ SANDBOX_MBOX_PING_XOR;
	sbm->chans[chan->id].rx_msg_valid = true;

	return 0;
}

static int sandbox_mbox_recv(struct mbox_chan *chan, void *data)
{
	struct sandbox_mbox *sbm = dev_get_priv(chan->dev);
	uint32_t *pmsg = data;

	debug("%s(chan=%p, data=%p)\n", __func__, chan, data);

	if (!sbm->chans[chan->id].rx_msg_valid)
		return -ENODATA;

	*pmsg = sbm->chans[chan->id].rx_msg;
	sbm->chans[chan->id].rx_msg_valid = false;

	return 0;
}

static int sandbox_mbox_bind(struct udevice *dev)
{
	debug("%s(dev=%p)\n", __func__, dev);

	return 0;
}

static int sandbox_mbox_probe(struct udevice *dev)
{
	debug("%s(dev=%p)\n", __func__, dev);

	return 0;
}

static const struct udevice_id sandbox_mbox_ids[] = {
	{ .compatible = "sandbox,mbox" },
	{ }
};

struct mbox_ops sandbox_mbox_mbox_ops = {
	.request = sandbox_mbox_request,
	.rfree = sandbox_mbox_free,
	.send = sandbox_mbox_send,
	.recv = sandbox_mbox_recv,
};

U_BOOT_DRIVER(sandbox_mbox) = {
	.name = "sandbox_mbox",
	.id = UCLASS_MAILBOX,
	.of_match = sandbox_mbox_ids,
	.bind = sandbox_mbox_bind,
	.probe = sandbox_mbox_probe,
	.priv_auto	= sizeof(struct sandbox_mbox),
	.ops = &sandbox_mbox_mbox_ops,
};


errors.Wrap(err, "connect to mongodb"), app.pbmOutF)
	}
	app.ctx = log.SetLoggerToContext(app.ctx, log.New(app.conn, "", ""))

	ver, err := version.GetMongoVersion(app.ctx, app.conn.MongoClient())
	if err != nil {
		fmt.Fprintf(os.Stderr, "get mongo version: %v", err)
		os.Exit(1)
	}
	if err := version.FeatureSupport(ver).PBMSupport(); err != nil {
		fmt.Fprintf(os.Stderr, "WARNING: %v\n", err)
	}

	app.pbm, err = sdk.NewClient(app.ctx, app.mURL)
	if err != nil {
		exitErr(errors.Wrap(err, "init sdk"), app.pbmOutF)
	}

	inf, err := topo.GetNodeInfo(app.ctx, app.conn.MongoClient())
	if err != nil {
		exitErr(errors.Wrap(err, "unable to obtain node info"), app.pbmOutF)
	}
	app.node = inf.Me

	return nil
}

func (app *pbmApp) persistentPostRun(cmd *cobra.Command, args []string) error {
	if app.pbm != nil {
		ctxPbm, cancelPbm := context.WithTimeout(context.Background(), 2*time.Second)
		defer cancelPbm()

		if err := app.pbm.Close(ctxPbm); err != nil {
			return errors.Wrap(err, "close pbm")
		}
	}

	if app.conn != nil {
		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
		defer cancel()

		if err := app.conn.Disconnect(ctx); err != nil {
			return errors.Wrap(err, "close conn")
		}
	}

	if app.cancel != nil {
		app.cancel()
	}

	return nil
}

func (app *pbmApp) buildBackupCmd() *cobra.Command {
	validCompressions := []string{
		string(compress.CompressionTypeNone),
		string(compress.CompressionTypeGZIP),
		string(compress.CompressionTypeSNAPPY),
		string(compress.CompressionTypeLZ4),
		string(compress.CompressionTypeS2),
		string(compress.CompressionTypePGZIP),
		string(compress.CompressionTypeZstandard),
	}

	validBackupTypes := []string{
		string(defs.PhysicalBackup),
		string(defs.LogicalBackup),
		string(defs.IncrementalBackup),
		string(defs.ExternalBackup),
	}

	backupOptions := backupOpts{}

	backupCmd := &cobra.Command{
		Use:   "backup",
		Short: "Make backup",
		RunE: app.wrapRunE(func(cmd *cobra.Command, args []string) (fmt.Stringer, error) {
			if err := app.validateEnum("compression", backupOptions.compression, validCompressions); err != nil {
				return nil, err
			}

			if err := app.validateEnum("type", backupOptions.typ, validBackupTypes); err != nil {
				return nil, err
			}

			backupOptions.name = time.Now().UTC().Format(time.RFC3339)
			return runBackup(app.ctx, app.conn, app.pbm, &backupOptions, app.pbmOutF)
		}),
	}

	backupCmd.Flags().StringVar(
		&backupOptions.compression, "compression", "",
		"Compression type <none>/<gzip>/<snappy>/<lz4>/<s2>/<pgzip>/<zstd>",
	)
	backupCmd.Flags().StringVarP(
		&backupOptions.typ, "type", "t", string(defs.LogicalBackup),
		fmt.Sprintf(
			"backup type: <%s>/<%s>/<%s>/<%s>",
			defs.PhysicalBackup


{
                if (filePath.endsWith('.br')) {
                    targetPath = filePath.replace(/\.br$/, '');
                } else {
                    targetPath = `${filePath}.dec`;
                }
            }

            this._moduleInstance.decompressFile(filePath, targetPath, (err) => {
                if (!err) return resolve();
                reject(new Error(`General Error when decompressing ${filePath}`));
            });
        })
    }

}

export const BrotliModule = new _BrotliModule();
import {assert, expect} from 'chai';
import 'mocha';
import {validate} from "../src/validation";

const array =[
    {
        ID: 10001,
        Name: "Alex",
        Surname: "Navalny",
        Mail: "navlex@mail.ru",
        Date: "01.05.2018",
        Phone: "375 33 2352356",
    },
    {
        ID: 1001,
        Name: "Alexthebesthumanintheworld",
        Surname: "Navalny",
        Mail: "navlex@mail.ru",
        Date: "01.05.2018",
        Phone: "375 33 2352356",
    },
    {
        ID: 1001,
        Name: "Alex",
        Surname: "Navalny",
        Mail: "navlex@mail.ru",
        Date: "01.05.2018",
        Phone: "375 33 23523566565",
    },
];

const array1 = [
    {
        ID: 1001,
        Name: "Alex",
        Surname: "Navalny",
        Mail: "navlex@mail.ru",
        Date: "01.05.2018",
        Phone: "375 33 2352356",
    },
];

describe('validate', () => {
    it('Return empty array if invalid', () => {
        let empty = [];
       expect(validate(array).length).to.equal(empty.length);
    });
})

describe('validate', () => {
    it('Return valid array if valid', () => {
        expect(validate(array1).length).to.equal(1);
    });
})export default class ConnectionTimeoutWatcher {
  private onDisconnected: Function;
  private timeout: NodeJS.Timeout | null;
  static readonly TIMEOUT_SEC: number = 10;

  constructor(onDisconnected: Function) {
    this.onDisconnected = onDisconnected;
    this.timeout = null;
  }

  notify() {
    if (this.timeout) {
      clearTimeout(this.timeout);
    }
    console.debug('ConnectionTimeoutWatcher: notified');
    this.timeout = setTimeout(() => {
      this.onDisconnected();
      console.debug('ConnectionTimeoutWatcher: timeout');
    }, ConnectionTimeoutWatcher.TIMEOUT_SEC * 1000);
  }
}
import { Interval } from "./interval";

export class PitchClass {
  static C = new PitchClass(0);
  static Cis = new PitchClass(1);
  static get Des(): PitchClass {
    return this.Cis;
  }
  static D = new PitchClass(2);
  static Dis = new PitchClass(3);
  static get Es(): PitchClass {
    return this.Dis;
  }
  static E = new PitchClass(4);
  static F = new PitchClass(5);
  static Fis = new PitchClass(6);
  static get Ges(): PitchClass {
    return this.Fis;
  }
  static G = new PitchClass(7);
  static Gis = new PitchClass(8);
  static get As(): PitchClass {
    return this.Gis;
  }
  static A = new PitchClass(9);
  static B = new PitchClass(10);
  static get Ais(): PitchClass {
    return this.B;
  }
  static H = new PitchClass(11);

  static pitchClasses = function*(
    from: PitchClass = PitchClass.C
  ): IterableIterator<PitchClass> {
    let current = from;
    while (true) {
      current = current.next();


attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n    "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("return")]),t._v(" max"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n\n")])])]),a("p",[t._v("Now the entire block can be commented out easily:")]),t._v(" "),a("div",{staticClass:"language-c extra-class"},[a("pre",{pre:!0,attrs:{class:"language-c"}},[a("code",[a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("/*\n\n// max(): Finds the largest integer in an array and returns it.\n// If the array length is less than 1, the result is undefined.\n// arr: The array of integers to search.\n// num: The number of integers in arr.\nint max(int arr[], int num)\n{\n    int max = arr[0];\n    for (int i = 0; i < num; i++)\n        if (arr[i] > max)\n            max = arr[i];\n    return max;\n}\n\n*/")]),t._v("\n\n")])])]),a("p",[t._v("Another solution is to avoid disabling code using comment syntax, using "),a("code",[t._v("#ifdef")]),t._v(" or "),a("code",[t._v("#ifndef")]),t._v(" preprocessor directives instead. These directives "),a("strong",[t._v("do")]),t._v(" nest, leaving you free to comment your code in the style you prefer.")]),t._v(" "),a("div",{staticClass:"language-c extra-class"},[a("pre",{pre:!0,attrs:{class:"language-c"}},[a("code",[a("span",{pre:!0,attrs:{class:"token macro property"}},[a("span",{pre:!0,attrs:{class:"token directive-hash"}},[t._v("#")]),a("span",{pre:!0,attrs:{class:"token directive keyword"}},[t._v("define")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token macro-name"}},[t._v("DISABLE_MAX")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("/* Remove or comment this line to enable max() code block */")])]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token macro property"}},[a("span",{pre:!0,attrs:{class:"token directive-hash"}},[t._v("#")]),a("span",{pre:!0,attrs:{class:"token directive keyword"}},[t._v("ifdef")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token expression"}},[t._v("DISABLE_MAX")])]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("/*\n * max(): Finds the largest integer in an array and returns it.\n * If the array length is less than 1, the result is undefined.\n * arr: The array of integers to search.\n * num: The number of integers in arr.\n */")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("int")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token function"}},[


Self::Json(Json(serde_json::to_string(t)?)))
	}
}

#[derive(Debug, Serialize)]
struct TitleEntry {
	title: String,
	url: PathBuf
}

fn content_type(node: &Node) -> Result<ContentType> {
	use std::str::FromStr;
	let info = node.xattrs(XattrType::User)?.into_iter().map(|(k, v)| (String::from_utf8_lossy(&k).into_owned(), String::from_utf8_lossy(&v).into_owned())).collect::<HashMap<String, String>>();
	Ok(match info.get("type") {
		Some(ctype) => ContentType::from_str(ctype).map_err(|x| anyhow!("\"{}\" is not a valid MIME type: {}", ctype, x))?,
		None => {
			let ext = node
				.path().ok_or(anyhow!("Couldn't get file path to determine content type"))?
				.extension().ok_or(anyhow!("Unknown resource extension"))?
				.to_str().ok_or(anyhow!("Invalid resource extension"))?;
			ContentType::from_extension(ext)
				.ok_or(anyhow!("Unknown resource content type"))?
		}
	})
}

#[get("/rsrc/<path..>")]
fn rsrc(app: State<App>, path: UncheckedPath) -> Result<Content<Vec<u8>>> {
	let (mut file, ctype) = app.resource(&path.get())?;
	Ok(Content(ctype, file.to_bytes()?))
}

#[get("/")]
fn home(app: State<App>) -> Result<Response> {
	Ok(Response::html(app.template("home", &json!({"priv": true, "viewbase": "/view", "categories": app.library.tokens()}))?)) // TODO priv, viewbase
}

#[get("/content/<id>/<path..>")] // TODO Fragments and query params passed through?
fn content<'a>(app: State<'a, App>, id: String, path: UncheckedPath) -> Result<Response<'a>> {
	let pathbuf = path.get();
	let volume = app.inner().library.get(&id)?;
	match (*volume).get(&pathbuf) {
		Err(_) => Ok(Response::html("error getting file".to_string())), // TODO Nice error
		Ok(None) => Ok(Response::html("I'm a 404.".to_string())), // TODO 404
		Ok(Some(node)) => {
			match node.data()? {
				Data::File(_) => {
					let ctype = content_type(&node)?;
					let conv = |vol: *const Volume| -> Result<OwnedFile<'a>> { unsafe { Ok((*vol).get(&pathbuf)?.unwrap().into_owned_file()?) } }; // TODO This needs some work!
					let read = ReadHandle { handle: OwningHandle::try_new(volume, conv)? };
					Ok(Response::Stream(Content(ctype, Stream::from(read))))
				},
				Data::Symlink(target) => Ok(Response::redirect(uri!(content: id, PathBuf::from(target)))),
				_ => Err(anyhow!("Target {} is not a file or symlink"))?,
			}
		},
	}
}

#[get("/view/<id>/<path..>")]
fn view<'a>(app: State<'a, App>, id: String, path: UncheckedPath) -> Result<Response<'a>> {
	let pathbuf = path.get();
	// TODO Implement toolbar
	Ok(Response::redirect(uri!(content: id, pathbuf)))
}

#[get("/view/<id>")]
fn view_default<'a>(app: State<'a, App>, id: String) -> Result<Redirect> {
	let home = app.inner().library.get(&id)?.info().home.clone();
	Ok(Redirect::to(uri!


5562] = "Grimório Vil de Vim'gol",
[185567] = "Crânio de Dragão de Grulloc",
[185569] = "Baú do Tesouro de Maggoc",
[185574] = "Estandarte de Slaag",
[185577] = "Alma de Skulloc",
[185584] = "Espinho de Naj'entus",
[185598] = "Barril de Cerveja Ôgrica da Lâmina Afiada",
[185604] = "Salva de Fogos Azuis Grande",
[185605] = "Salva de Fogos Verdes Grande",
[185606] = "Salva de Fogos Vermelhos Grande",
[185607] = "Salva de Fogos Amarelos Grande",
[185608] = "Simon Game Base Blue Small",
[185609] = "Salva de Fogos Azuis",
[185610] = "Simon Game Base Green Smalll",
[185611] = "Salva de Fogos Verdes",
[185612] = "Simon Game Base Red Small",
[185613] = "Salva de Fogos Vermelhos",
[185614] = "Simon Game Base Yellow Small",
[185615] = "Salva de Fogos Amarelos",
[185616] = "Simon Game Base Blue Small",
[185617] = "Salva de Fogos Azuis",
[185618] = "Simon Game Base Green Smalll",
[185619] = "Salva de Fogos Verdes",
[185620] = "Simon Game Base Red Small",
[185621] = "Salva de Fogos Vermelhos",
[185622] = "Simon Game Base Yellow Small",
[185623] = "Salva de Fogos Amarelos",
[185624] = "Salva de Fogos Amarelos",
[185625] = "Salva de Fogos Azuis",
[185626] = "Salva de Fogos Vermelhos",
[185627] = "Salva de Fogos Verdes",
[185628] = "Simon Game Base Green Smalll",
[185629] = "Simon Game Base Yellow Small",
[185630] = "Simon Game Base Blue Small",
[185631] = "Simon Game Base Red Small",
[185632] = "Simon Game Base Green Smalll",
[185633] = "Simon Game Base Yellow Small",
[185634] = "Simon Game Base Blue Small",
[185635] = "Simon Game Base Red Small",
[185636] = "Salva de Fogos Amarelos",
[185637] = "Salva de Fogos Azuis",
[185638] = "Salva de Fogos Vermelhos",
[185639] = "Salva de Fogos Verdes",
[185640] = "Salva de Fogos Azuis Grande",
[185641] = "Salva de Fogos Verdes Grande",
[185642] = "Salva de Fogos Vermelhos Grande",
[185643] = "Salva de Fogos Amarelos Grande",
[185644] = "Salva de Fogos Amarelos",
[185645] = "Salva de Fogos Vermelhos",
[185646] = "Salva de Fogos Verdes",
[185647] = "Salva de Fogos Azuis",
[185648] = "Salva de Fogos Amarelos",
[185649] = "Salva de Fogos Azuis",
[185650] = "Salva de Fogos Vermelhos",
[185651] = "Salva de Fogos Verdes",
[185652] = "Salva de Fogos Azuis",
[185653] = "Salva de Fogos Amarelos",
[185654] = "Salva de Fogos Verdes",
[185655] = "Salva de Fogos Vermelhos",
[185656] = "Salva de Fogos Amarelos",
[185657] = "Salva de Fogos Vermelhos",
[185658] = "Salva de Fogos Verdes",
[185659] = "Salva de Fogos Azuis",
[185660] = "Salva de Fogos Azuis Grande",
[185661] = "Salva de Fogos Verdes Grande",
[185662] = "Salva de F


         }                   13,229 - 13,229
 RBRACE         }                   14,243 - 14,243
 ENDMARKER                          15,257 - 15,257
```

# Bamboolib

A GUI for pandas.

- [Home](https://bamboolib.com/)
- GitHub: https://github.com/8080labs/bamboolib
- Online documentation: https://docs.bamboolib.8080labs.com/
- Supporting / dependency library:
  - pyforest: [GitHub](https://github.com/8080labs/pyforest) | [pypi](https://pypi.org/project/pyforest/)
- Blogs
  - [Introducing Bamboolib — a GUI for Pandas](https://towardsdatascience.com/introducing-bamboolib-a-gui-for-pandas-4f6c091089e3)
  - [Bamboolib — Learn and use Pandas without Coding](https://towardsdatascience.com/bamboolib-learn-and-use-pandas-without-coding-23a7d3a94e1b)
- Videos
 - [Intro to bamboolib - a GUI for pandas](https://www.youtube.com/watch?v=5UR1v3uxqW4&feature=share)
 - [Demo on big data (1mio rows)](https://www.youtube.com/watch?v=r59Q19oCMr8)
 - [All other videos](https://www.youtube.com/channel/UCQLqkDYCGnqczni1IWyAYvA/videos?view=0&sort=da&flow=grid)
- On Kaggle
  - [How to: Use bamboolib within Kaggle](https://docs.bamboolib.8080labs.com/how-tos/use-bamboolib-within-kaggle)
  - [Trying Bamboolib - Pandas GUI on Kaggle ](https://www.kaggle.com/nulldata/trying-bamboolib-pandas-gui-on-kaggle)
- [LinkedIn post](https://www.linkedin.com/posts/parulpandeyindia_bamboolib-pandas-activity-6610109280953700352-Cuie)
- Linkedin: https://www.linkedin.com/company/bamboolib/
- Twitter: https://twitter.com/bamboolib_
---

- [x] **[AI/ML/DL Library / Package / Framework: applicable]**
- [ ] [Inexpensive crowd-sourced infrastructure sharing: applicable]
- [x] **[Data querying]**
- [ ] [Data analytics: manual / tools available]
- [x] **[Data visualisation]**
- [x] **[Data cleaning]**
- [x] **[Data validation]**
- [ ] [Feature extraction: manual / no tools available]
- [ ] [Model creation: available]
- [ ] [Execute experiments: available]
- [ ] [Hyper parameter tuning: available]
- [ ] [Model saving: available]

Back to [Programs and Tools](./programs-and-tools.md#programs-and-tools). <br/>
Back to [Data page](./README.md#data).
# Statistics

- [An Introduction To Statistical Learning with Applications in R](https://github.com/tpn/pdfs/blob/master/An%20Introduction%20To%20Statistical%20Learning%20with%20Applications%20in%20R%20(ISLR%20Sixth%20Printing).pdf)
- Statistical Inferencing
    - [Understanding statistical inference [video]](https://www.youtube.com/watch?v=tFRXsngz4UQ)
    - [Four ideas of Statistical Inference](http://www.bristol.ac.uk/medical-school/media/rms/red/4_ideas_of_statistical_inference.html)
    - [An Introduction to Statistical Learning [book]](http://www-bcf.usc.edu/~gareth/ISL/)
    - See [Statistics courses](../courses.md#statistics) under [Courses](../courses.md#courses)
- [Understand Your Machine Learning Data Wi


"+40", 9..9),
	RS("RS", "Serbia", "+381", 8..8),
	RU("RU", "Russia", "+7", 10..10),
	RW("RW", "Rwanda", "+250", 9..9),
	SA("SA", "Saudi Arabia", "+966", 9..9),
	SB("SB", "Solomon Islands", "+677", 7..7),
	SC("SC", "Seychelles", "+248", 7..7),
	SD("SD", "Sudan", "+249", 9..9),
	SE("SE", "Sweden", "+46", 10..10),
	SG("SG", "Singapore", "+65", 8..8),
	SH("SH", "Saint Helena", "+290", 4..4),
	SI("SI", "Slovenia", "+386", 8..8),
	SJ("SJ", "Svalbard and Jan Mayen", "+47", 8..8),
	SK("SK", "Slovakia", "+421", 9..9),
	SL("SL", "Sierra Leone", "+232", 8..8),
	SM("SM", "San Marino", "+378", 7..7),
	SN("SN", "Senegal", "+221", 8..8),
	SO("SO", "Somalia", "+252", 7..8),
	SR("SR", "Suriname", "+597", 7..8),
	SS("SS", "South Sudan", "+211", 9..9),
	ST("ST", "São Tomé and Príncipe", "+239", 8..8),
	SV("SV", "El Salvador", "+503", 8..8),
	SX("SX", "Sint Maarten", "+1-721", 7..7),
	SY("SY", "Syria", "+963", 9..9),
	SZ("SZ", "Eswatini", "+268", 7..8),
	TC("TC", "Turks and Caicos Islands", "+1-649", 7..7),
	TD("TD", "Chad", "+235", 8..8),
	TG("TG", "Togo", "+228", 8..8),
	TH("TH", "Thailand", "+66", 10..10),
	TJ("TJ", "Tajikistan", "+992", 9..9),
	TK("TK", "Tokelau", "+690", 4..4),
	TL("TL", "East Timor", "+670", 8..8),
	TM("TM", "Turkmenistan", "+993", 8..8),
	TN("TN", "Tunisia", "+216", 8..8),
	TO("TO", "Tonga", "+676", 4..7),
	TR("TR", "Turkey", "+90", 10..10),
	TT("TT", "Trinidad and Tobago", "+1-868", 7..7),
	TV("TV", "Tuvalu", "+688", 5..5),
	TW("TW", "Taiwan", "+886", 9..9),
	TZ("TZ", "Tanzania", "+255", 9..10),
	UA("UA", "Ukraine", "+380", 9..9),
	UG("UG", "Uganda", "+256", 9..9),
	US("US", "United States", "+1", 10..10),
	UY("UY", "Uruguay", "+598", 8..8),
	UZ("UZ", "Uzbekistan", "+998", 9..9),
	VA("VA", "Vatican City", "+379", 9..9),
	VC("VC", "Saint Vincent and the Grenadines", "+1-784", 7..7),
	VE("VE", "Venezuela", "+58", 10..10),
	VG("VG", "British Virgin Islands", "+1-284", 7..7),
	VI("VI", "U.S. Virgin Islands", "+1-340", 7..7),
	VN("VN", "Vietnam", "+84", 10..10),
	VU("VU", "Vanuatu", "+678", 7..7),
	WF("WF", "Wallis and Futuna", "+681", 6..6),
	WS("WS", "Samoa", "+


1

1

1

1

1

1

1

1

List:

				Watched

					Wanted

				Custom

5
	4 Watched	2 Want to

		<img class='product' src='http://i2.lis


 2.142.257 2.885.704 0 0-.402-.129-.811-.183-.205.21-.382.298-.437.325z"/></svg>';
  static const String ape =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="32" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 32 32"><path fill="currentColor" d="M16 0c8.837 0 16 7.163 16 16s-7.163 16-16 16S0 24.837 0 16 7.163 0 16 0zm12.445 14.517-.067.166-.007.03v.04c-.06.447-.16.903-.3 1.36a6.629 6.629 0 01-1.004 1.94 6.51 6.51 0 01-1.306 1.367c-.132.11-.24.239-.306.368a1.66 1.66 0 00-.13.467l-.014.205-.015.173-.01.101-.011.094-.012.088-.014.085-.016.086-.008.044c-.194 1.066-.56 1.83-1.147 2.717l-.608.88c-.882 1.16-1.914 1.918-3.144 2.302l-.367.112-.272.037c-.392.065-.767.1-1.106.1h-.508l-.31.02c-.223 0-.435.04-.672.125-.856.268-1.882.405-3.138.415h-.229l-.251-.002-.17-.004-.265-.008-.28-.012-.302-.015-.801-.048c.192.07.387.136.584.198l.209.01.303.015.19.009.27.01.174.003.254.004.169.001c1.338 0 2.426-.14 3.335-.425a1.79 1.79 0 01.625-.116l.31-.02h.503c.349 0 .732-.036 1.13-.101l.283-.04.276-.083c1.31-.384 2.403-1.171 3.332-2.393l.612-.885c.576-.872.944-1.628 1.148-2.657l.04-.209.015-.087.013-.089.012-.092.01-.1.01-.107.02-.253.005-.073c.018-.144.055-.277.115-.415.053-.104.147-.216.262-.31a6.664 6.664 0 001.335-1.4 6.785 6.785 0 001.027-1.985l.046-.155.09-.338c.028-.113.054-.226.077-.339l.059-.332-.006-.076-.047-.403zm-.574-2.398-.021.263-.033.275-.04.262-.009.06v.051a6.532 6.532 0 01-.401 1.335l-.018.035-.008.033v.047l-.016.07a.232.232 0 00-.004.043v.06a5.53 5.53 0 01-.26 1.14c-.19.56-.45 1.08-.773 1.544l-.07.098a5.718 5.718 0 01-1.224 1.267c-.2.139-.373.34-.508.585-.117.212-.18.442-.19.69l-.002.067c0 .291-.033.578-.1.907a5.912 5.912 0 01-.574 1.628l-.049.092-.048.088-.049.086-.052.089-.056.094-.1.16-.078.123-.445.639c-.794 1.084-1.698 1.763-2.782 2.074l-.063.021-.03.007-.04.01-.069.02a.444.444 0