           } else if(writtenConst + EVM_WORD_SIZE == data.sz) {
                Alloc.PackedByteArray(
                    finalWrite = fpUpdate.ptr
                )
            } else {
                // if we see a write that is *definitely* not a length, return non-null here, short-circuiting later checks
                data
            }
        }
        return Alloc.ConstantArrayAlloc(
            constSize = writtenConst,
            eSz = EVM_WORD_SIZE
        )
    }

    private fun TACCommandGraph.blockCommandsForwardIgnoreRevert(ptr: CmdPointer) : Sequence<LTACCmd> {
        return sequence {
            for(c in this@blockCommandsForwardIgnoreRevert.blockCmdsForwardFrom(ptr)) {
                yield(c)
            }
            val rev = cache.revertBlocks
            var nxt = succ(ptr.block).singleOrNull {
                it !in rev
            }
            val visited = treapSetBuilderOf<NBId>()
            while(nxt != null) {
                if(!visited.add(nxt)) {
                    return@sequence
                }
                elab(nxt).commands.forEach {
                    yield(it)
                }
                nxt = succ(nxt).singleOrNull {
                    it !in rev
                }
            }
        }
    }

    /**
     *  If we have
     *    tacM0x40 = V ([fpUpdate])
     *    ...
     *    tacM[ptr] = sz
     *
     *  And, if
     *    - ptr is actually the value of tacM0x40 *before* storing V
     *    - sz is a constant s.t. sz*32 + 32 = [data.sz]
     *
     *  Then we are probably storing the (constant) size of the array when we write sz,
     *  so we should treat the allocation in question as a const array
     */
    private fun lengthPostWriteHeuristic(
        graph: TACCommandGraph,
        fpUpdate: LTACCmdView<TACCmd.Simple.AssigningCmd>,
        data: Alloc.ConstBlock
    ): Alloc? {
        val byteStore = graph.blockCmdsForwardFrom(fpUpdate.ptr).firstNotNullOfOrNull { c ->
            c.maybeNarrow<TACCmd.Simple.AssigningCmd.ByteStore>()
        } ?: return null
        val constValue = MustBeConstantAnalysis(graph, NonTrivialDefAnalysis(graph)).mustBeConstantAt(byteStore.ptr, byteStore.cmd.value) ?: return null
        if(BigInteger.ZERO == constValue || TACKeyword.MEM64.toVar() !in graph.cache.gvn.findCopiesAt(fpUpdate.ptr,byteStore.ptr to byteStore.cmd.loc)) {
            return null
        }
        /*
         * If we are allocing a constant sized byte-sized array (which has not already been caught by the string heuristic, harumph)
         * then we insist on finding a bytelong copy for init.
         *
         * Otherwise we end up with something cursed happening like:
         * ```
         * struct Foo {
         *    uint a;
         *    address whatever;
         * }
         *
         * Foo memory x = Foo{ a: 8, address: ... };
         * ```
         *
         * Where `x` gets classified as a constant alloc (8 rounded up to nearest word + 32 == 64 == sizeOf(Foo) and
         * 8 is written in the first word post alloc...)
         */
        if((constValue + 31.toBigInteger()).andNot(31.toBigInteger()) + EVM_WORD_SIZE == data.sz) {
            val seenInit = graph.succ(byteStore.ptr).singleOrNull()?.let {
                graph.blockCommandsForwardIgnoreRevert(it)
            }?.takeWhile {
                it.cmd.getLhs() != TACKeyword.MEM64.toVar() && it.cmd !is TACCmd.Simple.AssigningCmd.ByteLoad && it.cmd !is TACCmd.Simple.AssigningCmd.ByteStore
            }?.firstOrNull {
                 it.cmd is TACCmd.Simple.ByteLongCopy
            }?.let {
                it.cmd is T


ious rule */
}

button {
  overflow: visible;
  /* Address `overflow` set to `hidden` in IE 8/9/10/11 */
}

button,
select {
  text-transform: none;
  /* Firefox 40+, Internet Explorer 11- */
}

/* Apply cursor pointer to button elements */
button,
[type=button],
[type=reset],
[type=submit],
[role=button] {
  cursor: pointer;
  color: inherit;
}

/* Remove inner padding and border in Firefox 4+ */
button::-moz-focus-inner,
[type=button]::-moz-focus-inner,
[type=reset]::-moz-focus-inner,
[type=submit]::-moz-focus-inner {
  border-style: none;
  padding: 0;
}

/* Replace focus style removed in the border reset above */
button:-moz-focusring,
[type=button]::-moz-focus-inner,
[type=reset]::-moz-focus-inner,
[type=submit]::-moz-focus-inner {
  outline: 1px dotted ButtonText;
}

button,
html [type=button],
[type=reset],
[type=submit] {
  -webkit-appearance: button;
  /* Correct the inability to style clickable types in iOS */
}

/* Remove the default button styling in all browsers */
button,
input,
select,
textarea {
  background-color: transparent;
  border-style: none;
}

/* Style select like a standard input */
select {
  -moz-appearance: none;
  /* Firefox 36+ */
  -webkit-appearance: none;
  /* Chrome 41+ */
}

select::-ms-expand {
  display: none;
  /* Internet Explorer 11+ */
}

select::-ms-value {
  color: currentColor;
  /* Internet Explorer 11+ */
}

legend {
  border: 0;
  /* Correct `color` not being inherited in IE 8/9/10/11 */
  color: inherit;
  /* Correct the color inheritance from `fieldset` elements in IE */
  display: table;
  /* Correct the text wrapping in Edge and IE */
  max-width: 100%;
  /* Correct the text wrapping in Edge and IE */
  white-space: normal;
  /* Correct the text wrapping in Edge and IE */
  max-width: 100%;
  /* Correct the text wrapping in Edge 18- and IE */
}

::-webkit-file-upload-button {
  /* Correct the inability to style clickable types in iOS and Safari */
  -webkit-appearance: button;
  color: inherit;
  font: inherit;
  /* Change font properties to `inherit` in Chrome and Safari */
}

/* # =================================================================
   # Specify media element style
   # ================================================================= */
img {
  border-style: none;
  /* Remove border when inside `a` element in IE 8/9/10 */
}

/* Add the correct vertical alignment in Chrome, Firefox, and Opera */
progress {
  vertical-align: baseline;
}

/* # =================================================================
   # Accessibility
   # ================================================================= */
/* Hide content from screens but not screenreaders */
@media screen {
  [hidden~=screen] {
    display: inherit;
  }

  [hidden~=screen]:not(:active):not(:focus):not(:target) {
    position: absolute !important;
    clip: rect(0 0 0 0) !important;
  }
}
/* Specify the progress cursor of updating elements */
[aria-busy=true] {
  cursor: progress;
}

/* Specify the pointer cursor of trigger elements */
[aria-controls] {
  cursor: pointer;
}

/* Specify the unstyled cursor of disabled, not-editable, or otherwise inoperable elements */
[aria-disabled=true] {
  cursor: default;
}

.v-application .elevation-24 {
  box-shadow: 0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px


return getNone.get();
            }
        } catch (InterruptedException e) {
            throw new CustomizeRedissonException(ReturnCode.LOCK_SERVICE_ERROR);
        } finally {
            if (lockResult) {
                if (lock.isLocked()) {
                    lock.unlock();
                }
            }
        }
    }

    /**
     * 无论获取锁成功与否均带有自定义类型返回值，自动释放型，自定义等待分布式锁
     *
     * @param key       锁键值
     * @param waitTime  最大等待时间
     * @param leaseTime 自动释放时间
     * @param timeUnit  时间单位
     * @param getLock   获取锁成功的操作
     * @param getNone   获取锁失败的操作
     * @param <T>       返回的类型泛型
     * @return 返回结果
     */
    public static <T> T lockEvent(String key, long waitTime, long leaseTime, TimeUnit timeUnit, Supplier<T> getLock, Supplier<T> getNone) {
        RLock lock = REDISSON_CLIENT.getLock(KeyPrefixConstants.LOCK_PREFIX + key);
        boolean lockResult = false;
        try {
            lockResult = lock.tryLock(waitTime, leaseTime, Objects.isNull(timeUnit) ? TimeUnit.MILLISECONDS : timeUnit);
            if (lockResult) {
                return getLock.get();
            } else {
                return getNone.get();
            }
        } catch (InterruptedException e) {
            throw new CustomizeRedissonException(ReturnCode.LOCK_SERVICE_ERROR);
        } finally {
            if (lockResult) {
                if (lock.isLocked()) {
                    lock.unlock();
                }
            }
        }
    }

}package top.sharehome.springbootinittemplate.aop.studyDemo.annotation.atArgsAop.service.impl;

import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import top.sharehome.springbootinittemplate.aop.studyDemo.annotation.atArgsAop.annotation.AtArgsClass;
import top.sharehome.springbootinittemplate.aop.studyDemo.annotation.atArgsAop.annotation.param.Demo;
import top.sharehome.springbootinittemplate.aop.studyDemo.annotation.atArgsAop.service.AtArgsService;

/**
 * 针对切点参数为@args型的切面类的服务实现类
 *
 * @author AntonyCheng
 */
@Service
public class AtArgsServiceImpl implements AtArgsService {

    @Resource
    private AtArgsClass atArgsClass;

    @Override
    public void doMethod1() {
        System.out.println(atArgsClass.annotationMethod(new Demo("AtArgsServiceImpl.doMethod1()")));
    }

    @Override
    public String doMethod2() {
        return atArgsClass.annotationMethod(new Demo("AtArgsServiceImpl.doMethod2()"));
    }

    @Override
    public void doMethod3() throws Exception {
        System.out.println(atArgsClass.annotationMethod(new Demo("AtArgsServiceImpl.doMethod3()")));
        throw new Exception("some exception");
    }

    @Override
    public void doMethod4(String param) {
        System.out.println(atArgsClass.annotationMethod(new Demo("AtArgsServiceImpl.doMethod4()")) + " " + param);
    }

}package top.sharehome.springbootinittemplate.aop.studyDemo.annotation.atAnnotationAop.service.impl;

import jakarta.annotation.Resource;
import org.springfra


系修改下，导入至Neo4J中，得到的实体关系图如下：

![](https://img2018.cnblogs.com/blog/1219272/201906/1219272-20190629174227185-485981443.png)

  最后一篇为长篇小说——著名作家路遥的《平凡的世界》第一部。利用我们的关系抽取模型，一共在该小说中抽取了169对实体关系，其中有效实体关系100对。由于我们在该小说中抽取的实体关系过多，因此只展示前10条原文及抽取的实体关系：

> 原文,s,p,o
每天来回二十里路，与他一块上学的金波和大队书记田福堂的儿子润生都有自行车，只有他是两条腿走路。,田福堂,儿子,润生\
不过，他对润生的姐姐润叶倒怀有一种亲切的感情。,润生,姐姐,润叶\
“金波是金俊海的小子。”,金俊海,小子,“金波\
脑子里把前后村庄未嫁的女子一个个想过去，最后选定了双水村孙玉厚的大女子兰花。,双水村孙玉厚,大女子,兰花\
玉亭是大队党支部委员、农田基建队队长、贫下中农管理学校委员会主任，一身三职，在村里也是一个人物。,贫下中农管理学校,主任,玉亭\
玉亭是大队党支部委员、农田基建队队长、贫下中农管理学校委员会主任，一身三职，在村里也是一个人物。,农田基建队,队长,玉亭\
玉亭是大队党支部委员、农田基建队队长、贫下中农管理学校委员会主任，一身三职，在村里也是一个人物。,大队,党支部委员,玉亭\
会战总指挥是公社副主任徐治功，副总指挥是公社武装专干杨高虎。,公社,武装,杨高虎\
会战总指挥是公社副主任徐治功，副总指挥是公社武装专干杨高虎。,公社,副主任,徐治功\
这时候，双水村妇女主任贺凤英，正领着本村和外村的一些“铁姑娘”，忙碌地布置会场。,双水村,妇女主任,贺凤英\
……

&


 on 2023/6/24.
//

/*
 * Tencent is pleased to support the open source community by making
 * WCDB available.
 *
 * Copyright (C) 2017 THL A29 Limited, a Tencent company.
 * All rights reserved.
 *
 * Licensed under the BSD 3-Clause License (the "License"); you may not use
 * this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 *       https://opensource.org/licenses/BSD-3-Clause
 *
 * 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 com.tencent.wcdbtest.base

import com.tencent.wcdb.base.WCDBException
import com.tencent.wcdb.core.Database
import org.junit.Before
import org.junit.BeforeClass
import org.junit.Rule
import org.junit.rules.TemporaryFolder
import java.io.File

open class BaseTestCase {
    var currentDirectory: String? = null

    @Before
    @Throws(WCDBException::class)
    open fun setup() {
        currentDirectory = tempFolder.root.path + File.separator + javaClass.simpleName
        logInfo("Current directory: $currentDirectory")
    }

    @get:Rule
    var tempFolder = TemporaryFolder()

    companion object {
        @BeforeClass
        @JvmStatic
        fun globalSetUp() {
            Database.globalTracePerformance(null)
            Database.globalTraceSQL(null)
            Database.globalTraceException { exception ->
                if (exception.level.ordinal >= WCDBException.Level.Error.ordinal) {
                    logError(exception.toString())
                } else {
                    logInfo(exception.toString())
                }
                assert(exception.level != WCDBException.Level.Fatal)
            }
        }

        fun logInfo(msg: String?, vararg args: Any?) {
            var log = msg
            if (args.isNotEmpty()) {
                log = String.format(msg!!, *args)
            }
            println(log)
        }

        fun logError(msg: String?, vararg args: Any?) {
            var log = msg
            if (args.isNotEmpty()) {
                log = String.format(msg!!, *args)
            }
            System.err.println(log)
        }

        fun sleep(millisecond: Long) {
            try {
                Thread.sleep(millisecond)
            } catch (e: InterruptedException) {
                logError("sleep fail with error $e")
            }
        }
    }
}// Created by chenqiuwen on 2023/11/4.
//

/*
 * Tencent is pleased to support the open source community by making
 * WCDB available.
 *
 * Copyright (C) 2017 THL A29 Limited, a Tencent company.
 * All rights reserved.
 *
 * Licensed under the BSD 3-Clause License (the "License"); you may not use
 * this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 *       https://opensource.org/licenses/BSD-3-Clause
 *
 * 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 com.tencent.wcdbtest.orm.testclass

import com.tencent.wcdb.FTSModule
import com.tencent.wcdb.FTSVersion
import com.tencent.wcdb.WCDBField
import com.tencent.wcdb.WCDBT


 (isCancelled) null else current
    }

    /**
     * 当前插件是否监听了数据包事件
     */
    private fun isPacketEventListened(): Boolean {
        return InternalEventBus.isListening(PacketReceiveEvent::class.java)
                || InternalEventBus.isListening(PacketReceiveEvent.Handshake::class.java)
                || InternalEventBus.isListening(PacketSendEvent::class.java)
                || InternalEventBus.isListening(PacketSendEvent.Handshake::class.java)
    }

    /**
     * 立刻向服务端注入数据包监听器
     * 并且更新 OpenContainer 缓存
     */
    private fun injectPacketListener() {
        instance = LightInjectorImpl(BukkitPlugin.getInstance())
        Exchanges[PACKET_LISTENER] = pluginId
        Exchanges["$PACKET_LISTENER/plugin/$pluginId"] = null
        updateContainer()
        debug("LightInjector 初始化完成。")
    }

    /**
     * 初始化 LightInjector
     */
    @Awake(LifeCycle.ENABLE)
    private fun onEnable() {
        if (TabooLib.isStopped()) {
            return
        }
        // 所有 TabooLib 6.2 只注入一个数据包监听器
        // 借助 Exchanges 和 OpenAPI 减少资源损耗
        if (Exchanges.contains(PACKET_LISTENER)) {
            // 是否监听了数据包相关事件
            // 只有在 Exchanges 中标记本插件，才会收到共享的数据包事件
            if (isPacketEventListened()) {
                Exchanges["$PACKET_LISTENER/plugin/$pluginId"] = true
                debug("LightInjector 已在其他插件中初始化。")
            }
        } else {
            injectPacketListener()
        }
    }

    /**
     * 卸载 LightInjector，需要其他插件立刻顶替
     */
    @Awake(LifeCycle.DISABLE)
    private fun onDisable() {
        if (TabooLib.isStopped() || !isBukkitServerRunning) {
            return
        }
        if (instance != null) {
            // 注销数据包监听器
            instance?.close()
            // 通知其他插件立刻接管
            val next = containers.firstOrNull { it.name != pluginId }
            if (next != null) {
                try {
                    if (next.call(PACKET_LISTENER_EJECT, arrayOf()).isSuccessful) {
                        debug("LightInjector closed, current packet listener is taken over by ${next.name}.")
                    }
                } catch (ex: IllegalStateException) {
                    if (ex.message != "zip file closed") ex.printStackTrace()
                }
            }
        }
    }

    @Awake(LifeCycle.ACTIVE)
    private fun onActive() {
        if (instance != null) {
            updateContainer()
        }
    }

    @SubscribeEvent
    private fun onEnabled(e: PluginEnableEvent) {
        if (instance != null) {
            updateContainer()
        }
    }

    @SubscribeEvent
    private fun onDisable(e: PluginDisableEvent) {
        if (instance != null) {
            updateContainer()
        }
    }

    override fun call(name: String, data: Array<Any?>): OpenResult {
        when (name) {
            // 数据包接收
            PACKET_RECEIVE -> {
                val player = data[0] as? Player
                val channel = data[1] as Channel
                val packet = data[2] as Any
                if (player != null) {
                    val event = PacketReceiveEvent(player, PacketImpl(packet))
                    return if (event.callIf()) OpenResult.successful(event.packet.source) else OpenResult.failed()


son “otopsi” sahnesi. Otopsiyi yapan kişi cesedin canlı canlı toprağa gömülerek öldürülmüş olabileceğini söylemesi karşısında Doktor’un bir süre şaşkınlık geçirerek ama daha sonra kararlı bir biçimde öyle olmadığını söylediği ve kayıtlara da öyle geçirttiği sahne. Tam o sırada cesetten bir kanının Doktor’un yüzüne sıçraması ve kameranın uzun süre bu “lekeli” yüz üzerinde durması sanki bu konuda bugüne dair bir şeyler söyler gibiydi.

Dedim ya bu benim “seyretmem”. Nuri Bilge Ceylan ve arkadaşları böyle düşünmemiş olsalar bile yaptıkları işten ben böyle etkilendim. Filmlerini seyrederken Anadolu’da geçen fakat aynı zamanda tarihin herhangi bir döneminde herhangi bir yerinde de geçebilecek olan bir olayın acısının sesini duydum.

Hâlâ içimizi acıtan bir ses olarak...

erolkatircioglu@gmail.com

Kaynak: [taraf.com.tr](http://www.taraf.com.tr/erol-katircioglu/makale-bir-zamanlar-anadolu-da.htm), [web.archive.org (arşiv bağlantısı)](http://web.archive.org/web/20130909065028/http://www.taraf.com.tr/erol-katircioglu/makale-bir-zamanlar-anadolu-da.htm)
# Çılgın proje ve demokrasimiz

*Erol Katırcıoğlu 28.04.2011*

Batı karşısında yenik düşmenin Türkiye toplumunda ciddi bir travmaya yol açtığı bilinir. Bunca yılın koskoca Osmanlı’sının güneşi görünce eriyen kar misali tarih sahnesinden çekilmiş olması bu ülkenin insanlarınca kolay kabul edilen bir olgu olmadı. O nedenle de bu “kaybetmişlik duygusu” zaman zaman bir yerlerimizden çıkar. Bugün hâlâ Avrupa’yla ilişkilerimizin, “Onlar ortak, biz pazar” anlayışıyla algılanıyor olması da bu nedenle.

1991 yılında kurulan Demirel-İnönü hükümetinde ekonomi danışmanlığı yaparken çeşitli vesilelerle bu “duygu”nun farklı tezahürleriyle çokça karşılaştım. Dün Erdoğan’ın “çılgın proje”sini dinlerken de o günler geldi aklıma. Bu da bir başkası diye düşündüm kendi kendime.

Başbakanlık’taki çalışmam sırasında bu projeye benzer çok sayıda “çılgın projesi” olan insanla tanışmış, onları dinlemiş ve bazılarını da ilgili olabilecek kurum


//===-- InferFunctionAttrs.h - Infer implicit function attributes ---------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// Interfaces for passes which infer implicit function attributes from the
/// name and signature of function declarations.
///
//===----------------------------------------------------------------------===//

#ifndef LLVM_TRANSFORMS_IPO_INFERFUNCTIONATTRS_H
#define LLVM_TRANSFORMS_IPO_INFERFUNCTIONATTRS_H

#include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h"

namespace llvm {

/// A pass which infers function attributes from the names and signatures of
/// function declarations in a module.
struct InferFunctionAttrsPass : PassInfoMixin<InferFunctionAttrsPass> {
  PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM);
};

/// Create a legacy pass manager instance of a pass to infer function
/// attributes.
Pass *createInferFunctionAttrsLegacyPass();

}

#endif // LLVM_TRANSFORMS_IPO_INFERFUNCTIONATTRS_H


to_element(&elem_text, "<PASSWORD>")
    ///     .move_to_element_center(&elem_button)
    ///     .click()
    ///     .perform().await?;
    /// #         let elem_result = driver.find_element(By::Id("input-result")).await?;
    /// #         assert_eq!(elem_result.text().await?, "thirtyfour");
    /// #         Ok(())
    /// #     })
    /// # }
    /// ```
    fn action_chain(&self) -> ActionChain {
        ActionChain::new(self.session())
    }

    /// Get all cookies.
    ///
    /// # Example:
    /// ```rust
    /// # use thirtyfour::prelude::*;
    /// # use thirtyfour::support::block_on;
    /// #
    /// # fn main() -> WebDriverResult<()> {
    /// #     block_on(async {
    /// #         let caps = DesiredCapabilities::chrome();
    /// #         let driver = WebDriver::new("http://localhost:4444/wd/hub", &caps).await?;
    /// #         driver.get("http://webappdemo").await?;
    /// #         let set_cookie = Cookie::new("key", serde_json::json!("value"));
    /// #         driver.add_cookie(set_cookie).await?;
    /// let cookies = driver.get_cookies().await?;
    /// for cookie in &cookies {
    ///     println!("Got cookie: {}", cookie.value());
    /// }
    /// #         assert_eq!(
    /// #             cookies.iter().filter(|x| x.value() == &serde_json::json!("value")).count(), 1);
    /// #         Ok(())
    /// #     })
    /// # }
    /// ```
    async fn get_cookies(&self) -> WebDriverResult<Vec<Cookie>> {
        let v = self.cmd(Command::GetAllCookies).await?;
        convert_json_vec::<Cookie>(&v["value"])
    }

    /// Get the specified cookie.
    ///
    /// # Example:
    /// ```rust
    /// # use thirtyfour::prelude::*;
    /// # use thirtyfour::support::block_on;
    /// #
    /// # fn main() -> WebDriverResult<()> {
    /// #     block_on(async {
    /// #         let caps = DesiredCapabilities::chrome();
    /// #         let driver = WebDriver::new("http://localhost:4444/wd/hub", &caps).await?;
    /// #         driver.get("http://webappdemo").await?;
    /// #         let set_cookie = Cookie::new("key", serde_json::json!("value"));
    /// #         driver.add_cookie(set_cookie).await?;
    /// let cookie = driver.get_cookie("key").await?;
    /// println!("Got cookie: {}", cookie.value());
    /// #         assert_eq!(cookie.value(), &serde_json::json!("value"));
    /// #         Ok(())
    /// #     })
    /// # }
    /// ```
    async fn get_cookie(&self, name: &str) -> WebDriverResult<Cookie> {
        let v = self.cmd(Command::GetNamedCookie(name)).await?;
        convert_json::<Cookie>(&v["value"])
    }

    /// Delete the specified cookie.
    ///
    /// # Example:
    /// ```rust
    /// # use thirtyfour::prelude::*;
    /// # use thirtyfour::support::block_on;
    /// #
    /// # fn main() -> WebDriverResult<()> {
    /// #     block_on(async {
    /// #         let caps = DesiredCapabilities::chrome();
    /// #         let driver = WebDriver::new("http://localhost:4444/wd/hub", &caps).await?;
    /// #         driver.get("http://webappdemo").await?;
    /// #         let set_cook


endsOn(NodeHashTable.first::class)
    class type : StaticUniqueMapper.Field() {
        override val predicate = predicateOf<Instruction2> { it.opcode == INVOKEVIRTUAL && it.methodId == method<NodeHashTable.first>().id }
                .nextIn(1) { it.opcode == CHECKCAST && it.typeType == type<InterfaceParent>() }
                .nextWithin(23) { it.opcode == ICONST_3 }
                .prevWithin(10) { it.opcode == GETFIELD && it.fieldType == INT_TYPE && it.fieldOwner == type<InterfaceParent>() }
    }

    @DependsOn(type::class)
    class itf : IdentityMapper.InstanceField() {
        override val predicate = predicateOf<Field2> { it.type == INT_TYPE && it != field<type>() }
    }

    class keep : IdentityMapper.InstanceField() {
        override val predicate = predicateOf<Field2> { it.type == BOOLEAN_TYPE }
    }
}package org.runestar.client.updater.mapper.std.classes

import org.runestar.client.updater.mapper.IdentityMapper
import org.runestar.client.updater.mapper.DependsOn
import org.runestar.client.updater.mapper.and
import org.runestar.client.updater.mapper.predicateOf
import org.runestar.client.updater.mapper.type
import org.runestar.client.updater.mapper.Class2
import org.runestar.client.updater.mapper.Field2

@DependsOn(Node::class, IterableNodeDeque::class)
class IterableNodeDequeDescendingIterator : IdentityMapper.Class() {
    override val predicate = predicateOf<Class2> { it.superType == Any::class.type }
            .and { it.interfaces.contains(Iterator::class.type) }
            .and { it.instanceFields.count { it.type == type<Node>() } == 2 }
            .and { it.instanceFields.count { it.type == type<IterableNodeDeque>() } == 1 }
            .and { it.instanceFields.size == 3 }

    @DependsOn(IterableNodeDeque::class)
    class deque : IdentityMapper.InstanceField() {
        override val predicate = predicateOf<Field2> { it.type == type<IterableNodeDeque>() }
    }

    // current

    // last
}package org.runestar.client.updater.mapper.std.classes

import org.runestar.client.updater.mapper.IdentityMapper
import org.runestar.client.updater.mapper.StaticUniqueMapper
import org.runestar.client.updater.mapper.DependsOn
import org.runestar.client.updater.mapper.and
import org.runestar.client.updater.mapper.predicateOf
import org.runestar.client.updater.mapper.type
import org.runestar.client.updater.mapper.nextWithin
import org.runestar.client.updater.mapper.Class2
import org.runestar.client.updater.mapper.Instruction2
import org.objectweb.asm.Opcodes.*
import org.objectweb.asm.Type.*

class MiniMenuEntry : IdentityMapper.Class() {
    override val predicate = predicateOf<Class2> { it.superType == Any::class.type }
            .and { it.interfaces.isEmpty() }
            .and { it.instanceMethods.isEmpty() }
            .and { it.instanceFields.count { it.type == String::class.type } == 1 }
            .and { it.instanceFields.count { it.type == INT_TYPE } == 4 }
            .and { it.instanceFields.size == 5 }

    @DependsOn(Client.menuArguments1::class)
    class argument1 : StaticUniqueMapper.Field() {
        override val predicate = predicateOf<Instruction2> { it.opcode == NEW && it.typeT


      melp->buf_size = buffer_size;
      melp->remaining_bits = 8;
      melp->tmp = 0;
      melp->run = 0;
      melp->k = 0;
      melp->threshold = 1; // this is 1 << mel_exp[melp->k];
    }

    //////////////////////////////////////////////////////////////////////////
    static inline void
    mel_emit_bit(mel_struct* melp, int v)
    {
      assert(v == 0 || v == 1);
      melp->tmp = (melp->tmp << 1) + v;
      melp->remaining_bits--;
      if (melp->remaining_bits == 0)
      {
        if (melp->pos >= melp->buf_size)
          grk::grklog.error( "mel encoder's buffer is full");

        melp->buf[melp->pos++] = (ui8)melp->tmp;
        melp->remaining_bits = (melp->tmp == 0xFF ? 7 : 8);
        melp->tmp = 0;
      }
    }

    //////////////////////////////////////////////////////////////////////////
    static inline void
    mel_encode(mel_struct* melp, bool bit)
    {
      //MEL exponent
      static const int mel_exp[13] = {0,0,0,1,1,1,2,2,2,3,3,4,5};

      if (bit == false)
      {
        ++melp->run;
        if (melp->run >= melp->threshold)
        {
          mel_emit_bit(melp, 1);
          melp->run = 0;
          melp->k = ojph_min(12, melp->k + 1);
          melp->threshold = 1 << mel_exp[melp->k];
        }
      }
      else
      {
        mel_emit_bit(melp, 0);
        int t = mel_exp[melp->k];
        while (t > 0)
          mel_emit_bit(melp, (melp->run >> --t) & 1);
        melp->run = 0;
        melp->k = ojph_max(0, melp->k - 1);
        melp->threshold = 1 << mel_exp[melp->k];
      }
    }

    /////////////////////////////////////////////////////////////////////////
    //
    /////////////////////////////////////////////////////////////////////////
    struct vlc_struct {
      //storage
      ui8* buf;      //pointer to data buffer
      ui32 pos;      //position of next writing within buf
      ui32 buf_size; //size of buffer, which we must not exceed

      int used_bits; //number of occupied bits in tmp
      int tmp;       //temporary storage of coded bits
      bool last_greater_than_8F; //true if last byte us greater than 0x8F
    };

    //////////////////////////////////////////////////////////////////////////
    static inline void
    vlc_init(vlc_struct* vlcp, ui32 buffer_size, ui8* data)
    {
      vlcp->buf = data + buffer_size - 1; //points to last byte
      vlcp->pos = 1;                      //locations will be all -pos
      vlcp->buf_size = buffer_size;

      vlcp->buf[0] = 0xFF;
      vlcp->used_bits = 4;
      vlcp->tmp = 0xF;
      vlcp->last_greater_than_8F = true;
    }

    //////////////////////////////////////////////////////////////////////////
    static inline void
    vlc_encode(vlc_struct* vlcp, int cwd, int cwd_len)
    {
      while (cwd_len > 0)
      {
        if (vlcp->pos >= vlcp->buf_size)
          grk::grklog.error( "vlc encoder's buffer is full");

        int avail_bits = 8 - vlcp->last_greater_than_8F - vlcp->used_bits;
        int t = ojph_min(avail_bits, cwd_len);
        vlcp->tmp |= (cwd & ((1 << t) - 1)) << vlcp->used_bits;
        vlcp->


8035CA24 00358684  80 7F 00 20 */	lwz r3, 0x20(r31)
/* 8035CA28 00358688  4B F9 A3 51 */	bl SOHtoNl
/* 8035CA2C 0035868C  38 E0 00 FE */	li r7, 0xfe
/* 8035CA30 00358690  38 C0 00 FD */	li r6, 0xfd
/* 8035CA34 00358694  38 00 00 00 */	li r0, 0
/* 8035CA38 00358698  3B A1 00 18 */	addi r29, r1, 0x18
/* 8035CA3C 0035869C  90 61 00 08 */	stw r3, 8(r1)
/* 8035CA40 003586A0  7F A3 EB 78 */	mr r3, r29
/* 8035CA44 003586A4  38 9F 00 1C */	addi r4, r31, 0x1c
/* 8035CA48 003586A8  38 A0 00 04 */	li r5, 4
/* 8035CA4C 003586AC  98 E1 00 18 */	stb r7, 0x18(r1)
/* 8035CA50 003586B0  38 63 00 03 */	addi r3, r3, 3
/* 8035CA54 003586B4  98 C1 00 19 */	stb r6, 0x19(r1)
/* 8035CA58 003586B8  98 01 00 1A */	stb r0, 0x1a(r1)
/* 8035CA5C 003586BC  4B CA 75 A5 */	bl memcpy
/* 8035CA60 003586C0  80 01 00 08 */	lwz r0, 8(r1)
/* 8035CA64 003586C4  38 C0 00 07 */	li r6, 7
/* 8035CA68 003586C8  2C 00 00 00 */	cmpwi r0, 0
/* 8035CA6C 003586CC  41 82 00 1C */	beq lbl_8035CA88
/* 8035CA70 003586D0  7F A3 EB 78 */	mr r3, r29
/* 8035CA74 003586D4  38 81 00 08 */	addi r4, r1, 8
/* 8035CA78 003586D8  38 A0 00 04 */	li r5, 4
/* 8035CA7C 003586DC  38 63 00 07 */	addi r3, r3, 7
/* 8035CA80 003586E0  4B CA 75 81 */	bl memcpy
/* 8035CA84 003586E4  38 C0 00 0B */	li r6, 0xb
lbl_8035CA88:
/* 8035CA88 003586E8  88 1F 00 14 */	lbz r0, 0x14(r31)
/* 8035CA8C 003586EC  54 00 07 7B */	rlwinm. r0, r0, 0, 0x1d, 0x1d
/* 8035CA90 003586F0  41 82 00 60 */	beq lbl_8035CAF0
/* 8035CA94 003586F4  80 1E 00 40 */	lwz r0, 0x40(r30)
/* 8035CA98 003586F8  38 61 00 18 */	addi r3, r1, 0x18
/* 8035CA9C 003586FC  38 A0 00 00 */	li r5, 0
/* 8035CAA0 00358700  7C 03 31 AE */	stbx r0, r3, r6
/* 8035CAA4 00358704  38 C6 00 01 */	addi r6, r6, 1
/* 8035CAA8 00358708  7C 63 32 14 */	add r3, r3, r6
/* 8035CAAC 0035870C  48 00 00 1C */	b lbl_8035CAC8
lbl_8035CAB0:
/* 8035CAB0 00358710  7C 9E 2A 14 */	add r4, r30, r5
/


0s.39-1.02 0-1.41L5.12 3.56a.996.996 0 0 0-1.41 0"}),"MicOffRounded"),_y1=h(c.jsx("path",{d:"M15 10.6V5c0-1.66-1.34-3-3-3-1.54 0-2.79 1.16-2.96 2.65zm4 .4h-1.7c0 .58-.1 1.13-.27 1.64l1.27 1.27c.44-.88.7-1.87.7-2.91M4.41 2.86 3 4.27l6 6V11c0 1.66 1.34 3 3 3 .23 0 .44-.03.65-.08l1.66 1.66c-.71.33-1.5.52-2.31.52-2.76 0-5.3-2.1-5.3-5.1H5c0 3.41 2.72 6.23 6 6.72V21h2v-3.28c.91-.13 1.77-.45 2.55-.9l4.2 4.2 1.41-1.41z"}),"MicOffSharp"),Xy1=h([c.jsx("path",{d:"M12 3.7c-.66 0-1.2.54-1.2 1.2v1.51l2.39 2.39.01-3.9c0-.66-.54-1.2-1.2-1.2",opacity:".3"},"0"),c.jsx("path",{d:"M19 11h-1.7c0 .58-.1 1.13-.27 1.64l1.27 1.27c.44-.88.7-1.87.7-2.91M4.41 2.86 3 4.27l6 6V11c0 1.66 1.34 3 3 3 .23 0 .44-.03.65-.08l1.66 1.66c-.71.33-1.5.52-2.31.52-2.76 0-5.3-2.1-5.3-5.1H5c0 3.41 2.72 6.23 6 6.72V21h2v-3.28c.91-.13 1.77-.45 2.55-.9l4.2 4.2 1.41-1.41zM10.8 4.9c0-.66.54-1.2 1.2-1.2s1.2.54 1.2 1.2l-.01 3.91L15 10.6V5c0-1.66-1.34-3-3-3-1.54 0-2.79 1.16-2.96 2.65l1.76 1.76z"},"1")],"MicOffTwoTone"),$y1=h([c.jsx("path",{d:"M12 14c1.66 0 3-1.34 3-3V5c0-1.66-1.34-3-3-3S9 3.34 9 5v6c0 1.66 1.34 3 3 3"},"0"),c.jsx("path",{d:"M17 11c0 2.76-2.24 5-5 5s-5-2.24-5-5H5c0 3.53 2.61 6.43 6 6.92V21h2v-3.08c3.39-.49 6-3.39 6-6.92z"},"1")],"MicOutlined"),cg1=h(c.jsx("path",{d:"M12 14c1.66 0 3-1.34 3-3V5c0-1.66-1.34-3-3-3S9 3.34 9 5v6c0 1.66 1.34 3 3 3m5.91-3c-.49 0-.9.36-.98.85C16.52 14.2 14.47 16 12 16s-4.52-1.8-4.93-4.15c-.08-.49-.49-.85-.98-.85-.61 0-1.09.54-1 1.14.49 3 2.89 5.35 5.91 5.78V20c0 .55.45 1


tY].rank < subsets[rootX].rank) {
			subsets[rootY].parent = rootX;
		}
		else if (subsets[rootX].rank
				< subsets[rootY].rank) {
			subsets[rootX].parent = rootY;
		}
		else {
			subsets[rootY].parent = rootX;
			subsets[rootX].rank++;
		}
	}

	// Function to find parent of a set
	private static int findRoot(Subset[] subsets, int i)
	{
		if (subsets[i].parent == i)
			return subsets[i].parent;

		subsets[i].parent
			= findRoot(subsets, subsets[i].parent);
		return subsets[i].parent;
	}
}

/* Output
Following are the edges in the constructed MST
2 -- 3 == 4
0 -- 3 == 5
0 -- 1 == 10
Minimum Cost Spanning Tree: 19
*/

class Solution {
public:
    // i: arr[i] we are currently looking at
	// mask: Bitmask that represents all the characters that have been added to the current string
	// If 0-th bit in mask is set, it means that we have added "a" in the current string
    int solve(vector<string> &arr, int i, int mask) {
        int n = arr.size();

        if (i >= n)
            return 0;

        // Skip concatenating arr[i]
        int curRes = solve(arr, i+1, mask)

		// Mask to keep track of the characters that are present in arr[i]
		int curMask = 0;

        // Check whether any character in arr[i] is present in current string, i.e.
		// Check whether (arr[i]-'a')-th bit is set in mask
        // If any existing character's bit is set, it means that we cannot concatenate arr[i]
        // to the given string and so return curRes only which contains the result of skipping arr[i]
        // Also, use curMask to maintain the characters in arr[i] that have been seen.
		// It is possible that arr[i] itself has duplicate characters in which case, we will not be able to concatenate arr[i]
        // So check whether (c-'a')-th bit is set in curMask and after that set the (c-'a')-th bit in curMask
        for (char &c: arr[i]) {
            if (mask & (1 << (c - 'a')))
                return curRes;

            if (curMask & (1 << (c - 'a')))
                return curRes;

            curMask |= (1 << (c - 'a'));
        }

        // All the bits that were set in curMask will be now set in mask,
		// in order to add all characters of arr[i] to the current string
        mask |= curMask;

        // We make a call to i+1 with the updated mask and arr[i]'s length being added
        curRes = max(curRes, (int) arr[i].length() + solve(arr, i+1, mask));
        return curRes;
    }

    int maxLength(vector<string>& arr) {
        return solve(arr, 0, 0);
    }
};
/**
 * Find the number of occurrences of bob in string A consisting of lowercase English alphabets.
 *
 *
 *
 * Problem Constraints
 * 1 <= |A| <= 1000
 *
 *
 * Input Format
 * The first and only argument contains the string A, consisting of lowercase English alphabets.
 *
 *
 * Output Format
 * Return an integer containing the answer.
 *
 *
 * Example Input
 * Input 1:
 *
 *   "abobc"
 * Input 2:
 *
 *   "bobob"
 *
 *
 * Example Output
 * Output 1:
 *
 *   1
 * Output 2:
 *
 *   2
 *
 *
 * Example Explanation
 * Explanation 1:
 *
 *   The only occurrence


self, level=None, edge_crease=None, vertex_crease=None, boundary_smooth='ALL', uv_smooth='PRESERVE_BOUNDARIES', node_label=None, node_color=None, **kwargs):
    node = self.tree.SubdivisionSurface(mesh=self, level=level, edge_crease=edge_crease, vertex_crease=vertex_crease, boundary_smooth=boundary_smooth, uv_smooth=uv_smooth, node_label=node_label, node_color=node_color, **kwargs)
    self.jump(node.mesh)
    return self
```
### switch

- node : [Switch](/docs/GeoNodes/Switch.md)
- self : false
- jump : No
- return : output

##### Arguments

- switch : None
- true : None
- node_label : None
- node_color : None

#### Source code

``` python
def switch(self, switch=None, true=None, node_label=None, node_color=None, **kwargs):
    node = self.tree.Switch(switch=switch, false=self, true=true, input_type='GEOMETRY', node_label=node_label, node_color=node_color, **kwargs)
    return node.output
```
### transform_geometry

- node : [TransformGeometry](/docs/GeoNodes/TransformGeometry.md)
- self : geometry
- jump : geometry
- return : self

##### Arguments

- translation : None
- rotation : None
- scale : None
- node_label : None
- node_color : None

#### Source code

``` python
def transform_geometry(self, translation=None, rotation=None, scale=None, node_label=None, node_color=None, **kwargs):
    node = self.tree.TransformGeometry(geometry=self, translation=translation, rotation=rotation, scale=scale, node_label=node_label, node_color=node_color, **kwargs)
    self.jump(node.geometry)
    return self
```
### translate_instances

- node : [TranslateInstances](/docs/GeoNodes/TranslateInstances.md)
- self : instances
- jump : instances
- return : self

##### Arguments

- translation : None
- local_space : None
- selection : None
- node_label : None
- node_color : None

#### Source code

``` python
def translate_instances(self, translation=None, local_space=None, selection=None, node_label=None, node_color=None, **kwargs):
    node = self.tree.TranslateInstances(instances=self, translation=translation, local_space=local_space, selection=self._get_selection(selection), node_label=node_label, node_color=node_color, **kwargs)
    self.jump(node.instances)
    return self
```
### triangulate

- node : [Triangulate](/docs/GeoNodes/Triangulate.md)
- self : mesh
- jump : mesh
- return : self

##### Arguments

- minimum_vertices : None
- selection : None
- ngon_method : 'BEAUTY' in ('BEAUTY', 'CLIP')
- quad_method : 'SHORTEST_DIAGONAL' in ('BEAUTY', 'FIXED', 'FIXED_ALTERNATE', 'SHORTEST_DIAGONAL', 'LONGEST_DIAGONAL')
- node_label : None
- node_color : None

#### Source code

``` python
def triangulate(self, minimum_vertices=None, selection=None, ngon_method='BEAUTY', quad_method='SHORTEST_DIAGONAL', node_label=None, node_color=None, **kwargs):
    node = self.tree.Triangulate(mesh=self, minimum_vertices=minimum_vertices, selection=self._get_selection(selection), ngon_method=ngon_method, quad_method=q


/**
 *
 * \section COPYRIGHT
 *
 * Copyright 2013-2015 Software Radio Systems Limited
 *
 * \section LICENSE
 *
 * This file is part of the srsUE library.
 *
 * srsUE is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of
 * the License, or (at your option) any later version.
 *
 * srsUE 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 Affero General Public License for more details.
 *
 * A copy of the GNU Affero General Public License can be found in
 * the LICENSE file in the top-level directory of this distribution
 * and at http://www.gnu.org/licenses/.
 *
 */

#ifndef MACPCAP_H
#define MACPCAP_H

#include <stdint.h>
#include "srslte/common/pcap.h"

namespace srslte {

class mac_pcap
{
public:
  mac_pcap() {enable_write=false; ue_id=0; pcap_file = NULL; };
  void enable(bool en);
  void open(const char *filename, uint32_t ue_id = 0);
  void close();

  void set_ue_id(uint16_t ue_id);

  void write_ul_crnti(uint8_t *pdu, uint32_t pdu_len_bytes, uint16_t crnti, uint32_t reTX, uint32_t tti);
  void write_dl_crnti(uint8_t *pdu, uint32_t pdu_len_bytes, uint16_t crnti, bool crc_ok, uint32_t tti);
  void write_dl_ranti(uint8_t *pdu, uint32_t pdu_len_bytes, uint16_t ranti, bool crc_ok, uint32_t tti);

  // SI and BCH only for DL
  void write_dl_sirnti(uint8_t *pdu, uint32_t pdu_len_bytes, bool crc_ok, uint32_t tti);
  void write_dl_bch(uint8_t *pdu, uint32_t pdu_len_bytes, bool crc_ok, uint32_t tti);
  void write_dl_pch(uint8_t *pdu, uint32_t pdu_len_bytes, bool crc_ok, uint32_t tti);

private:
  bool enable_write;
  FILE *pcap_file;
  uint32_t ue_id;
  void pack_and_write(uint8_t* pdu, uint32_t pdu_len_bytes, uint32_t reTX, bool crc_ok, uint32_t tti,
                              uint16_t crnti_, uint8_t direction, uint8_t rnti_type);
};

} // namespace srsue

#endif // MACPCAP_H


PATCH_MAX();

    NT_ASSERT(FlagOn(Data->Flags, FLTFL_CALLBACK_DATA_POST_OPERATION));
    NT_ASSERT(Data->Iopb->MajorFunction == IRP_MJ_CLOSE);
    DBG_UNREFERENCED_PARAMETER(Data);

    cacheEntry = NULL;
    previosIrql = ExAcquireSpinLockExclusive(&KphpFileNameCacheLock);

    for (PLIST_ENTRY entry = KphpFileNameCacheList.Flink;
         entry != &KphpFileNameCacheList;
         entry = entry->Flink)
    {
        cacheEntry = CONTAINING_RECORD(entry,
                                       KPH_FLT_FILE_NAME_CACHE_ENTRY,
                                       ListEntry);

        if (cacheEntry->FileObject == FltObjects->FileObject)
        {
            RemoveEntryList(&cacheEntry->ListEntry);
            break;
        }

        cacheEntry = NULL;
    }

    ExReleaseSpinLockExclusive(&KphpFileNameCacheLock, previosIrql);

    if (cacheEntry)
    {
        KphDereferenceObject(cacheEntry);
    }
}

/**
 * \brief Allocates a cached file name object.
 *
 * \param[in] Size The size of the object to allocate.
 *
 * \return The allocated object, or NULL on failure.
 */
_Function_class_(KPH_TYPE_ALLOCATE_PROCEDURE)
_IRQL_requires_max_(APC_LEVEL)
_Return_allocatesMem_size_(Size)
PVOID KSIAPI KphpFltAllocateCachedFileName(
    _In_ SIZE_T Size
    )
{
    KPH_NPAGED_CODE_APC_MAX_FOR_PAGING_IO();

    return KphAllocateNPaged(Size, KPH_TAG_FLT_CACHED_FILE_NAME);
}

/**
 * \brief Frees a cached file name object.
 *
 * \param[in] Object The object to free.
 */
_Function_class_(KPH_TYPE_ALLOCATE_PROCEDURE)
_IRQL_requires_max_(APC_LEVEL)
VOID KSIAPI KphpFltFreeCachedFileName(
    _In_freesMem_ PVOID Object
    )
{
    KPH_NPAGED_CODE_APC_MAX_FOR_PAGING_IO();

    KphFree(Object, KPH_TAG_FLT_CACHED_FILE_NAME);
}

KPH_PAGED_FILE();

/**
 * \brief Cleans up the file name cache.
 *
 * \details A global name cache is used in limited cases to cache the file name
 * for a given file object. This must be called after the filter stops
 * filtering.
 */
_IRQL_requires_max_(PASSIVE_LEVEL)
VOID KphpFltCleanupFileNameCache(
    VOID
    )
{
    KPH_PAGED_CODE_PASSIVE();

    if (!KphpFileNameCacheInitialized)
    {
        return;
    }

    while (!IsListEmpty(&KphpFileNameCacheList))
    {
        PKPH_FLT_FILE_NAME_CACHE_ENTRY cacheEntry;

        cacheEntry = CONTAINING_RECORD(RemoveHeadList(&KphpFileNameCacheList),
                                       KPH_FLT_FILE_NAME_CACHE_ENTRY,
                                       ListEntry);

        KphDereferenceObject(cacheEntry);
    }
}

/**
 * \brief Initializes the file name cache.
 *
 * \details A global name cache is used in limited cases to cache the file name
 * for a given file object. This must be called before the filter is begins
 * filtering.
 */
_IRQL_requires_max_(PASSIVE_LEVEL)
VOID KphpFltInitializeFileNameCache(
    VOID
    )
{
    KPH_OBJECT_TYPE_INFO typeInfo;

    KPH_PAGED_CODE_PASSIVE();

    InitializeListHead(&KphpFileNameCacheList);

    typeInfo.Allocate = KphpFltAllocateCachedFileName;
    typeInfo.Initialize = NULL;
    typeInfo.Delete = NULL;
    typeInfo.Free = KphpFltFreeCachedFileName;
    typeInfo.Flags = 0;

    KphCreateObjectType(&KphpCachedFileNameTypeName,
                        &typeInfo,
                        &KphpCachedFileNameType);

    KphpFileNameCacheInitialized = TRUE;
}


local radical  = require("radical")
local tag_menu = require( "radical.impl.common.tag" )

local capi = {client = client,mouse=mouse}

local module = {}

local centered = nil

module.centered_menu = function(layouts,backward)
    local screen = capi.client.focus and capi.client.focus.screen or capi.mouse.screen
    if not centered then

        centered = radical.box {
            filter      = false,
            item_style  = radical.item.style.rounded,
            item_height = 45,
            column      = 6,
            layout      = radical.layout.grid,
            screen      = screen
        }

        tag_menu.layouts(centered,layouts)
        centered:ad


000176C 3C048001 */  lui   $a0, %hi(D_80011C34) # $a0, 0x8001
/* 002370 80001770 24841C34 */  addiu $a0, %lo(D_80011C34) # addiu $a0, $a0, 0x1c34
/* 002374 80001774 0C000B84 */  jal   LogUtils_LogThreadId
/* 002378 80001778 240503B8 */   li    $a1, 952
/* 00237C 8000177C 3C048001 */  lui   $a0, %hi(D_80011C44) # $a0, 0x8001
/* 002380 80001780 24841C44 */  addiu $a0, %lo(D_80011C44) # addiu $a0, $a0, 0x1c44
/* 002384 80001784 0C00084C */  jal   osSyncPrintf
/* 002388 80001788 24050020 */   li    $a1, 32
/* 00238C 8000178C 3C048001 */  lui   $a0, %hi(D_80011C84) # $a0, 0x8001
/* 002390 80001790 0C00084C */  jal   osSyncPrintf
/* 002394 80001794 24841C84 */   addiu $a0, %lo(D_80011C84) # addiu $a0, $a0, 0x1c84
.L80001798:
/* 002398 80001798 3C078001 */  lui   $a3, %hi(sDmaMgrMsgQueue)
/* 00239C 8000179C 24E43990 */  addiu $a0, $a3, %lo(sDmaMgrMsgQueue)
/* 0023A0 800017A0 02002825 */  move  $a1, $s0
/* 0023A4 800017A4 0C000C18 */  jal   osSendMesg
/* 0023A8 800017A8 24060001 */   li    $a2, 1
/* 0023AC 800017AC 8FBF001C */  lw    $ra, 0x1c($sp)
/* 0023B0 800017B0 8FB00018 */  lw    $s0, 0x18($sp)
/* 0023B4 800017B4 27BD0020 */  addiu $sp, $sp, 0x20
/* 0023B8 800017B8 03E00008 */  jr    $ra
/* 0023BC 800017BC 00001025 */   move  $v0, $zero


lt<(), P::Error> {
        self.0.accept(c, v)?;
        self.1.accept(c, v)?;
        self.2.accept(c, v)
    }
}

impl<P: Params, T1, T2, T3, T4> Node<P> for (T1, T2, T3, T4)
where
    T1: Node<P>,
    T2: Node<P>,
    T3: Node<P>,
    T4: Node<P>,
{
    fn recurse<'node>(
        &'node self,
        c: &mut P::Context,
        v: &mut dyn Visitor<'node, P = P>,
    ) -> Result<(), P::Error> {
        self.0.accept(c, v)?;
        self.1.accept(c, v)?;
        self.2.accept(c, v)?;
        self.3.accept(c, v)
    }
}

impl<P: Params, T1, T2> NodeMut<P> for (T1, T2)
where
    T1: NodeMut<P>,
    T2: NodeMut<P>,
{
    fn recurse<'node>(
        &'node mut self,
        c: &mut P::Context,
        v: &mut dyn VisitorMut<'node, P = P>,
    ) -> Result<(), P::Error> {
        self.0.accept(c, v)?;
        self.1.accept(c, v)
    }
}

impl<P: Params, T1, T2, T3> NodeMut<P> for (T1, T2, T3)
where
    T1: NodeMut<P>,
    T2: NodeMut<P>,
    T3: NodeMut<P>,
{
    fn recurse<'node>(
        &'node mut self,
        c: &mut P::Context,
        v: &mut dyn VisitorMut<'node, P = P>,
    ) -> Result<(), P::Error> {
        self.0.accept(c, v)?;
        self.1.accept(c, v)?;
        self.2.accept(c, v)
    }
}

impl<P: Params, T1, T2, T3, T4> NodeMut<P> for (T1, T2, T3, T4)
where
    T1: NodeMut<P>,
    T2: NodeMut<P>,
    T3: NodeMut<P>,
    T4: NodeMut<P>,
{
    fn recurse<'node>(
        &'node mut self,
        c: &mut P::Context,
        v: &mut dyn VisitorMut<'node, P = P>,
    ) -> Result<(), P::Error> {
        self.0.accept(c, v)?;
        self.1.accept(c, v)?;
        self.2.accept(c, v)?;
        self.3.accept(c, v)
    }
}

impl<P: Params> Node<P> for crate::LocalIdMap<P::Ex> {
    fn recurse<'node>(
        &'node self,
        c: &mut P::Context,
        v: &mut dyn Visitor<'node, P = P>,
    ) -> Result<(), P::Error> {
        Ok(for (key, value) in self.0.iter() {
            key.accept(c, v)?;
            v.visit_ex(c, value)?;
        })
    }
}

/// `NodeMut` implementation doesn't visit keys,
/// mutating key requires re-constructing the underlaying map.
/// There will be extra perf cost even keys are not mutated.
/// Overriding its parent visit method can mutate keys economically.
impl<P: Params> NodeMut<P> for crate::LocalIdMap<P::Ex> {
    fn recurse<'node>(
        &'node mut self,
        c: &mut P::Context,
        v: &mut


tate != null) room.RoomState = body.RoomState.Value;

        if (body.Slots.Count > 1)
        {
            dataContext.Logger.LogWarning(BunkumCategory.Matching, "Received create room request with multiple slots, rejecting");
            return BadRequest;
        }

        foreach(List<int> slot in body.Slots)
        {
            if (slot.Count != 2)
            {
                dataContext.Logger.LogWarning(BunkumCategory.Matching, "Received request with invalid slot, rejecting.");
                return BadRequest;
            }

            room.LevelType = (RoomSlotType)slot[0];
            room.LevelId = slot[1];
        }

        byte? mood = body.HostMood ?? body.Mood;
        if (mood != null)
        {
            room.RoomMood = (RoomMood)mood;
        }

        dataContext.Match.RoomAccessor.UpdateRoom(room);

        return OK;
    }
}


tępny w DOS.

Odzyskiwanie do woluminu FAT, pole "Podziel dużych plików"

Woluminy FAT nie obsługuje plików większych niż 4 GB (lub czasem 2 GB).
Większe pliki mogą być podzielony podczas odzyskiwania na żądanie,
jeśli OS prawidłowo informuje (które nie zawsze tak jest),
lub opcja Podziel dużych plików jest używany (zalecane).
Później można połączyć części plików na inny dysk za pomocą narzędzia systemowe
copy / b part1 + part2 part3 + wynik, na przykład.
Czysta DOS obsługuje tylko woluminy FAT.

Długie i krajowych nazw plików w systemie DOS, pole "Zastępuj nazwy"

Bez specjalnych sterowników długich nazw plików nie są obsługiwane w systemie DOS.
Opcja Zastępuj nazwy umożliwia zastąpienie nazwy w okresie odzyskiwania.
Plik LRENAME.BAT jest tworzony w folderze docelowym dla wstecznej zmiany nazwy.
Aby przywrócić oryginalne nazwy załadować pliku system operacyjny Windows, przejdź do folderu docelowego
i uruchomić pliku LRENAME.BAT.
Odpowiednie kodowej strony OEM musi być wybrany
podczas pracy w DOS, aby przywrócić symbole narodowe poprawnie.
Unicode symboli poza wybraną kodowej stronę będzie transliteracji lub podstawiony.

Możesz dodać parametr substnamesutf8=1
lub użyć opcji utf-8 aby utworzyć LRENAME.BAT w formacie utf-8,
który obsługuje wszystkie symbole Unicode niezależnie wybrana strona kodowa.
Format utf-8 jest obsługiwany w systemie Windows 7 i wyższych.

Ścieżki dłuższe niż 259 znaków (Windows NT i wyżej)

Opcja Wsparcie dla bardzo długich ścieżek
(lub ręczna zmiana prefiksu \\?\ przy określaniu katalogu docelowego,
np.: \\?\D:\)
pozwala odzyskać ścieżki dłuższe niż 259 znaków.
Takie długie ścieżki mogą być niedostępne przy użyciu standardowych środków systemu operacyjnego,
takich jak Explorer ("Mój komputer").

Zduplikowane nazwy, błędy w plikach i obsługa innych zdar


{
							int indexOf = m_Params[i].IndexOf( '=' );

							if ( indexOf >= 0 )
								hintNumber = Utility.ToInt32( m_Params[i].Substring( ++indexOf ) );
						}
						else if ( m_Params[i].StartsWith( "ResetDelay" ) )
						{
							int indexOf = m_Params[i].IndexOf( '=' );

							if ( indexOf >= 0 )
								resetDelay = TimeSpan.Parse( m_Params[i].Substring( ++indexOf ) );
						}
					}

					HintItem hi = new HintItem( m_ItemID, range, messageNumber, hintNumber );

					hi.WarningString = messageString;
					hi.HintString = hintString;
					hi.ResetDelay = resetDelay;

					item = hi;
				}
				else if ( m_Type == typeofWarningItem )
				{
					int range = 0;
					int messageNumber = 0;
					string messageString = null;
					TimeSpan resetDelay = TimeSpan.Zero;

					for ( int i = 0; i < m_Params.Length; ++i )
					{
						if ( m_Params[i].StartsWith( "Range" ) )
						{
							int indexOf = m_Params[i].IndexOf( '=' );

							if ( indexOf >= 0 )
								range = Utility.ToInt32( m_Params[i].Substring( ++indexOf ) );
						}
						else if ( m_Params[i].StartsWith( "WarningString" ) )
						{
							int indexOf = m_Params[i].IndexOf( '=' );

							if ( indexOf >= 0 )
								messageString = m_Params[i].Substring( ++indexOf );
						}
						else if ( m_Params[i].StartsWith( "WarningNumber" ) )
						{
							int indexOf = m_Params[i].IndexOf( '=' );

							if ( indexOf >= 0 )
								messageNumber = Utility.ToInt32( m_Params[i].Substring( ++indexOf ) );
						}
						else if ( m_Params[i].StartsWith( "ResetDelay" ) )
						{
							int indexOf = m_Params[i].IndexOf( '=' );

							if ( indexOf >= 0 )
								resetDelay = TimeSpan.Parse( m_Params[i].Substring( ++indexOf ) );
						}
					}

					WarningItem wi = new WarningItem( m_ItemID, range, messageNumber );

					wi.WarningString = messageString;
					wi.ResetDelay = resetDelay;

					item = wi;
				}
				else if ( m_Type == typeofCannon )
				{
					CannonDirection direction = CannonDirection.North;

					for ( int i = 0; i < m_Params.Length; ++i )
					{
						if ( m_Params[i].StartsWith( "CannonDirection" ) )
						{
							int indexOf = m_Params[i].IndexOf( '=' );

							if ( indexOf >= 0 )
								direction = (CannonDirection)Enum.Parse( typeof( CannonDirection ), m_Params[i].Substring( ++indexOf ), true );
						}
					}

					item = new Cannon( direction );
				}
				else if ( m_Type == typeofSerpentPillar )
				{
					string word = null;
					Rectangle2D destination = new Rectangle2D();

					for ( int i = 0; i < m_Params.Length; ++i )
					{
						if ( m_Params[i].StartsWith( "Word" ) )
						{
							int indexOf = m_Params[i].IndexOf( '=' );

							if ( indexOf >= 0 )
								word = m_Params[i].Substring( ++indexOf );
						}
						else if ( m_Params[i].StartsWith( "DestStart" ) )
						{
							int indexOf = m_Params[i].IndexOf( '=' );

							if ( indexOf >= 0 )
								dest


r0, 0x68(r3)
/* 8042EAF0 0042BA30  90 03 00 6C */	stw r0, 0x6c(r3)
/* 8042EAF4 0042BA34  D0 23 00 54 */	stfs f1, 0x54(r3)
/* 8042EAF8 0042BA38  D0 23 00 50 */	stfs f1, 0x50(r3)
/* 8042EAFC 0042BA3C  D0 23 00 4C */	stfs f1, 0x4c(r3)
/* 8042EB00 0042BA40  D0 03 00 60 */	stfs f0, 0x60(r3)
/* 8042EB04 0042BA44  4E 80 00 20 */	blr
.endfn reset__Q34Game5P2JST11ObjectActorFv

.fn update__Q34Game5P2JST11ObjectActorFv, global
/* 8042EB08 0042BA48  94 21 FE E0 */	stwu r1, -0x120(r1)
/* 8042EB0C 0042BA4C  7C 08 02 A6 */	mflr r0
/* 8042EB10 0042BA50  90 01 01 24 */	stw r0, 0x124(r1)
/* 8042EB14 0042BA54  DB E1 01 10 */	stfd f31, 0x110(r1)
/* 8042EB18 0042BA58  F3 E1 01 18 */	psq_st f31, 280(r1), 0, qr0
/* 8042EB1C 0042BA5C  DB C1 01 00 */	stfd f30, 0x100(r1)
/* 8042EB20 0042BA60  F3 C1 01 08 */	psq_st f30, 264(r1), 0, qr0
/* 8042EB24 0042BA64  93 E1 00 FC */	stw r31, 0xfc(r1)
/* 8042EB28 0042BA68  93 C1 00 F8 */	stw r30, 0xf8(r1)
/* 8042EB2C 0042BA6C  7C 7F 1B 78 */	mr r31, r3
/* 8042EB30 0042BA70  80 83 00 58 */	lwz r4, 0x58(r3)
/* 8042EB34 0042BA74  80 03 00 68 */	lwz r0, 0x68(r3)
/* 8042EB38 0042BA78  7C 04 00 40 */	cmplw r4, r0
/* 8042EB3C 0042BA7C  41 82 00 14 */	beq .L_8042EB50
/* 8042EB40 0042BA80  81 83 00 00 */	lwz r12, 0(r3)
/* 8042EB44 0042BA84  81 8C 00 BC */	lwz r12, 0xbc(r12)
/* 8042EB48 0042BA88  7D 89 03 A6 */	mtctr r12
/* 8042EB4C 0042BA8C  4E 80 04 21 */	bctrl
.L_8042EB50:
/* 8042EB50 0042BA90  80 7F 00 5C */	lwz r3, 0x5c(r31)
/* 8042EB54 0042BA94  80 1F 00 6C */	lwz r0, 0x6c(r31)
/* 8042EB58 0042BA98  7C 03 00 40 */	cmplw r3, r0
/* 8042EB5C 0042BA9C  41 82 00 18 */	beq .L_8042EB74
/* 8042EB60 0042BAA0  7F E3 FB 78 */	mr r3, r31
/* 8042EB64 0042BAA4  81 9F 00 00 */	lwz r12, 0(r31)
/* 8042EB68 0042BAA8  81 8C 00 C0 */	lwz r12, 0xc0(r12)
/* 8042EB6C 0042BAAC  7D 89 03 A6 */


  // entry found -> j = offset
  __ add(j, array, i, ext::uxtx, 3);
  __ ldrw(j, Address(j, BytesPerInt));
  __ profile_switch_case(i, key, array);
  __ rev32(j, j);
  __ load_unsigned_byte(rscratch1, Address(rbcp, j, Address::sxtw(0)));
  __ lea(rbcp, Address(rbcp, j, Address::sxtw(0)));
  __ dispatch_only(vtos);

  // default case -> j = default offset
  __ bind(default_case);
  __ profile_switch_default(i);
  __ ldrw(j, Address(array, -2 * BytesPerInt));
  __ rev32(j, j);
  __ load_unsigned_byte(rscratch1, Address(rbcp, j, Address::sxtw(0)));
  __ lea(rbcp, Address(rbcp, j, Address::sxtw(0)));
  __ dispatch_only(vtos);
}

void TemplateTable::_return(TosState state)
{
  transition(state, state);
  assert(_desc->calls_vm(),
         "inconsistent calls_vm information"); // call in remove_activation

  if (_desc->bytecode() == Bytecodes::_return_register_finalizer) {
    assert(state == vtos, "only valid state");

    __ ldr(c_rarg1, aaddress(0));
    __ load_klass(r3, c_rarg1);
    __ ldrw(r3, Address(r3, Klass::access_flags_offset()));
    __ tst(r3, JVM_ACC_HAS_FINALIZER);
    Label skip_register_finalizer;
    __ br(Assembler::EQ, skip_register_finalizer);

    __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::register_finalizer), c_rarg1);

    __ bind(skip_register_finalizer);
  }

  // Issue a StoreStore barrier after all stores but before return
  // from any constructor for any class with a final field.  We don't
  // know if this is a finalizer, so we always do so.
  if (_desc->bytecode() == Bytecodes::_return)
    __ membar(MacroAssembler::StoreStore);

  // Narrow result if state is itos but result type is smaller.
  // Need to narrow in the return bytecode rather than in generate_return_entry
  // since compiled code callers expect the result to already be narrowed.
  if (state == itos) {
    __ narrow(r0);
  }

  __ remove_activation(state);
  __ ret(lr);
}

// ----------------------------------------------------------------------------
// Volatile variables demand their effects be made known to all CPU's
// in order.  Store buffers on most chips allow reads & writes to
// reorder; the JMM's ReadAfterWrite.java test fails in -Xint mode
// without some kind of memory barrier (i.e., it's not sufficient that
// the interpreter does not reorder volatile references, the hardware
// also must not reorder them).
//
// According to the new Java Memory Model (JMM):
// (1) All volatiles are serialized wrt to each other.  ALSO reads &
//     writes act as aquire & release, so:
// (2) A read cannot let unrelated NON-volatile memory refs that
//     happen after the read float up to before the read.  It's OK for
//     non-volatile memory refs that happen before the volatile read to
//     float down below it.
// (3) Similar a volatile write cannot let unrelated NON-volatile
//     memory refs that happen BEFORE the write float down to after the
//     write.  It's OK for non-volatile memory refs that happen after the
//     volatile write to float up before it.
//
// We only put in barriers around volatile refs (they are expensive),
// not _between_ memory refs (that would require us to track the
// flavor of the previous memory refs).  Requirements (2) and (3)
// require some barriers before volatile stores and after volatile
// loads.  These nearly cover requirement (1) but miss the
// volatile-store-volatile-load case.  This final case is placed after
// volatile-stores although it could just as well go before
// volatile-load


Apng
import com.t8rin.imagetoolbox.core.resources.icons.Exif
import com.t8rin.imagetoolbox.core.resources.icons.ImageText
import com.t8rin.imagetoolbox.core.resources.icons.Jpg
import com.t8rin.imagetoolbox.core.resources.icons.Jxl
import com.t8rin.imagetoolbox.core.resources.icons.Webp
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable

@Serializable
@Stable
@Immutable
sealed class Screen(
    open val id: Int,
    @StringRes val title: Int,
    @StringRes val subtitle: Int
) {

    val isBetaFeature: Boolean by lazy { isBetaFeature() }

    val simpleName: String by lazy { simpleName() }

    val icon: ImageVector? by lazy { icon() }

    val twoToneIcon: ImageVector? by lazy { twoToneIcon() }

    @Serializable
    data class LibraryDetails(
        val name: String,
        val htmlDescription: String
    ) : Screen(
        id = -5,
        title = 0,
        subtitle = 0
    )

    @Serializable
    data object LibrariesInfo : Screen(
        id = -4,
        title = 0,
        subtitle = 0
    )

    @Serializable
    data class Settings(
        val searchQuery: String = ""
    ) : Screen(
        id = -3,
        title = 0,
        subtitle = 0
    )

    @Serializable
    data object EasterEgg : Screen(
        id = -2,
        title = 0,
        subtitle = 0
    )

    @Serializable
    data object Main : Screen(
        id = -1,
        title = 0,
        subtitle = 0
    )

    @Serializable
    data class SingleEdit(
        val uri: Uri? = null
    ) : Screen(
        id = 0,
        title = R.string.single_edit,
        subtitle = R.string.single_edit_sub
    )

    @Serializable
    data class ResizeAndConvert(
        val uris: List<Uri>? = null
    ) : Screen(
        id = 1,
        title = R.string.resize_and_convert,
        subtitle = R.string.resize_and_convert_sub
    )

    @Serializable
    data class WeightResize(
        val uris: List<Uri>? = null
    ) : Screen(
        id = 2,
        title = R.string.by_bytes_resize,
        subtitle = R.string.by_bytes_resize_sub
    )

    @Serializable
    data class Crop(
        val uri: Uri? = null
    ) : Screen(
        id = 3,
        title = R.string.crop,
        subtitle = R.string.crop_sub
    )

    @Serializable
    data class Filter(
        @SerialName("dataType") val type: Type? = null
    ) : Screen(
        id = 4,
        title = R.string.filter,
        subtitle = R.string.filter_sub
    ) {
        @Serializable
        sealed class Type(
            @StringRes val title: Int,
            @StringRes val subtitle: Int
        ) {

            val icon: ImageVector
                get() = when (this) {
                    is Masking -> Icons.Rounded.Texture
                    is Basic -> Icons.Outlined.AutoFixHigh
                }

            @Serializable
            data class Masking(
                val uri: Uri? = null
            ) : Type(
                title = R.string.mask_filter,
                subtitle = R.string.mask_filter_sub
            )

            @Serializable
            data class Basic(
                val uris: List<Uri>? = null
            ) : Type(
                title = R.string.full_filter,
                subtitle = R.string.full_filter_sub
            )

            companion object {
                val entries by lazy {
                    listOf(


ze, num_layers, output_size, bias, f)
	-- size = dimensionality of inputs
	-- num_layers = number of hidden layers (default = 1)
	-- bias = bias for transform gate (default = -2)
	-- f = non-linearity (default = ReLU)

	local num_layers = num_layers or 1
	local input_size = input_size
	local output_size = output_size or input_size
	local bias = bias or -2
	local f = f or nn.ReLU()
	local start = nn.Identity()()
	local transform_gate, carry_gate, input, output
	for i = 1, num_layers do
		if i > 1 then
			input_size = output_size
		else
			input = start
		end
		output = f(nn.Linear(input_size, output_size)(input))
		transform_gate = nn.Sigmoid()(nn.AddConstant(bias, true)(
					nn.Linear(input_size, output_size)(input)))
		carry_gate = nn.AddConstant(1, true)(nn.MulConstant(-1)(transform_gate))
		local proj
		if input_size==output_size then
			proj = nn.Identity()
		else
			proj = nn.LinearNoBias(input_size, output_size)
		end
		input = nn.CAddTable()({nn.CMulTable()({transform_gate, output}),
							 nn.CMulTable()({carry_gate, proj(input)})})
	end
	return nn.gModule({start},{input})
end


h-48v-32.46C311.83 429.82 262.06 448 208 448s-103.83-18.18-144-48.46V480c0 17.67 14.33 32 32 32h224c17.67 0 32-14.33 32-32h48c42.2 0 77.48-29.87 85.98-69.56 15.39-8 26.02-23.9 26.02-42.44 0-26.51-21.49-48-48-48z"],
    "bell-school-slash": [640, 512, [], "f5d6", "M272 448c-54.06 0-103.83-18.18-144-48.46V480c0 17.67 14.33 32 32 32h224c17.67 0 32-14.33 32-32v-28.47l-37.66-29.11C346.23 438.51 310.29 448 272 448zm78.19-47.33L65.95 180.99C64.8 189.85 64 198.82 64 208c0 114.88 93.12 208 208 208 27.68 0 54.04-5.52 78.19-15.33zm283.63 57.43l-72.26-55.85C570.45 393.54 576 381.43 576 368c0-26.51-21.49-48-48-48-17.82 0-33.2 9.83-41.48 24.25l-36.81-28.45C468.88 284.38 480 247.52 480 208 480 93.12 386.87 0 272 0c-58.54 0-111.06 24.5-148.8 63.45L45.47 3.37C38.49-2.05 28.43-.8 23.01 6.18L3.37 31.45C-2.05 38.42-.8 48.47 6.18 53.9l588.35 454.73c6.98 5.43 17.03 4.17 22.46-2.81l19.64-25.27c5.42-6.97 4.17-17.02-2.81-22.45zM346.64 236.15l-27.35-21.14c.34-2.31.71-4.61.71-7.01 0-26.51-21.49-48-48-48-6.7 0-13.07 1.39-18.87 3.87l-27-20.87c12.98-9.29 28.68-15 45.87-15 44.11 0 80 35.89 80 80 0 9.95-2.02 19.37-5.36 28.15z"],
    "bell-slash": [640, 512, [], "f1f6", "M633.82 458.1l-90.62-70.05c.19-1.38.8-2.66.8-4.06.05-7.55-2.61-15.27-8.61-21.71-19.32-20.76-55.47-51.99-55.47-154.29 0-77.7-54.48-139.9-127.94-155.16V32c0-17.67-14.32-32-31.98-32s-31.98 14.33-31.98 32v20.84c-40.33 8.38-74.66 31.07-97.59 62.57L45.47 3.37C38.49-2.05 28.43-.8 23.01 6.18L3.37 31.45C-2.05 38.42-.8 48.47 6.18 53.9l588.35 454.73c6.98 5.43 17.03 4.17 22.46-2.81l19.64-25.27c5.42-6.97 4.17-17.02-2.81-22.45zM157.23 251.54c-8.61 67.96-36.41 93.33-52.62 110.75-6 6.45-8.66 14.16-8.61 21.71.11 16.4 12.98 32 32.1 32h24


o check for dupes
  async addWord(value: string, groupId: number): Promise<void> {
    let dao = this.dao;
    dao.getDictionary().then(async (dictionary: Array<DictionaryEntry>) => {
      let isDupe: boolean =
        dictionary.filter(function (entry) {
          return entry.value === value;
        }).length > 0;
      if (!isDupe) {
        await dao.addEntry(value, '', false, groupId);
        WHLogger.log(
          'Word ' +
            value +
            ' has been added to the dictionary through the context menu'
        );
      }
    });
  }
}
import { should, use } from 'chai'
import { Assignment, Catch, Class, Closure, Constructor, Describe, Field, Fixture, If, Import, Literal, Method, Mixin, NamedArgument, New, Package, Parameter, Program, Reference, Return, Send, Singleton, Super, Test, Throw, Try, Variable } from '../src/builders'
import * as parse from '../src/parser'
import { parserAssertions } from './assertions'

const { raw } = String

use(parserAssertions)
should()

describe('Wollok parser', () => {

  describe('Comments', () => {
    const parser = parse.importEntity

    it('multiline comments should be ignored in between tokens', () => {
      `/*some comment*/import /* some
      comment */ p`.should.be.parsedBy(parser).into(
        Import(Reference('p'))
      ).and.be.tracedTo(16, 49)
        .and.have.nested.property('entity').tracedTo(48, 49)
    })

    it('line comments should be ignored at the end of line', () => {
      `import //some comment
      p`.should.be.parsedBy(parser).into(
        Import(Reference('p'))
      ).and.be.tracedTo(0, 29)
        .and.have.nested.property('entity').tracedTo(28, 29)
    })

    it('should not parse elements inside line comment', () => {
      '// import p'.should.not.be.parsedBy(parser)
    })

    it('should not parse elements inside multiline comment', () => {
      `/*
        import p
      */`.should.not.be.parsedBy(parser)
    })

    it('should not parse elements with an unclosed multiline comment', () => {
      'import p /* non closed comment'.should.not.be.parsedBy(parser)
    })

  })

  describe('Names', () => {

    const parser = parse.name

    it('should parse names that begin with _', () => {
      '_foo123'.should.be.be.parsedBy(parser).into(
        '_foo123'
      )
    })

    it('should not parse names with spaces', () => {
      'foo bar'.should.not.be.parsedBy(parser)
    })

    it('should not parse names that begin with numbers', () => {
      '4foo'.should.not.be.parsedBy(parser)
    })

    it('should not parse operators as names', () => {
      '=='.should.not.be.parsedBy(parser)
    })

  })

  describe('Literals', () => {
    const parser = parse.literal

    describe('Booleans', () => {

      it('should parse "true"', () => {
        'true'.should.be.parsedBy(parser).into(Literal(true)).and.be.tracedTo(0, 4)
      })

      it('should parse "false"', () => {
        'false'.should.be.parsedBy(parser).into(Literal(false)).and.be.tracedTo(0, 5)
      })

    })

    describe('Null', () => {

      it('should parse "null"', () => {
        'null'.should.be.parsedBy(parser).into(Literal(null)
        ).and.be.tracedTo(0, 4)
      })

    })

    describe('Numbers',


   d->pb_close = new IconButton(this);
    d->pb_close->setText(tr("&Close"));
    connect(d->pb_close, SIGNAL(clicked()), SLOT(close()));
    d->pb_close->setMinimumWidth(80);
    hb4->addWidget(d->pb_close);

    hb4->addStretch(1);

    d->pb_next = new IconButton(this);
    connect(d->pb_next, SIGNAL(clicked()), SLOT(doReadNext()));
    d->pb_next->setText(tr("&Next"));
    d->pb_next->hide();
    d->pb_next->setMinimumWidth(96);
    d->pb_next->setEnabled(false);
    hb4->addWidget(d->pb_next);

    d->pb_quote = new IconButton(this);
    d->pb_quote->setText(tr("&Quote"));
    connect(d->pb_quote, SIGNAL(clicked()), SLOT(doQuote()));
    d->pb_quote->hide();
    d->pb_quote->setMinimumWidth(96);
    hb4->addWidget(d->pb_quote);

    d->ck_all_auth = new QCheckBox(tr("For all"), this);
    d->ck_all_auth->hide();
    hb4->addWidget(d->ck_all_auth);

    d->pb_deny = new IconButton(this);
    d->pb_deny->setText(tr("&Deny"));
    connect(d->pb_deny, SIGNAL(clicked()), SLOT(doDeny()));
    d->pb_deny->hide();
    d->pb_deny->setMinimumWidth(96);
    hb4->addWidget(d->pb_deny);

    d->pb_auth = new IconButton(this);
    d->pb_auth->setText(tr("&Add/Auth"));
    connect(d->pb_auth, SIGNAL(clicked()), SLOT(doAuth()));
    d->pb_auth->setPsiIcon(IconsetFactory::iconPtr("psi/addContact"));
    d->pb_auth->hide();
    d->pb_auth->setMinimumWidth(96);
    hb4->addWidget(d->pb_auth);

    d->pb_send = new IconButton(this);
    d->pb_send->setText(tr("&Send"));
    connect(d->pb_send, SIGNAL(clicked()), SLOT(doSend()));
    d->pb_send->hide();
    d->pb_send->setMinimumWidth(96);
    hb4->addWidget(d->pb_send);

    d->pb_chat = new IconButton(this);
    d->pb_chat->setText(tr("&Chat"));
    connect(d->pb_chat, SIGNAL(clicked()), SLOT(doChat()));
    d->pb_chat->hide();
    d->pb_chat->setMinimumWidth(96);
    hb4->addWidget(d->pb_chat);

    d->pb_reply = new IconButton(this);
    d->pb_reply->setText(tr("&Reply"));
    connect(d->pb_reply, SIGNAL(clicked()), SLOT(doReply()));
    d->pb_reply->hide();
    d->pb_reply->setMinimumWidth(96);
    hb4->addWidget(d->pb_reply);

    d->pb_http_confirm = new IconButton(this);
    d->pb_http_confirm->setText(tr("C&onfirm"));
    connect(d->pb_http_confirm, SIGNAL(clicked()), SLOT(doHttpConfirm()));
    d->pb_http_confirm->hide();
    d->pb_http_confirm->setMinimumWidth(96);
    hb4->addWidget(d->pb_http_confirm);

    d->pb_http_deny = new IconButton(this);
    d->pb_http_deny->setText(tr("&Deny"));
    connect(d->pb_http_deny, SIGNAL(clicked()), SLOT(doHttpDeny()));
    d->pb_http_deny->hide();
    d->pb_http_deny->setMinimumWidth(96);
    hb4->addWidget(d->pb_


�页
│   │   ├── profile/              # 个人资料
│   │   ├── chat/                 # 聊天页面
│   │   ├── call/                 # 通话页面
│   │   └── settings/             # 设置页面
│   ├── widgets/                  # 组件
│   │   ├── common/               # 通用组件
│   │   ├── chat/                 # 聊天组件
│   │   ├── call/                 # 通话组件
│   │   └── gift/                 # 礼物组件
│   ├── utils/                    # 工具类
│   │   ├── constants.dart
│   │   ├── helpers.dart
│   │   └── validators.dart
│   └── constants/                # 常量
│       ├── colors.dart
│       ├── strings.dart
│       └── assets.dart
├── assets/                       # 静态资源
│   ├── images/
│   ├── icons/
│   ├── animations/
│   ├── sounds/
│   └── fonts/
├── android/                      # Android配置
├── ios/                          # iOS配置
└── web/                          # Web配置
```

### 核心功能模块

#### 1. 认证模块
- 手机号注册/登录
- 微信/QQ第三方登录
- JWT Token管理
- 生物识别认证

#### 2. 用户模块
- 个人资料管理
- 头像上传/裁剪
- 实名认证
- 用户搜索/推荐

#### 3. 视频通话模块
- WebRTC连接管理
- 音视频设备控制
- 通话质量监控
- 网络切换处理

#### 4. 聊天模块
- 实时消息收发
- 消息类型支持（文本、图片、语音、视频）
- 表情包系统
- 消息状态管理

#### 5. 礼物系统
- 礼物展示
- 礼物动画
- 礼物购买
- 收益统计

## 🔧 后端架构 (Django + FastAPI)

### 技术栈
- **主框架**: Django 4.2 + Django REST Framework
- **实时通信**: FastAPI + WebSocket
- **数据库**: PostgreSQL 15
- **缓存**: Redis 7
- **消息队列**: Celery + Redis
- **文件存储**: AWS S3 + CloudFront
- **监控**: Sentry + Prometheus + Grafana

### 服务架构
```
┌─────────────────────────────────────────────────────────────┐
│                    API Gateway Layer                        │
├─────────────────────────────────────────────────────────────┤
│  Django API (REST)  │  FastAPI (WebSocket)  │  FastAPI (WebRTC) │
├─────────────────────────────────────────────────────────────┤
│                    Business Logic Layer                     │
├─────────────────────────────────────────────────────────────┤
│  User Service  │  Room Service  │  Call Service  │  Gift Service │
├─────────────────────────────────────────────────────────────┤
│                    Data Access Layer


|1, NOFLIP|2, NOFLIP|3, NOFLIP|4, NOFLIP|5
	.byte NOFLIP|6, H_FLIP|5, H_FLIP|4, H_FLIP|3, H_FLIP|2, H_FLIP|1
	.byte H_FLIP|0, HVFLIP|1, HVFLIP|2, HVFLIP|3, HVFLIP|4, HVFLIP|5
	.byte V_FLIP|6, V_FLIP|5, V_FLIP|4, V_FLIP|3, V_FLIP|2, V_FLIP|1
	.undef NOFLIP
	.undef H_FLIP
	.undef V_FLIP
	.undef HVFLIP

drawcube_sprite_none:
	; Bits 6-7: FLIP
	; Bits 0-2: actual idx
	.define NOFLIP $00
	.define H_FLIP $40
	.define V_FLIP $80
	.define HVFLIP $C0
	.byte NOFLIP|0, NOFLIP|1, NOFLIP|2, NOFLIP|3, NOFLIP|4, NOFLIP|5
	.byte NOFLIP|6, NOFLIP|1, NOFLIP|2, NOFLIP|3, NOFLIP|4, NOFLIP|5
	.byte NOFLIP|6, NOFLIP|1, NOFLIP|2, NOFLIP|3, NOFLIP|4, NOFLIP|5
	.byte NOFLIP|6, NOFLIP|1, NOFLIP|2, NOFLIP|3, NOFLIP|4, NOFLIP|5
	.undef NOFLIP
	.undef H_FLIP
	.undef V_FLIP
	.undef HVFLIP

drawplayer_center_offsets:
	;		Cub	Shp Bal	UFO	RBT	SPI	Wav
	.byte	8,	8,	8,	8,	4,	4,	8,	8,	8; normal size
	.byte	4,	4,	4,	4,	4,	4,	4,	4,	4; mini

; void drawplayerone();
.segment _PLAYER_RENDER_BANK

.export _drawplayerone
.proc _drawplayerone

    LDX _cube_data
    LDA _slope_frames+0
    ORA _slope_type+0
    BEQ :+
        TXA
        ORA #%10000000
        BNE @skipClearBit
    :
        TXA
        AND #%01111111
    @skipClearBit:
    sta _cube_data

	LDA _player_gravity+0
	BEQ :+
		LDA #$80
	: STA xargs+0

	LDX _player_y+1		;
	DEX					;	The Y of oam_meta_spr is high_byte(player_y[0])-1
	STX sreg+1			;__

	; Set up base pointer for jump tables
	LDA _player_mini;
	BEQ :+          ;   Add 8 if mini mode
		LDA #gamemode_count
	:               ;__
	CLC             ;   Actual gamemode itself
	ADC _gamemode   ;__
	PHA
	LDX _retro_mode
	BEQ :+
		ADC #gamemode_count*2	; ain't no way the last one overflowed
	:
	TAX
	LDA sprite_table_table_lo, X
	STA ptr1		;__	Get low byte of table ptr
	LDA sprite_table_table_hi, X
	STA ptr1+1		;__ Get high byte of table ptr
	PLA				;	Get pure gamemode number
	TAX				;__

	LDY _player_x+1     ;__ temp_x = high_byte(player_x[0]);
	; The condition if is temp_x == 0 or is > 0xfc,
	; this can be expressed as (temp_x - 1) > 0xfb
	DEY					;
	CPY #$FC            ;
	BCC :+              ;	if(temp_x-1 > 0xfb) temp_x = 1;


te a virtual Roblox tree
local habitat = lemur.Habitat.new()

-- We'll put all of our library code and dependencies here
local ReplicatedStorage = habitat.game:GetService("ReplicatedStorage")

-- Load all of the modules specified above
for _, module in ipairs(LOAD_MODULES) do
	local container = habitat:loadFromFs(module[1])
	container.Name = module[2]
	container.Parent = ReplicatedStorage
end

-- When Lemur implements a proper scheduling interface, we'll use that instead.
local runTests = habitat:loadFromFs("test/runner.server.lua")
habitat:require(runTests)


}

            Console.ReadLine();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Tests tests = new Tests();
            tests.GeoCodeTest();


.getByToken(stereoRecHitsToken_, rechitsstereo);

  //Variables in order to count total num of rechitrphi,rechitstereo, rechitmatched in subdetectors
  std::map<std::string, int> totnumrechitrphi;
  std::map<std::string, int> totnumrechitstereo;
  std::map<std::string, int> totnumrechitmatched;
  int totrechitrphi = 0;
  int totrechitstereo = 0;
  int totrechitmatched = 0;

  TrackerHitAssociator associate(e, trackerHitAssociatorConfig_);

  const TrackerGeometry& tracker = es.getData(m_geomToken);

  SiStripHistoId hidmanager;
  SiStripFolderOrganizer fold_organ;
  for (auto const& theDetSet : *rechitsrphi) {
    DetId detid = theDetSet.detId();
    uint32_t myid = detid.rawId();
    totrechitrphi += theDetSet.size();

    std::string label = hidmanager.getSubdetid(myid, tTopo, true);
    std::map<std::string, LayerMEs>::iterator iLayerME = LayerMEsMap.find(label);
    std::pair<std::string, int32_t> det_lay_pair = fold_organ.GetSubDetAndLayer(myid, tTopo, true);

    totnumrechitrphi[det_lay_pair.first] = totnumrechitrphi[det_lay_pair.first] + theDetSet.size();
    //loop over rechits-rphi in the same subdetector
    if (iLayerME != LayerMEsMap.end()) {
      for (auto const& rechit : theDetSet) {
        const GeomDetUnit* det = tracker.idToDetUnit(detid);
        const StripTopology& topol = static_cast<const StripGeomDetUnit*>(det)->specificTopology();
        //analyze RecHits
        rechitanalysis(rechit, topol, associate);
        // fill the result in a histogram
        fillME(iLayerME->second.meWclusrphi, rechitpro.clusiz);
        fillME(iLayerME->second.meAdcrphi, rechitpro.cluchg);
        fillME(iLayerME->second.mePosxrphi, rechitpro.x);
        fillME(iLayerME->second.meResolxrphi, rechitpro.resolxx);
        fillME(iLayerME->second.meNsimHitrphi, rechitpro.NsimHit);
        if (rechitpro.NsimHit > 0) {
          std::map<std::string, SubDetMEs>::iterator iSubDetME = SubDetMEsMap.find(det_lay_pair.first);
          fillME(iSubDetME->second.meBunchrphi, rechitpro.bunch);
          if (rechitpro.bunch == 0)
            fillME(iSubDetME->second.meEventrphi, rechitpro.event);
        }
        if (rechitpro.resx != -999999. || rechitpro.pullMF != -999999. || rechitpro.chi2 != -999999.) {
          fillME(iLayerME->second.meResrphi, rechitpro.resx);
          fillME(iLayerME->second.mePullLFrphi, rechitpro.resx / sqrt(rechitpro.resolxx));
          fillME(iLayerME->second.mePullMFrphi, rechitpro.pullMF);
          fillME(iLayerME->second.meChi2rphi, rechitpro.chi2);
        }
      }
    }
  }

  // start loops over detectors with detected rechitsstereo
  for (auto const& theDetSet : *rechitsstereo) {
    DetId detid = theDetSet.detId();
    uint32_t myid = detid.rawId();
    totrech


   detail_df['upper'] = (detail_df['mean detail'] + detail_df['std detail']).rolling(window=window_size, center=True).mean()
    detail_df['lower'] = (detail_df['mean detail'] - detail_df['std detail']).rolling(window=window_size, center=True).mean()
    detail_df_list[d_idx] = detail_df

for d_idx, detail_df in enumerate(detail_df_huge_car_list):
    detail_df = detail_df.head(min_detail_df_len).copy()
    detail_df['mean detail'] = detail_df['mean detail'].rolling(window=window_size, center=True).mean()
    detail_df = detail_df.dropna()

    detail_df['upper'] = (detail_df['mean detail'] + detail_df['std detail']).rolling(window=window_size, center=True).mean()
    detail_df['lower'] = (detail_df['mean detail'] - detail_df['std detail']).rolling(window=window_size, center=True).mean()
    detail_df_huge_car_list[d_idx] = detail_df

final_detail_df = pd.concat(detail_df_list)
final_detail_huge_car_df = pd.concat(detail_df_huge_car_list)

final_detail_df.to_csv('ppo_v4_reload_count.csv')
final_detail_huge_car_df.to_csv('ppo_v4_reload_count_huge_car.csv')

plot = (ggplot()
        + geom_line(final_detail_df, aes(x='episode', y='mean detail', color='algorithm', fill='algorithm'))
        + labs(x='Episode', y='#Relocation')
        + geom_ribbon(final_detail_df, aes(x='episode', ymin='lower', ymax='upper', fill='algorithm'), alpha=0.2)
        # + scale_fill_manual(values=npg)
        # + scale_color_manual(values=npg)
        + theme_prism()
        + theme(legend_position=(.8,.2))
        )

plot_huge_car = (ggplot()
                + geom_line(final_detail_huge_car_df, aes(x='episode', y='mean detail', color='algorithm', fill='algorithm'))
                + labs(x='Episode', y='#Crane movement distance')
                + geom_ribbon(final_detail_huge_car_df,
                            aes(x='episode', ymin='lower', ymax='upper', fill='algorithm'), alpha=0.2)
                + theme_prism()
                + theme(legend_position=(.8,.2))
                )
plot.save('../figures/rl/ppo_v4_reload_count.pdf')
plot_huge_car.save('../figures/rl/ppo_v4_crane_movement_distance.pdf')


using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Volo.Abp.EntityFrameworkCore;
using Volo.Abp.EntityFrameworkCore.DependencyInjection;
using Volo.Abp.EntityFrameworkCore.SqlServer;
using Volo.Abp.Modularity;

namespace FormsApp
{
    [DependsOn(
        typeof(FormsDomainModule),
        typeof(AbpEntityFrameworkCoreSqlServerModule)
    )]
    public class FormsEntityFrameworkCoreModule : AbpModule
    {
        public override void ConfigureServices(ServiceConfigurationContext context)
        {
            context.Services.AddAbpDbContext<FormsAppDbContext>(options =>
            {
                options.AddDefaultRepositories();
                options.AddRepository<For


会党组、省委统战部转报省工业厅党组关于陕西省公私合营工业工作总结报告

   日期：1954-9-21 作者：[待确定]

   我们除基本同意你们厅党组小组关于“陕西省公私合营工业工作总结”及1954年上半年对公私合营企业所进行的生产、经营管理等整顿工作的报告外（总结原文个别地方略加修改）兹提出如下意见请省委批示。

   一、对资本家及其代理人和原有职员、技术人员的团结、教育改造问题，是关联着进一步提高生产，节约原料，降低成本，改善经营管理的一个重要环节。过去在这一方面虽已做了不少工作，但还不够。今后应继续加强这方面的工作，以便更好地团结改造资本家及原有职员、技术人员，为进一步改造企业创造有利条件。

   二、根据政务院颁布“公私合营工业企业暂行条例”第21、22条规定精神，对规模小，股东少的合营企业，可以不设立董事会”，其有关公私关系重要事项，由公私双方代表协商处理，并由合营企业报请当地人民政府主管部门批准。

   三、为进一步作好对私营工业的改造和管好公私合营企业，我们同意，在省党校，附设一个30人左右的公私合营干部训练班，以便提高干部的政策思想水平和交流工作经验，请省委考虑确定。此外，你厅应即考虑1955年扩展公私合营工业所需干部名额及来源，以免因干部缺乏而影响工作。

   四、关于30人以上的机器、半机器厂矿配备专职支部书记或党委书记的问题，请省委考虑确定。

   五、鉴于所剩编制机动人数有限，和成立手工业管理局（或处）后，工业厅即可腾出力量加强对地方国营与公私合营企业的领导，因此，目前暂可不成立私营工商管理局。但为了进一步加强对私营工业的社会主义改造和管好公私合营企业，同意给工业厅增编专管私营、公私合营工业的干部20人，以利工作。

    附：


yv1 "github.com/ray-project/kuberay/ray-operator/apis/ray/v1"
)

var _ = Describe("RayCluster validating webhook", func() {
	Context("when name is too long", func() {
		It("should return error", func() {
			longName := "this-name-is-tooooooooooooooooooooooooooooooooooooooooooo-long-and-should-be-invalid"
			rayCluster := rayv1.RayCluster{
				ObjectMeta: metav1.ObjectMeta{
					Namespace: "default",
					Name:      longName,
				},
				Spec: rayv1.RayClusterSpec{
					HeadGroupSpec: rayv1.HeadGroupSpec{
						Template: corev1.PodTemplateSpec{
							Spec: corev1.PodSpec{
								Containers: []corev1.Container{},
							},
						},
					},
					WorkerGroupSpecs: []rayv1.WorkerGroupSpec{},
				},
			}

			err := k8sClient.Create(context.TODO(), &rayCluster)
			Expect(err).To(HaveOccurred())

			Expect(err.Error()).To(ContainSubstring(fmt.Sprintf("RayCluster.ray.io \"%s\" is invalid: metadata.name", longName)))
		})
	})

	Context("when name isn't a DNS1035 label", func() {
		It("should return error", func() {
			rayCluster := rayv1.RayCluster{
				ObjectMeta: metav1.ObjectMeta{
					Namespace: "default",
					Name:      "invalid.name",
				},
				Spec: rayv1.RayClusterSpec{
					HeadGroupSpec: rayv1.HeadGroupSpec{
						Template: corev1.PodTemplateSpec{
							Spec: corev1.PodSpec{
								Containers: []corev1.Container{},
							},
						},
					},
					WorkerGroupSpecs: []rayv1.WorkerGroupSpec{},
				},
			}

			err := k8sClient.Create(context.TODO(), &rayCluster)
			Expect(err).To(HaveOccurred())

			Expect(err.Error()).To(ContainSubstring("RayCluster.ray.io \"invalid.name\" is invalid: metadata.name:"))
		})
	})

	Context("when groupNames are not unique", func() {
		var name, namespace string
		var rayCluster rayv1.RayCluster

		BeforeEach(func() {
			namespace = "default"
			name = fmt.Sprintf("test-raycluster-%d", rand.IntnRange(1000, 9000))
		})

		It("should return error", func() {
			rayCluster = rayv1.RayCluster{
				ObjectMeta: metav1.ObjectMeta{
					Name:      name,
					Namespace: namespace,
				},
				Spec: rayv1.RayClusterSpec{
					HeadGroupSpec: rayv1.HeadGroupSpec{
						Template: corev1.PodTemplateSpec{
							Spec: corev1.PodSpec{
								Containers: []corev1.Container{},
							},
						},
					},
					WorkerGroupSpecs: []rayv1.WorkerGroupSpec{
						{
							GroupName: "group1",
							Template: corev1.PodTemplateSpec{
								Spec: corev1.PodSpec{
									Containers: []corev1.Container{},
								},
							},
						},
						{
							GroupName: "group1",
							Template: corev1.PodTemplateSpec{
								Spec: corev1.PodSpec{
									Containers: []corev1.Container{},
								},
							},
						},
					},
				},
			}

			err := k8sClient.Create(context.TODO(), &rayCluster)
			Expect(err).To(HaveOccurred())

			Expect(err.Error()).To(ContainSubstring("worker group names must be unique"))
		})
	})
})
package v1alpha1

import (
	"testing"

	"github.com/go-logr/logr"
	"github.com/go-logr/logr/testr"

	kaischeduler "github.com/ray-project/kuberay/ray-operator/controllers/ray/batchscheduler/kai-scheduler"
	schedulerPlugins "github.com


2Triangles( 4,  8,  7, 0x0,  3,  9,  1, 0x0),
    gsSP2Triangles(10, 11, 12, 0x0, 10, 12, 13, 0x0),
    gsSP2Triangles(11, 14, 12, 0x0, 11, 15, 14, 0x0),
    gsSPVertex(monty_mole_seg5_vertex_05004930, 4, 0),
    gsSP2Triangles( 0,  1,  2, 0x0,  0,  3,  1, 0x0),
    gsSPEndDisplayList(),
};

// 0x05004BE0 - 0x05004C00
const Gfx monty_mole_seg5_dl_05004BE0[] = {
    gsSPVertex(monty_mole_seg5_vertex_05004970, 4, 0),
    gsSP2Triangles( 0,  1,  2, 0x0,  0,  2,  3, 0x0),
    gsSPEndDisplayList(),
};

// 0x05004C00 - 0x05004C90
const Gfx monty_mole_seg5_dl_05004C00[] = {
    gsDPPipeSync(),
    gsDPSetCombineMode(G_CC_MODULATERGB, G_CC_MODULATERGB),
    gsDPSetTile(G_IM_FMT_RGBA, G_IM_SIZ_16b, 0, 0, G_TX_LOADTILE, 0, G_TX_WRAP | G_TX_NOMIRROR, G_TX_NOMASK, G_TX_NOLOD, G_TX_WRAP | G_TX_NOMIRROR, G_TX_NOMASK, G_TX_NOLOD),
    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
    gsDPTileSync(),
    gsDPSetTile(G_IM_FMT_RGBA, G_IM_SIZ_16b, 8, 0, G_TX_RENDERTILE, 0, G_TX_WRAP | G_TX_NOMIRROR, 5, G_TX_NOLOD, G_TX_WRAP | G_TX_NOMIRROR, 5, G_TX_NOLOD),
    gsDPSetTileSize(0, 0, 0, (32 - 1) << G_TEXTURE_IMAGE_FRAC, (32 - 1) << G_TEXTURE_IMAGE_FRAC),
    gsSPDisplayList(monty_mole_seg5_dl_050049B0),
    gsDPTileSync(),
    gsDPSetTile(G_IM_FMT_RGBA, G_IM_SIZ_16b, 8, 0, G_TX_RENDERTILE, 0, G_TX_CLAMP, 5, G_TX_NOLOD, G_TX_CLAMP, 5, G_TX_NOLOD),
    gsDPSetTileSize(0, 0, 0, (32 - 1) << G_TEXTURE_IMAGE_FRAC, (32 - 1) << G_TEXTURE_IMAGE_FRAC),
    gsSPDisplayList(monty_mole_seg5_dl_05004A10),
    gsSPDisplayList(monty_mole_seg5_dl_05004B50),
    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
    gsDPPipeSync(),
    gsDPSetCombineMode(G_CC_SHADE, G_CC_SHADE),
    gsSPDisplayList(monty_mole_seg5_dl_05004BE0),
    gsSPEndDisplayList(),
};

// 0x05004C90
static const Lights1 monty_mole_seg5_lights_05004C90 = gdSPDefLights1(
    0x7f, 0x7f, 0x7f,
    0xff, 0xff, 0xff, 0x28, 0x28, 0x28
);

// 0x05004CA8
static const Vtx monty_mole_seg5_vertex_05004CA8[] = {
    {{{     3,     99,    -25}, 0, {  -154,    -14}, {0xed, 0x7d, 0x00, 0xff}}},
    {{{   -42,     92,    -12}, 0, {   160,    980}, {0xed, 0x7d, 0x00, 0xff}}},
    {{{   -42,     92,     13}, 0, {   800,    978}, {0xed, 0x7d, 0x00, 0xff}}},
    {{{     3,     99,     26}, 0, {  1092,    -18}, {0xed, 0x7d, 0x00, 0xff}}},
};

// 0x05004CE8 - 0x05004D30
const Gfx monty_mole_seg5_dl_05004CE8[] = {
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, monty_mole_seg5_texture_05002170),
    gsDPLoadSync(),
    gsDPLoadBlock(G_TX_LOADTILE, 0, 0, 32 * 32 - 1, CALC_DXT(32, G_IM_SIZ_16b_BYTES)),
    gsSPLight(&monty_mole_seg5_lights_05004C90.l, 1),
    gsSPLight(&monty_mole_seg5_lights_05004C90.a, 2),
    gsSPVertex(monty_mole_seg5_vertex_05004CA8, 4, 0),
    gsSP2Triangles( 0,  1,  2, 0x0,  0,  2,  3, 0x0),
    gsSPEndDisplayList(),
};

// 0x05004D30 - 0x05004DA0
const Gfx monty_mole_seg5_dl_05004D30[] = {
    gsDPPipeSync(),
    gsDPSetCombineMode(G_CC_MODULATERGBA, G_CC_MODULATERGBA),
    gsSPClearGeometryMode(G_CULL_BACK | G_SHADING_SMOOTH),
    gsDPSetTile(G_IM_FMT_RGBA, G_IM_SIZ_16b, 0, 0, G_TX_LOADTILE, 0, G_TX_WRAP | G_TX_NOMIRROR, G_TX_NOMASK, G_TX_NOLOD, G_TX_WRAP | G_TX_NOMIRROR, G_TX_NOMASK, G_TX_NOLOD),
    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
    gsDPTileSync(),
    gsDPSetTile(G_IM_FMT_RGBA, G_IM_SIZ_16b, 8, 0, G_TX_RENDERTILE, 0, G_TX_CLAMP, 5, G_TX_NOLOD, G_TX_CLAMP, 5, G_TX_NOLOD),
    gsDPSetTileSize(0, 0, 0, (32 - 1) << G_TEXTURE_IMAGE_FRAC, (32 - 1) << G_TEXTURE_IMAGE_FRAC),
    gsSPDisplayList(monty_mole_seg5_dl_05004CE8),
    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
    gsDPPipeSync(),
    gsDPSetCombineMode(G_CC_SHADE, G_CC_SHADE),
    gsSPSetGeometryMode(G_CULL_BACK | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
};


 (slotArray[a] === slotArray[b]) {
                matches = 3
            }
        }

        let matchText
        switch (matches) {
            case 1:
                matchText = `**Matches: 1** ${discord.getEmoji("mexShrug")}`
                break
            case 2:
                matchText = `**Matches: 2** ${discord.getEmoji("aquaUp")}`
                break
            case 3:
                matchText = `**Matches: 3** ${discord.getEmoji("gabYes")}\n **Perfect Score!** 🎉`
            default:
        }

        const left = discord.getEmoji("left")
        await message.channel.send(`**Slot Machine** ${discord.getEmoji("KannaXD")}\n`)
        await message.channel.send(
            `${discord.getEmoji(slotArray[0])} ${discord.getEmoji(slotArray[1])} ${discord.getEmoji(slotArray[2])} ${row === 1 ? left : ""}\n` +
            `${discord.getEmoji(slotArray[3])} ${discord.getEmoji(slotArray[4])} ${discord.getEmoji(slotArray[5])} ${row === 2 ? left : ""}\n` +
            `${discord.getEmoji(slotArray[6])} ${discord.getEmoji(slotArray[7])} ${discord.getEmoji(slotArray[8])} ${row === 3 ? left : ""}\n`
        )
        return message.channel.send(matchText)
    }
}
import { Component, OnInit, Input, Output, EventEmitter, ViewChild, ElementRef } from '@angular/core';

@Component({
  selector: 'app-incrementador',
  templateUrl: './incrementador.component.html',
  styles: []
})
export class IncrementadorComponent implements OnInit {

// Para hacer referencia a un elemento concreto
@ViewChild('txtProgress') txtProgress: ElementRef;

// Insertamos 'algo' (datos o lo que sea) en nuestro componente
@Input('nombre') leyenda: string = 'Leyenda';
@Input('progress')  progress: number = 20;

// Emitimos un número como un evento a las barras de progreso
@Output() cambioValor: EventEmitter<number> = new EventEmitter();

  constructor() {
    // console.log('Constructor: ', 'Leyenda', this.leyenda);
    // console.log('progress', this.progress);
  }

  ngOnInit() {
    // console.log('ngInit: ', 'Leyenda', this.leyenda);
    // console.log('progress', this.progress);
  }

  cambiarValor(valor) {

    this.progress = this.progress + valor;

    if (this.progress >= 100) {
      this.progress = 100;
    }

    if (this.progress <= 0 ) {
      this.progress = 0;
    }

    // Emito el valor a la barra de progreso
    this.cambioValor.emit(this.progress);

  }

  onChange(valor: number) {

    // Cojo el elemento [0] del array de elementos con name 'progress'
    // const elemHTML: any = document.getElementsByName('progress')[0];

    if (valor >= 100) {
      this.progress = 100;
    } else if (valor <= 0) {
      this.progress = 0;
    } else {
      this.progress = valor;
    }

    // elemHTML.value = this.progress;
    this.txtProgress.nativeElement.value = this.progress; // Uso el @ViewChild

    // Emito el valor a la barra de progreso
    this.cambioValor.emit(this.progress);

    // Ponemos el foco en el elemento
    this.txtProgress.nativeElement.focus();
  }

}
import {IMassUpdateSelectPlanObject} from 'app/plan/mass-update/interfaces/iMassUpdateSelectPlanObject';
/**
 * Interface used by to define what a Mass Category Select Plan Object should contain
 */
export interface IMassUpdateSelectPlanData {

  /**
   * Inidcates The


ActionEvent<MessageEvent>("message", AddEventListener, RemoveEventListener); set { } }
        /// <summary>
        /// Fired when a message arrives that can't be deserialized. Also available via the onmessageerror property.
        /// </summary>
        public ActionEvent<MessageEvent> OnMessageError { get => new ActionEvent<MessageEvent>("messageerror", AddEventListener, RemoveEventListener); set { } }
        /// <summary>
        /// The BroadcastChannel.close() terminates the connection to the underlying channel, allowing the object to be garbage collected. This is a necessary step to perform as there is no other way for a browser to know that this channel is not needed anymore.
        /// </summary>
        public void Close() => JSRef!.CallVoid("close");
        /// <summary>
        /// The BroadcastChannel.postMessage() sends a message, which can be of any kind of Object, to each listener in any browsing context with the same origin. The message is transmitted as a 'message' event targeted at each BroadcastChannel bound to the channel.
        /// </summary>
        /// <param name="message">Data to be sent to the other window. The data is serialized using the structured clone algorithm. This means you can pass a broad variety of data objects safely to the destination window without having to serialize them yourself.</param>
        public void PostMessage(object message) => JSRef!.CallVoid("postMessage", message);
    }
}


[180252] = "食人妖英雄閃電",
[180253] = "食人妖英雄風之傳送門",
[180254] = "食人妖英雄火焰傳送門",
[180255] = "聯盟出入口",
[180256] = "部落出入口",
[180322] = "鬼魂之門",
[180323] = "祖爾格拉布之門",
[180324] = "矮人餐桌裝飾品 01",
[180325] = "椅子",
[180326] = "旅店桌子",
[180327] = "瘋狂之緣的火盆",
[180328] = "一般的燭臺 01",
[180329] = "水罐 01",
[180330] = "水罐 02",
[180331] = "水罐 03",
[180332] = "水罐 01",
[180333] = "水罐 02",
[180334] = "暴風城地毯 02",
[180335] = "暗月馬戲團音樂裝飾",
[180337] = "烹飪台",
[180338] = "蠟燭 01",
[180339] = "蠟燭 02",
[180340] = "蠟燭 03",
[180341] = "獸人罈子 01",
[180342] = "獸人罈子 02",
[180343] = "帕格漁場法術集中",
[180345] = "獸人罈子 03",
[180346] = "臭泥魚誘餌",
[180347] = "獸人罈子 04",
[180348] = "獸人罈子 05",
[180349] = "獸人罈子 06",
[180350] = "獸人水罐 01",
[180351] = "獸人水罐 02",
[180352] = "一般火炬 01",
[180353] = "獨立式火炬 01",
[180358] = "格里雷克，鋼鐵之血",
[180362] = "進食",
[180364] = "哈札拉爾，織夢者",
[180365] = "雷納塔基，千刃之王",
[180366] = "破碎的工具箱",
[180367] = "贊札祭壇",
[180368] = "瘋狂石碑",
[180369] = "混濁的水",
[180370] = "收穫節水果",
[180371] = "收穫節魚肉",
[180372] = "收穫節野豬",
[180373] = "收穫節蜜酒",
[180374] = "收穫節蜜酒",
[180375] = "贊札祭壇法術集中",
[180376] = "狂暴增益",
[180377] = "進食",
[180378] = "狂暴增益",
[180379] = "速度增益",
[18


elfmade
|tip Create them with Mining. |only if selfmade
'|complete skill("Blacksmithing") >= 165 |or
step
label "Collect_Heavy_Grinding_Stone_165"
map Arathi Highlands
path follow smart; loop on; ants curved; dist 20
path	76.64,42.59	75.00,44.93	72.65,48.07	70.58,55.05	69.99,58.40
path	72.92,59.03	72.28,63.63	72.78,66.86	71.75,66.15	69.15,72.54
path	67.17,70.90	63.52,73.55	59.48,74.71	59.32,70.74	56.16,71.89
path	50.82,78.41	47.96,82.44	42.53,80.75	43.02,77.16	40.39,71.86
path	37.95,67.63	38.52,68.50	33.94,66.02	34.59,61.64	33.70,56.77
path	33.45,53.94	33.65,50.19	35.00,47.28	32.96,46.68	31.68,45.41
path	32.34,42.64	31.42,41.24	25.23,43.10	20.94,39.12	20.02,35.80
path	19.12,33.36	22.43,31.28	23.48,24.90	26.93,20.65	28.65,14.18
path	28.96,16.96	31.62,18.63	30.96,20.36	33.19,21.23	36.35,24.61
path	39.97,25.62	40.21,28.79	43.97,30.51	45.70,33.02	48.08,33.60
path	49.78,36.76	52.14,36.11	52.75,31.99	54.80,33.13	58.19,32.50
path	58.02,34.22	59.94,35.97	62.25,32.06	64.69,35.58	64.49,26.56
path	66.77,27.64	70.39,27.07	70.47,30.74	71.07,38.63
Click ore as you follow the path around this area
|tip Track them on your minimap with "Find Minerals".
collect 10 Heavy Grinding Stone##3486 |or
|tip You created these in a previous step.
'|complete skill("Blacksmithing") >= 165 |or
step
Enter the building |goto Ironforge 43.85,29.81 < 7 |walk
talk Poranna Snowbraid##5154
|tip Inside the building.
buy 35 Green Dye##2605 |goto Ironforge 42.96,28.32 |or
'|complete skill("Blacksmithing") >= 165 |or
step
Open Your Blacksmithing Crafting Panel:
_<Create 10 Green Iron Leggings>_
|tip Stand next to an anvil.
Reach Skill 165 in Blacksmithing |skill Blacksmithing,165 |goto Ironforge 52.55,41.46
step
talk Bengus Deepforge##4258
Train Green Iron Bracers |learn Green Iron Bracers##3501 |goto Ironforge 52.55,41.46
stickystart "Collect_Green_Dye_190"
step
map Arathi Highlands
path follow smart; loop on; ants curved; dist 20
path	76.64,42.59	75.00,44.93	72.65,48.07	70.58,55.05	69.99,58.40
path	72.92,59.03	72.28,63.63	72.78,66.86	71.75,66.15	69.15,72.54
path	67.17,70.90	63.52,73.55	59.48,


import serial
import time
import sys

#enter your device file
arddev = sys.argv[1]
baud = 115200

#setup - if a Serial object can't be created, a SerialException will be raised.
start_time = time.time()

while True:
    try:
        ser = serial.Serial(arddev, baud)

        #break out of while loop when connection is made
        break
    except serial.SerialException:
        print 'waiting for device ' + arddev + ' to be available'
        time.sleep(3)

#read lines from serial device
f = open(sys.argv[2], 'rb')
b = f.read()
a = 0;
#
t=""
print "Start"
start_time = time.time()
while True:

	#for i in range(0, 256):
		#print "write"
		#ser.write(str(ord(b[a +i])) + "\n")
	ser.write(b[a:a+256])

	a = a + 256
	#for i in range(0, 4):
	#	print ser.readline()
	#print "address",

	print (a * 1.0/0x7ffff *100.0)

	print ser.readline();

	if (a>0x7ffff):

		print "Complete!"
		# your code
		elapsed_time = time.time() - start_time
		print elapsed_time
		exit()