ease add everything after https://youtube.com/ in channel url
  YoutubeID = "c/your_youtube_id"
```

To add a menu item add `[[menu.header]]` item to `config.toml`. For example:

```
[menu]
  [[menu.header]]
    name = "posts"
    weight = 0
    url = "/posts"
```

To add a submenu item add `[[menu.header]]` item with a parent parameter to `config.toml`. For example:

```
[menu]
  [[menu.header]]
    identifier = "post"
    name = "posts"
    weight = 0
  [[menu.header]]
    parent = "post"
    name = "All Posts"
    url = "/posts"
  [[menu.header]]
    parent = "post"
    name = "categories"
    url = "/categories"
  [[menu.header]]
    parent = "post"
    name = "tags"
    url = "/tags"
```

To enable disqus comments add `disqusShortname` to your `config.toml`.

You can turn off disqus comments per page by adding `nocomments = true` to the front matter.

To disable the post date from a specific page add `showpostdate = false` to your relevant `.md` file.

Pages now also support ![Lastmod](https://gohugo.io/methods/page/lastmod/). This will not appear until you populate `lastmod:` in the page's frontmatter, unless you have `enableGitInfo` set to `true` in your site's config file, in which case it will use the date of the last git commit containing that page.

## License

Nix is licensed under the [MIT License](LICENSE.md)
# Contributing to Llamactl

Thank you for considering contributing to Llamactl! This document outlines the development setup and contribution process.

## Development Setup

### Prerequisites

- Go 1.24 or later
- Node.js 22 or later
- `llama-server` executable (from [llama.cpp](https://github.com/ggml-org/llama.cpp))

### Getting Started

1. **Clone the repository**
   ```bash
   git clone https://github.com/lordmathis/llamactl.git
   cd llamactl
   ```

2. **Install dependencies**
   ```bash
   # Go dependencies
   go mod download

   # Frontend dependencies
   cd webui && npm ci && cd ..
   ```

3. **Run for development**
   ```bash
   # Start backend server
   go run ./cmd/server
   ```
   Server will be available at `http://localhost:8080`

   ```bash
   # In a separate terminal, start frontend dev server
   cd webui && npm run dev
   ```
   Development UI will be available at `http://localhost:5173`

4. **Common development commands**
   ```bash
   # Backend
   go test ./... -v                    # Run tests
   go test -race ./... -v              # Run with race detector
   go fmt ./... && go vet ./...        # Format and vet code

   # Frontend (run from webui/ directory)
   npm run test:run                    # Run tests once
   npm run test                        # Run tests in watch mode
   npm run type-check                  # TypeScript type checking
   npm run lint:fix                    # Lint and fix issues
   ```

## Before Submitting a Pull Request

### Required Checks

All the following must pass:

1. **Backend**
   ```bash
   go test ./... -v
   go test -race ./... -v
   go fmt ./... && go vet ./...
   go build -o llamactl ./cmd/server


local app = app
local Class = require "Base.Class"
local Observable = require "Base.Observable"
local Signal = require "Signal"

local Chooser = Class {}
Chooser:include(Observable)

function Chooser:init(chain, currentSource)
  app.collectgarbage()
  Observable.init(self)
  self:setClassName("Source.Chooser")
  self.chain = chain

  self.panels = {}
  local graphic = app.Graphic(0, 0, 128, 64)
  local Drawings = require "Drawings"
  local drawing = app.Drawing(0, 0, 128, 64)
  drawing:add(Drawings.Sub.HelpfulButtons)
  graphic:addChild(drawing)

  local panel = app.TextPanel("Jacks", 1, 0.5, app.GRID5_LINE3 - 1)
  self.panels[1] = panel
  graphic:addChild(panel)
  if chain then
    panel = app.TextPanel("Locals", 2, 0.5, app.GRID5_LINE3 - 1)
  else
    panel = app.TextPanel("", 2, 0.5, app.GRID5_LINE3 - 1)
  end
  self.panels[2] = panel
  graphic:addChild(panel)
  local GlobalChains = require "GlobalChains"
  local nGlobals = GlobalChains.count()
  if nGlobals == 1 then
    panel = app.TextPanel("1 Global", 3, 0.5, app.GRID5_LINE3 - 1)
  else
    panel = app.TextPanel(string.format("%d Globals", nGlobals), 3, 0.5,
                          app.GRID5_LINE3 - 1)
  end
  self.panels[3] = panel
  Signal.weakRegister("onGlobalChainCountChanged", self)
  graphic:addChild(panel)

  local label = app.Label("Choose a source.", 10)
  label:setJustification(app.justifyLeft)
  label:setPosition(3, app.GRID5_LINE1)
  graphic:addChild(label)
  self.help1 = label

  label = app.Label("M1-M6 to commit.", 10)
  label:setJustification(app.justifyLeft)
  label:setPosition(3, app.GRID5_LINE2)
  graphic:addChild(label)
  self.help2 = label

  label = app.Label("CANCEL to abort.", 10)
  label:setJustification(app.justifyLeft)
  label:setPosition(3, app.GRID5_LINE3)
  graphic:addChild(label)
  self.help3 = label

  self.menuGraphic = graphic

  self.index = 1
  self.currentSource = currentSource
  if currentSource then
    if currentSource.type == "global" then
      self.index = 3
    elseif currentSource.type == "local" then
      self.index = 2
    end
  end

  if self.index == 3 and nGlobals == 0 then
    self.index = 1
  end

  self:setChooser(self.index)
end

function Chooser:onGlobalChainCountChanged(n)
  if n == 1 then
    self.panels[3]:setText("1 Global")
  else
    self.panels[3]:setText(string.format("%d Globals", n))
  end
  if n == 0 and self.index == 3 then
    self:setChooser(1)
  end
end

function Chooser:getExternalChooser()
  if self.externals == nil then
    local ExternalChooser = require "Source.ExternalChooser"
    self.externals = ExternalChooser(self)
  end
  return self.externals
end

function Cho


.65,39.78,24.28,40.21,24.02,47.58,23.29,49.76,23.18,50.58,22.36,51.70,21.92,52.63,22.05,54.06,22.96,56.11,24.38,56.30,25.42,56.33;.mob Deepstrider Giant"
        },
      },
    },
    ["Durotar"] = {
      ["Warlord Kolkanis"] = {
        {
        MinLevel = 9,
        MaxLevel = 9,
        Classification = "Rare",
        Movement = "Idle",
        Notes = "Pummel, Thunderclap, 3 spawn locations",
        Location = ".pin Durotar,50.2,80.0;.pin Durotar,48.0,77.6;.pin Durotar,46.6,79.8;.mob Warlord Kolkanis"
        },
      },
      ["Zalazane"] = {
        {
        MinLevel = 10,
        MaxLevel = 10,
        Classification = "Normal",
        Movement = "Slow Patrol",
        Notes = "Healing Wave, often double pull",
        Location = ".line Durotar,66.6,87.6,67.6,87.8,67.6,86.8;.mob Zalazane"
        },
      },
      ["Captain Flat Tusk"] = {
        {
        MinLevel = 11,
        MaxLevel = 11,
        Classification = "Rare Elite",
        Movement = "Idle",
        Notes = "Heroic Strike; can burst for 100+ damage",
        Location = ".pin Durotar,44.76,50.66;.pin Durotar,39.20,53.64;.pin Durotar,40.04,48.91;.pin Durotar,43.53,39.93;.pin Durotar,43.51,37.10;.mob Captain Flat Tusk"
        },
      },
      ["Felweaver Scornn"] = {
        {
        MinLevel = 11,
        MaxLevel = 11,
        Classification = "Rare Elite",
        Movement = "Idle",
        Notes = "High damage shadowbolt + voidwalker, in a cave",
        Location = ".pin Durotar,52.78,8.96;.mob Felweaver Scornn"
        },
      },
      ["Fizzle Darkstorm"] = {
        {
        MinLevel = 12,
        MaxLevel = 12,
        Classification = "Normal",
        Movement = "Idle",
        Notes = "High damage Shadowbolt + Drain Life + Imp",
        Location = ".pin Durotar,42.12,26.66;.mob Fizzle Darkstorm"
        },
      },
      ["Makasgar"] = {
        {
        MinLevel = 12,
        MaxLevel = 12,
        Classification = "Normal",
        Movement = "Idle",
        Notes = "Not dangerous, just in a weird place",


" bc=\"仙剑奇侠传四 > 主线剧情 > 第一章\"/><di ky=\"238\" rd=\"Paltoc-sc/pal4/pal4_MainStory/pal4_MainStory_01_05.htm|女萝平妖\" ct=\"寿阳城—柳府—前厅 柳世封：哈哈，贤侄～来得正好，我们正要向韩姑娘说女萝岩之事，你也听听。 云天河：哦，好…… 柳世封：说来惭愧，我初来寿阳时，治理无方，此地百姓虽不至困顿潦倒，却也绝非大有余钱，行商 ...\" bc=\"仙剑奇侠传四 > 主线剧情 > 第一章\"/><di ky=\"239\" rd=\"Paltoc-sc/pal4/pal4_MainStory/pal4_MainStory_01_06.htm|少年行\" ct=\"（城门出口处） 柳梦璃：菱纱，你适才说不走官道，是有其他办法去陈州吗？ 韩菱纱：那当然！韩女侠自有妙计！ 云天河：……？ 韩菱纱：（哼哼，我～偏～不～说～了，想知道就来问呐！） 韩菱纱：（…………一个 ...\" bc=\"仙剑奇侠传四 > 主线剧情 > 第一章\"/><di ky=\"240\" rd=\"Paltoc-sc/pal4/pal4_MainStory/pal4_MainStory_01_07.htm|风水惊变\" ct=\"云天河：前面……真的有杀气！ 柳梦璃：会不会是误闯进墓中的野兽？ 韩菱纱：一点声响都没有啊…… 云天河：咦？是个女孩子？ 云天河：……穿这么少？ 柳梦璃：小心！她身上戾气很重！ 韩菱纱：啊！ 云天河： ...\" bc=\"仙剑奇侠传四 > 主线剧情 > 第一章\"/><di ky=\"241\" rd=\"Paltoc-sc/pal4/pal4_MainStory/pal4_MainStory_01_08.htm|弦歌问情\" ct=\"陈州 （城门入口处） 韩菱纱：说起来，陈州才算得上是淮河岸边真正的宝地～传说天神伏羲在这儿设下了先天八卦之阵，再厉害的妖魔也不能作乱。而且历朝历代的皇亲国戚都特别偏爱这里，最最有名的要数那个才高很多斗 ...\" bc=\"仙剑奇侠传四 > 主线剧情 > 第一章\"/><di ky=\"242\" rd=\"Paltoc-sc/pal4/pal4_MainStory/pal4_MainStory_01_09.htm|寻仙昆仑\" ct=\"陈州（城门入口处） 柳梦璃：刚才为等我耽搁了，实在过意不去。 怀朔：姑娘多礼了。其实倒没耽搁什么，我也正好陪璇玑去买糖葫芦—— 璇玑：师～兄～～ 璇玑：这么丢脸的事不要拿出来说嘛～ 怀朔：好～不说不说 ...\" bc=\"仙剑奇侠传四 > 主线剧情 > 第一章\"/><di ky=\"243\" rd=\"Paltoc-sc/pal4/pal4_MainStory/pal


		X509Chain_CheckRevocationOnChain_m2441901351(__this, L_23, /*hidden argument*/NULL);
		X509Chain_WrapUp_m1072032285(__this, /*hidden argument*/NULL);
		return;
	}
}
// System.Void System.Security.Cryptography.X509Certificates.X509Chain::Process(System.Int32)
extern "C"  void X509Chain_Process_m2508784250 (X509Chain_t777637347 * __this, int32_t ___n0, const MethodInfo* method)
{
	static bool s_Il2CppMethodInitialized;
	if (!s_Il2CppMethodInitialized)
	{
		il2cpp_codegen_initialize_method (X509Chain_Process_m2508784250_MetadataUsageId);
		s_Il2CppMethodInitialized = true;
	}
	X509ChainElement_t528874471 * V_0 = NULL;
	X509Certificate2_t4056456767 * V_1 = NULL;
	X509Certificate2_t4056456767 * V_2 = NULL;
	bool V_3 = false;
	X509Certificate2_t4056456767 * G_B6_0 = NULL;
	X509Chain_t777637347 * G_B6_1 = NULL;
	X509Certificate2_t4056456767 * G_B5_0 = NULL;
	X509Chain_t777637347 * G_B5_1 = NULL;
	AsymmetricAlgorithm_t784058677 * G_B7_0 = NULL;
	X509Certificate2_t4056456767 * G_B7_1 = NULL;
	X509Chain_t777637347 * G_B7_2 = NULL;
	{
		X509ChainElementCollection_t2081831987 * L_0 = __this->get_elements_1();
		int32_t L_1 = ___n0;
		NullCheck(L_0);
		X509ChainElement_t528874471 * L_2 = X509ChainElementCollection_get_Item_m1494130666(L_0, L_1, /*hidden argument*/NULL);
		V_0 = L_2;
		X509ChainElement_t528874471 * L_3 = V_0;
		NullCheck(L_3);
		X509Certificate2_t4056456767 * L_4 = X509ChainElement_get_Certificate_m3929662793(L_3, /*hidden argument*/NULL);
		V_1 = L_4;
		int32_t L_5 = ___n0;
		X509ChainElementCollection_t2081831987 * L_6 = __this->get_elements_1();
		NullCheck(L_6);
		int32_t L_7 = X509ChainElementCollection_get_Count_m905965108(L_6, /*hidden argument*/NULL);
		if ((((int32_t)L_5) == ((int32_t)((int32_t)((int32_t)L_7-(int32_t)1)))))
		{
			goto IL_007b;
		}
	}
	{
		X509Certificate2_t4056456767 * L_8 = V_1;
		NullCheck(L_8);
		X509Certificate_t324051958 * L_9 = X509Certificate2_get_MonoCertificate_m2721967882(L_8, /*hidden argument*/NULL);
		NullCheck(L_9);
		String_t* L_10 = VirtFuncInvoker0< String_t* >::Invoke(6 /* System.String Mono.Security.X509.X509Certificate::get_KeyAlgorithm() */, L_9);
		IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
		bool L_11 = String_op_Equality_m1790663636(NULL /*static, unused*/, L_10, _stringLiteral186901249, /*hidden argument*/NULL);
		if (!L_11)
		{
			got


mock_workspace_folder("/home/nvim/test")
      assert.are.same("nvim_dev_container_homenvimtest", subject.get_image_cache_tag())
    end)

    it("should replace backslashes", function()
      mock_workspace_folder("\\test\\dir")
      assert.are.same("nvim_dev_container_testdir", subject.get_image_cache_tag())
    end)

    it("should replace colons", function()
      mock_workspace_folder("D:\\test\\dir")
      assert.are.same("nvim_dev_container_dtestdir", subject.get_image_cache_tag())
    end)
  end)
end)


cess([]byte(FALSE))).Times(1)

	// update, approve
	nodeUpdateInfo := &UpdateNodeInfo{
		NodeName: UpdateInfo{
			OldInfo: nodes[5].Name,
			NewInfo: nodes[4].Name,
			IsEdit:  true,
		},
		Permission: UpdateMapInfo{
			OldInfo: nodes[5].Permissions,
			NewInfo: nodes[5].Permissions,
			IsEdit:  false,
		},
	}
	nodeUpdateInfoData, err := json.Marshal(nodeUpdateInfo)
	assert.Nil(t, err)
	// IsAnyAvailableAdmin error
	res = nm.Manage(string(governance.EventUpdate), BallotApprove, string(governance.GovernanceAvailable), nodes[5].Account, nodeUpdateInfoData)
	assert.False(t, res.Ok, string(res.Result))
	// ok
	res = nm.Manage(string(governance.EventUpdate), BallotApprove, string(governance.GovernanceAvailable), nodes[5].Account, nodeUpdateInfoData)
	assert.True(t, res.Ok, string(res.Result))

	mockStub.EXPECT().CrossInvoke(constant.RoleContractAddr.Address().String(), "IsAnyAvailableAdmin", gomock.Any(), gomock.Any()).Return(boltvm.Error("", "IsAnyAvailableAdmin error")).Times(1)
	mockStub.EXPECT().CrossInvoke(constant.RoleContractAddr.Address().String(), "IsAnyAvailableAdmin", gomock.Any(), gomock.Any()).Return(boltvm.Success([]byte(FALSE))).Times(1)

	// update, reject
	// IsAnyAvailableAdmin error
	res = nm.Manage(string(governance.EventUpdate), BallotReject, string(governance.GovernanceAvailable), nodes[5].Account, nodeUpdateInfoData)
	assert.False(t, res.Ok, string(res.Result))
	// ok
	res = nm.Manage(string(governance.EventUpdate), BallotReject, string(governance.GovernanceAvailable), nodes[5].Account, nodeUpdateInfoData)
	assert.True(t, res.Ok, string(res.Result))

	// logout, approve
	res = nm.Manage(string(governance.EventLogout), BallotApprove, string(governance.GovernanceAvailable), nodes[6].Account, nil)
	assert.True(t, res.Ok, string(res.Result))

	mockStub.EXPECT().CrossInvoke(constant.RoleContractAddr.Address().String(), "GetRoleInfoById", gomock.Any()).Return(boltvm.Error("", "GetRoleInfoById error")).Times(1)
	forbiddenRole := &Role{
		ID:     nodes[6].AuditAdminAddr,
		Status: governance.GovernanceForbidden,
	}
	forbiddenRoleData, err := json.Marshal(forbiddenRole)
	assert.Nil(t, err)
	bindingRole := &Role{
		ID:     nodes[6].AuditAdminAddr,
		Status: governance.GovernanceBinding,
	}
	bindingRoleData, err := json.Marshal(bindingRole)
	assert.Nil(t, err)
	mockStub.EXPECT().CrossInvoke(constant.RoleContractAddr.Address().String(), "GetRoleInfoById", gomock.Any()).Return(boltvm.Success(forbiddenRoleData)).Times(1)
	mockStub.EXPECT().CrossInvoke(constant.RoleContractAddr.Address().String(), "GetRoleInfoById", gomock.Any()).Return(boltvm.Success(bindingRoleData)).AnyTimes()

	mockStub.EXPECT().CrossInvoke(constant.RoleContractAddr.Address().String(), "RestoreAuditAdminBinding", gomock.Any()).Return(boltvm.Error("", "RestoreAuditAdminBinding error")).Times(1)
	mockStub.EXPECT().CrossInvoke(constant.RoleContractAddr.Address().String(), "RestoreAuditAdminBinding", gomock.Any()).Return(boltvm.Success(nil)).Times(1)


 rz_set ||
                                           scalex_set || scaley_set || scalez_set ||
                                           mirrorx_set || mirrory_set || mirrorz_set; }
    };

    struct Object {
        Object() : idx(-1) {}
        int                     idx;
        std::vector<Instance>   instances;
    };

    // Version of the amf file
    //unsigned int             m_version { 0 };
    // Current Expat XML parser instance.
    XML_Parser               m_parser;
    // Error code returned by the application side of the parser. In that case the expat may not reliably deliver the error state
    // after returning from XML_Parse() function, thus we keep the error state here.
    bool                     m_error { false };
    std::string              m_error_message;
    // Model to receive objects extracted from an AMF file.
    Model                   &m_model;
    // Current parsing path in the XML file.
    std::vector<AMFNodeType> m_path;
    // Current object allocated for an amf/object XML subtree.
    ModelObject             *m_object { nullptr };
    // Map from obect name to object idx & instances.
    std::map<std::string, Object> m_object_instances_map;
    // Vertices parsed for the current m_object.
    std::vector<Vec3f>       m_object_vertices;
    // Current volume allocated for an amf/object/mesh/volume subtree.
    ModelVolume             *m_volume { nullptr };
    // Faces collected for the current m_volume.
    std::vector<Vec3i32>       m_volume_facets;
    // Transformation matrix of a volume mesh from its coordinate system to Object's coordinate system.
    Transform3d 			 m_volume_transform;
    // Current material allocated for an amf/metadata subtree.
    ModelMaterial           *m_material { nullptr };
    // Current instance allocated for an amf/constellation/instance subtree.
    Instance                *m_instance { nullptr };
    // Generic string buffer for vertices, face indices, metadata etc.
    std::string              m_value[5];
    // Pointer to config to update if config data are stored inside the amf file
    DynamicPrintConfig      *m_config { nullptr };
    // Config substitution rules and collected config substitution log.
    ConfigSubstitutionContext *m_config_substitutions { nullptr };
    //BBS: add units logic
    bool                     m_use_inches { false };

private:
    AMFParserContext& operator=(AMFParserContext&);
};

void AMFParserContext::startElement(const char *name, const char **atts)
{
    AMFNodeType node_type_new = NODE_TYPE_UNKNOWN;
    switch (m_path.size()) {
    case 0: {
        // An AMF file must start with an <amf> tag.
        node_type_new = NODE_TYPE_AMF;
        if (strcmp(name, "amf") != 0) this->stop();
        // BBS: add units logic
        const char *units = get_attribute(atts, "unit");
        if (units && (strcmp(units, "inch") == 0)) { m_use_inches = true; }
        break;
    }
    case 1:
        if (strcmp(name, "metadata") == 0) {
            const char *type = get_attribute(atts, "type");
            if (type != nullptr) {
                m_value[0] = type;
                node_type_new = NODE_TYPE_METADATA;
            }
        } else if (strcmp(name, "material") == 0) {
            const char *material_id = get_attribute(atts, "id");
            m_material = m_model.add_material((material_id == nullptr) ? "_" : material_id);
            node_type_new = NODE_TYPE_MATERIAL;
        } else if (


手\(面试常客\)](#二-tcp-三次握手和四次挥手面试常客)
  - [为什么要三次握手](#为什么要三次握手)
  - [为什么要传回 SYN](#为什么要传回-syn)
  - [传了 SYN,为啥还要传 ACK](#传了-syn为啥还要传-ack)
  - [为什么要四次挥手](#为什么要四次挥手)
- [三 TCP、UDP 协议的区别](#三-tcp、udp-协议的区别)
- [四 TCP 协议如何保证可靠传输](#四-tcp-协议如何保证可靠传输)
  - [停止等待协议](#停止等待协议)
  - [自动重传请求 ARQ 协议](#自动重传请求-arq-协议)
  - [连续ARQ协议](#连续arq协议)
  - [滑动窗口](#滑动窗口)
  - [流量控制](#流量控制)
  - [拥塞控制](#拥塞控制)
- [五  在浏览器中输入url地址 ->> 显示主页的过程（面试常客）](#五-在浏览器中输入url地址---显示主页的过程（面试常客）)
- [六 状态码](#六-状态码)
- [七 各种协议与HTTP协议之间的关系](#七-各种协议与http协议之间的关系)
- [八  HTTP长连接、短连接](#八-http长连接、短连接)
- [写在最后](#写在最后)
  - [计算机网络常见问题回顾](#计算机网络常见问题回顾)
  - [建议](#建议)

<!-- /MarkdownTOC -->

相对与上一个版本的计算机网路面试知识总结，这个版本增加了 “TCP协议如何保证可靠传输”包括超时重传、停止等待协议、滑动窗口、流量控制、拥塞控制等内容并且对一些已有内容做了补充。

## 一 OSI与TCP/IP各层的结构与功能,都有哪些协议

###  五层协议的体系结构

学习计算机网络时我们一般采用折中的办法，也就是中和 OSI 和 TCP/IP 的优点，采用一种只有五层协议的体系结构，这样既简洁又能将概念阐述清楚。

![五层协议的体系结构](https://user-gold-cdn.xitu.io/2018/7/29/164e5307471e8eba?w=633&h=344&f=png&s=164623)

结合互联网的情况，自上而下地，非常简要的介绍一下各层的作用。

### 1 应用层

**应用层(application-layer）的任务是通过应用进程间的交互来完成特定网络应用。**应用层协议定义的是应用进程（进程：主机中正在运行的程序）间的通信和交互的规则。对于不同的网络应用需要不同的应用层协议。在互联网中应用层协议很多，如**域名系统DNS**，支持万维网应用的 **HTTP协议**，支持电


'},
{'30135',	'cctvx.cc',	'cctvx.cc'},
{'30136',	'cctvy2.cn',	'cctvy2.cn'},
{'30137',	'ccu.118bbs.com',	'ccu.118bbs.com'},
{'30138',	'ccutv61.com',	'ccutv61.com'},
{'30139',	'ccv004.com',	'ccv004.com'},
{'30140',	'ccv1201.com',	'ccv1201.com'},
{'30141',	'ccw12.com',	'ccw12.com'},
{'30142',	'ccxx.killhhh.cn',	'ccxx.killhhh.cn'},
{'30143',	'ccytv3.com',	'ccytv3.com'},
{'30144',	'cddzfx.com',	'cddzfx.com'},
{'30145',	'cde.2020wyt.com',	'cde.2020wyt.com'},
{'30146',	'cde.ss.la',	'cde.ss.la'},
{'30147',	'cdew32dsw.cn',	'cdew32dsw.cn'},
{'30148',	'cdf.odwould.cn',	'cdf.odwould.cn'},
{'30149',	'cdfgge.net',	'cdfgge.net'},
{'30150',	'cdn.download.sweetim.com',	'cdn.download.sweetim.com'},
{'30151',	'cdn.dsultra.com',	'cdn.dsultra.com'},
{'30152',	'cebbgnk.com',	'cebbgnk.com'},
{'30153',	'cebbxnk.com',	'cebbxnk.com'},
{'30154',	'cebistro.com',	'cebistro.com'},
{'30155',	'ceewe3w2.cn',	'ceewe3w2.cn'},
{'30156',	'celine.9966.org',	'celine.9966.org'},
{'30157',	'ceqdfg.3322.org',	'ceqdfg.3322.org'},
{'30158',	'ces-hunter.com',	'ces-hunter.com'},
{'30159',	'ceshikl.7766.org',	'ceshikl.7766.org'},
{'30160',	'cevalterng.com',	'cevalterng.com'},
{'30161',	'cfile202.uf.daum.net',	'cfile202.uf.daum.net'},
{'30162',	'cfkvqhaxhvfp.com',	'cfkvqhaxhvfp.com'},
{'30163',	'cfq58.cn',	'cfq58.cn'},
{'30164',	'cfqq1.com',	'cfqq1.com'},
{'30165',	'cfqqd.com',	'cfqqd.com'},
{'30166',	'cfqqm.com',	'cfqqm.com'},
{'30167',	'cfqqo.com',	'cfqqo.com'},
{'30168',	'cfqqqc.com',	'cfqqqc.com'},
{'30169',	'cfqqr.com',	'cfqqr.com'},
{'30170',	'cfqqy.com',	'cfqqy.com'},
{'30171',	'cfrsc.com',	'cfrsc.com'},
{'30172',	'cfx8.cn',	'cfx8.cn'},
{'30173',	'cfy.2288.org',	'cfy.2288.org'},
{'30174',	'cg77.fileave.com',	'cg77.fileave.com'},
{'30175',	'cgi.ebay.com.jghtyu.com',	'cgi.ebay.com.jghtyu.com'},
{'30176',	'cgi35.plala.or.jp',	'cgi35.plala.or.jp'},
{'30177',	'cgx0577.3322.org',	'cgx0577.3322.org'},
{'30178',	'ch


2] = 0;
   _memset(($c|0),0,152)|0;
   $4 = $c;
   $5 = $4;
   HEAP32[$5>>2] = 1;
   $6 = (($4) + 4)|0;
   $7 = $6;
   HEAP32[$7>>2] = 0;
   _memset(($d|0),0,152)|0;
   _memset(($e|0),0,152)|0;
   _memset(($f|0),0,152)|0;
   $8 = $f;
   $9 = $8;
   HEAP32[$9>>2] = 1;
   $10 = (($8) + 4)|0;
   $11 = $10;
   HEAP32[$11>>2] = 0;
   _memset(($g|0),0,152)|0;
   _memset(($h|0),0,152)|0;
   $12 = $h;
   $13 = $12;
   HEAP32[$13>>2] = 1;
   $14 = (($12) + 4)|0;
   $15 = $14;
   HEAP32[$15>>2] = 0;
   dest=$a+0|0; src=$q+0|0; stop=dest+80|0; do { HEAP32[dest>>2]=HEAP32[src>>2]|0; dest=dest+4|0; src=src+4|0; } while ((dest|0) < (stop|0));
   $i$018 = 0;$nqpqx$019 = $a;$nqpqx2$014 = $e;$nqpqz$013 = $b;$nqpqz2$015 = $f;$nqx$011 = $c;$nqx2$016 = $g;$nqz$012 = $d;$nqz2$017 = $h;
   while(1) {
    $16 = (31 - ($i$018))|0;
    $17 = (($n) + ($16)|0);
    $18 = HEAP8[$17>>0]|0;
    $byte$09 = $18;$j$08 = 0;$nqpqx$110 = $nqpqx$019;$nqpqx2$14 = $nqpqx2$014;$nqpqz$13 = $nqpqz$013;$nqpqz2$15 = $nqpqz2$015;$nqx$11 = $nqx$011;$nqx2$16 = $nqx2$016;$nqz$12 = $nqz$012;$nqz2$17 = $nqz2$017;
    while(1) {
     $19 = $byte$09&255;
     $20 = $19 >>> 7;
     _swap_conditional($nqx$11,$nqpqx$110,$20,0);
     _swap_conditional($nqz$12,$nqpqz$13,$20,0);
     _fmonty($nqx2$16,$nqz2$17,$nqpqx2$14,$nqpqz2$15,$nqx$11,$nqz$12,$nqpqx$110,$nqpqz$13,$q);
     _swap_conditional($nqx2$16,$nqpqx2$14,$20,0);
     _swap_conditional($nqz2$17,$nqpqz2$15,$20,0);
     $21 = $19 << 1;
     $22 = $21&255;
     $23 = (($j$08) + 1)|0;
     $exitcond = ($23|0)==(8);
     if ($exitcond) {
      break;
     } else {
      $nqz2$17$phi = $nqz$12;$nqz$12$phi = $nqz2$17;$nqx2$16$phi = $nqx$11;$nqx$11$ph


const` before the literal or call. This turns it into a constant pattern\nwhich preserves the current behavior:\n\n**BAD:**\n\n```dart\ncase [1, 2]:\ncase {'k': 'v'}:\ncase {1, 2}:\ncase Point(1, 2):\n```\n\n**GOOD:**\n\n```dart\ncase const [1, 2]:\ncase const {'k': 'v'}:\ncase const {1, 2}:\ncase const Point(1, 2):\n```\n\n* **Wildcards:** Rename the constant from `_` to something else. Since the name\nis private, this can be done locally in the library without affecting other\ncode.\n\n* **Everything else:** For any other invalid expression, you have to hoist the\nexpression out into a new named constant. For example, if you have code like\nthis:\n\n\n**BAD:**\n\n```dart\nswitch (n) {\n  case 1 + 2: ...\n}\n```\n\nIt can be fixed by changing it to:\n\n**GOOD:**\n\n ```dart\nconst three = 1 + 2;\n\nswitch (n) {\n  case three: ...\n}\n```",
    "sinceDartSdk": "3.0"
  },
  {
    "name": "invalid_runtime_check_with_js_interop_types",
    "description": "Avoid runtime type tests with JS interop types where the result may not\n    be platform-consistent.",
    "categories": [
      "errorProne",
      "web"
    ],
    "state": "stable",
    "incompatible": [],
    "sets": [
      "recommended",
      "flutter"
    ],
    "fixStatus": "needsEvaluation",
    "details": "**DON'T** use `is` checks where the type is a JS interop type.\n\n**DON'T** use `is` checks where the type is a generic Dart type that has JS\ninterop type arguments.\n\n**DON'T** use `is` checks with a JS interop value.\n\n`dart:js_interop` types have runtime types that are different based on whether\nyou are compiling to JS or to Wasm. Therefore, runtime type checks may result in\ndifferent behavior. Runtime checks also do not necessarily check that a JS\ninterop value is a particular JavaScript type.\n\n**BAD:**\n```dart\nextension type HTMLElement(JSObject o) {}\nextension type HTMLDivElement(JSObject o) implements HTMLElement {}\n\nvoid compute(JSAny a, bool b, List<JSObject> lo, List<String> ls, JSObject o,\n    HTMLElement e) {\n  a is String; // LINT, checking that a JS value is a Dart type\n  b is JSBoolean; // LINT, checking that a Dart value is a JS type\n  a is JSString; // LINT, checking that a JS value is a different JS interop\n                 // type\n  o is JSNumber; // LINT, checking that a JS value is a different JS interop\n                 // type\n  lo is List<String>; // LINT, JS interop type argument and Dart type argument\n                      // are incompatible\n  ls is List<JSString>; // LINT, Dart type argument and JS interop type argument\n                        // are incompatible\n  lo is List<JSArray>; // LINT, comparing JS interop type argument with\n                       // different JS interop type argument\n  lo is List<JSNumber>; // LINT, comparing JS interop type argument with\n                        // different JS interop type argument\n  o is HTMLElement; // LINT, true because both are JSObjects but doesn't check\n                    // that it's a JS HTMLElement\n  e is HTMLDivElement; // LINT, true because both are JSObjects but doesn't\n                       // check that it's a JS HTMLDivElement\n}\n```\n\nPrefer using JS interop helpers like `isA` from `dart:js_interop` to check the\nunderlying type of JS interop values.\n\n**GOOD:**\n```


验教训，继续有计划有组织地发动作家深入生活，学习马克思列宁主义，学习政府和党的政策，学习社会主义现实主义的文学理论和苏联的文学创作经验；我们必须通过创作组的方法，展开作家之间关于创作研究的互相竞赛，互相帮助，鼓励各种文学形式、体裁与风格的多样性的发展。

   我们必须使得我们的批评工作走上健全发展的道路。在加强批评工作的领导时，应当注意克服主观主义的、片面性的批评，应当从研究和分析具体作品来帮助作家，从创作实践和批评中发展社会主义现实主义的原则。

   二、应当从思想与方法上加强指导文学普及工作。必须以最大努力培养青年作家，加强对于青年和初学写作者的指导，传播成熟的经验。特别要注意从工农干部中培养出新作家，并注意推进各兄弟民族的文学运动。

   三、用马克思列宁主义的观点和方法，批判地接受中国的和世界的古典文学遗产。整理和研究古代及近代的中国文学，发扬中国民族文化的优秀传统。促进国际的文化合作，加强国际间的文化交流，积极参加保卫世界和平和进步文化的伟大斗争。

   这就是作家协会的任务，也就是我们大家共同奋斗的目标。

   新的作家协会，必须是充满朝气的，紧张工作的作家的团体；必须是认真地负责地领导文学创作与批评活动的团体。

   新的作家协会有责任领导我们为完成上述任务而作最大的努力，而作家协会全体会员同志也应当把完成上述任务看作自己的责任。

   代表同志们：伟大的毛泽东时代给了我们各尽所长、自由发展、为人民服务、为祖国效力的最好的条件。我们生活在伟大的社会主义改造的历史时期。在我们面前，是社会主义社会的美丽的远景。在共产党的领导之下，在共产主义思想教育之下，我们有信心完成光荣的任务。我国的文艺潜力是无限量的，我们的队伍在一天一天地壮大，我们每天每天在增加着健康的新鲜的血液。让我们为中国的社会主义现实主义文学的成长壮大而奋斗，让我们为新中国文学的辉煌灿烂的前途而努力罢！

   来源：1953年10月10日《人民日报》。

    [返回索引页面]

   Copyright (C)  2024  Marxist-Leninist-Maoist.

   Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version publi


r1)
/* 804FF914 004FAE54  7C 08 03 A6 */	mtlr r0
/* 804FF918 004FAE58  38 21 00 10 */	addi r1, r1, 0x10
/* 804FF91C 004FAE5C  4E 80 00 20 */	blr

.global func_804FF920
func_804FF920:
/* 804FF920 004FAE60  94 21 FF E0 */	stwu r1, -0x20(r1)
/* 804FF924 004FAE64  7C 08 02 A6 */	mflr r0
/* 804FF928 004FAE68  90 01 00 24 */	stw r0, 0x24(r1)
/* 804FF92C 004FAE6C  39 61 00 20 */	addi r11, r1, 0x20
/* 804FF930 004FAE70  48 01 7C 01 */	bl _savegpr_27
/* 804FF934 004FAE74  7C 7B 1B 78 */	mr r27, r3
/* 804FF938 004FAE78  7C 9C 23 78 */	mr r28, r4
/* 804FF93C 004FAE7C  7C BD 2B 78 */	mr r29, r5
/* 804FF940 004FAE80  7C DE 33 78 */	mr r30, r6
/* 804FF944 004FAE84  7C FF 3B 78 */	mr r31, r7
/* 804FF948 004FAE88  38 60 00 02 */	li r3, 2
/* 804FF94C 004FAE8C  4B FE A6 09 */	bl func_804E9F54
/* 804FF950 004FAE90  2C 03 00 00 */	cmpwi r3, 0
/* 804FF954 004FAE94  40 82 00 0C */	bne lbl_804FF960
/* 804FF958 004FAE98  38 60 00 00 */	li r3, 0
/* 804FF95C 004FAE9C  48 00 00 6C */	b lbl_804FF9C8
lbl_804FF960:
/* 804FF960 004FAEA0  38 00 00 0C */	li r0, 0xc
/* 804FF964 004FAEA4  38 A0 00 00 */	li r5, 0
/* 804FF968 004FAEA8  B0 03 00 02 */	sth r0, 2(r3)
/* 804FF96C 004FAEAC  38 80 00 03 */	li r4, 3
/* 804FF970 004FAEB0  38 00 00 04 */	li r0, 4
/* 804FF974 004FAEB4  39 00 00 09 */	li r8, 9
/* 804FF978 004FAEB8  B0 A3 00 04 */	sth r5, 4(r3)
/* 804FF97C 004FAEBC  7F 67 46 70 */	srawi r7, r27, 8
/* 804FF980 004FAEC0  57 86 C6 3E */	rlwinm r6, r28, 0x18, 0x18, 0x1f
/* 804FF984 004FAEC4  88 BD 00 02 */	lbz r5, 2(r29)
/* 804FF988 004FAEC8  98 83 00 08 */	stb r4, 8(r3)
/* 804FF98C 004FAECC  88 9D 00 01 */	lbz r4, 1(r29)
/* 804FF990 004FAED0  98 03 00 09 */	stb r0, 9(r3)
/* 804FF994 004FAED4  88 1D 00 00 */	lbz r0, 0(r29)
/* 804FF998 004FAED8  99 03 00 0A */	stb r8, 0xa(r3)
/* 804FF99C


[data-v-97981f08]{width:calc(2.5625rem * var(--misc-rate));height:calc(2.5625rem * var(--misc-rate));background-position:calc(-13.9375rem * var(--misc-rate)) calc(-3.125rem * var(--misc-rate))}.spirit_misc-select_false[data-v-97981f08]{width:calc(2.5rem * var(--misc-rate));height:calc(2.5rem * var(--misc-rate));background-position:calc(-11.4375rem * var(--misc-rate)) calc(-7.5rem * var(--misc-rate))}.spirit_misc-select_true[data-v-97981f08]{width:calc(2.5rem * var(--misc-rate));height:calc(2.5rem * var(--misc-rate));background-position:calc(-13.9375rem * var(--misc-rate)) calc(-8.25rem * var(--misc-rate))}.spirit_misc-mark[data-v-97981f08]{width:calc(7.5rem * var(--misc-rate));height:calc(.8125rem * var(--misc-rate));background-position:calc(-3.9375rem * var(--misc-rate)) calc(-10.5rem * var(--misc-rate))}.spirit_misc-soldier[data-v-97981f08]{width:calc(9.25rem * var(--misc-rate));height:calc(7.5rem * var(--misc-rate));background-position:0 0}.spirit_btn-info[data-v-97981f08],.spirit_btn-warning[data-v-97981f08],.spirit_btn-error[data-v-97981f08]{width:calc(14rem * var(--btn-rate));height:calc(3.5rem * var(--btn-rate));background-image:url(https://lengyibai.github.io/wzry-material/image/btn.png);background-size:calc(14rem * var(--btn-rate)) calc(10.5rem * var(--btn-rate))}.spirit_btn-info[data-v-97981f08]{background-position:0 0}.spirit_btn-warning[data-v-97981f08]{background-position:0 calc(-3.5rem * var(--btn-rate))}.spirit_btn-error[data-v-97981f08]{background-position:0 calc(-7rem * var(--btn-rate))}.spirit_white-logo-1[data-v-97981f08],.spirit_white-logo-2[data-v-97981f08],.spirit_white-logo-3[data-v-97981f08],.spirit_white-logo-4[data-v-97981f08]{width:calc(31.25rem * var(--white-logo-rate));height:calc(29.0625rem * var(--white-logo-rate));background-image:url(https://lengyibai.github.io/wzry-material/image/white_logo.png);background-size:calc(62.5rem * var(--white-logo-rate)) calc(58.125rem * var(--white-logo-rate))}.spirit_white-logo-1[data-v-97981f08]{background-position:0 0}.spirit_white-logo-2[data-v-97981f08]{background-position:calc(-31.25rem * var(--white-logo-rate)) 0}.spirit_white-logo-3[data-v-97981f08]{background-position:0 calc(-29.0625rem * var(--white-logo-rate))}.spirit_white-logo-4[data-v-97981f08]{background-position:calc(-31.25rem * var(--white-logo-rate)) calc(-29.0625rem * var(--white-logo-rate))}.mouth[data-v-97981f08]{--rate: 1;position:relative;display:-webkit-box


lters.udp.dns_filter.v3.DnsFilterConfig.ClientContextConfig
	3, // 2: envoy.extensions.filters.udp.dns_filter.v3.DnsFilterConfig.ServerContextConfig.inline_dns_table:type_name -> envoy.data.dns.v3.DnsTable
	4, // 3: envoy.extensions.filters.udp.dns_filter.v3.DnsFilterConfig.ServerContextConfig.external_dns_table:type_name -> envoy.config.core.v3.DataSource
	5, // 4: envoy.extensions.filters.udp.dns_filter.v3.DnsFilterConfig.ClientContextConfig.resolver_timeout:type_name -> google.protobuf.Duration
	6, // 5: envoy.extensions.filters.udp.dns_filter.v3.DnsFilterConfig.ClientContextConfig.upstream_resolvers:type_name -> envoy.config.core.v3.Address
	7, // 6: envoy.extensions.filters.udp.dns_filter.v3.DnsFilterConfig.ClientContextConfig.dns_resolution_config:type_name -> envoy.config.core.v3.DnsResolutionConfig
	8, // 7: envoy.extensions.filters.udp.dns_filter.v3.DnsFilterConfig.ClientContextConfig.typed_dns_resolver_config:type_name -> envoy.config.core.v3.TypedExtensionConfig
	8, // [8:8] is the sub-list for method output_type
	8, // [8:8] is the sub-list for method input_type
	8, // [8:8] is the sub-list for extension type_name
	8, // [8:8] is the sub-list for extension extendee
	0, // [0:8] is the sub-list for field type_name
}

func init() { file_envoy_extensions_filters_udp_dns_filter_v3_dns_filter_proto_init() }
func file_envoy_extensions_filters_udp_dns_filter_v3_dns_filter_proto_init() {
	if File_envoy_extensions_filters_udp_dns_filter_v3_dns_filter_proto != nil {
		return
	}
	if !protoimpl.UnsafeEnabled {
		file_envoy_extensions_filters_udp_dns_filter_v3_dns_filter_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*DnsFilterConfig); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_envoy_extensions_filters_udp_dns_filter_v3_dns_filter_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*DnsFilterConfig_ServerContextConfig); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_envoy_extensions_filters_udp_dns_filter_v3_dns_filter_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*DnsFilterConfig_ClientContextConfig); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
	}
	file_envoy


rl, out _, out _, out _);

        public bool TryExtractGitlabDataFromRemoteUrl(
            string remoteUrl,
            [NotNullWhen(returnValue: true)] out string? host,
            [NotNullWhen(returnValue: true)] out string? owner,
            [NotNullWhen(returnValue: true)] out string? repository)
        {
            host = null;
            owner = null;
            repository = null;

            Match m = MatchRegExes(remoteUrl, _gitLabRegexes);

            if (m is null || !m.Success)
            {
                return false;
            }

            host = m.Groups["host"].Value;
            owner = m.Groups["owner"].Value;
            repository = m.Groups["repo"].Value.Replace(".git", "");
            return true;
        }
    }
}


process enable innovative companies to focus their resources on technological innovation, instead of legal fees, but allowing the USPTO to administer IPR and ex parte proceedings is entirely consistent with the US Constitution.

While we await a decision in Oil States, expect to see Cloudflare initiate IPR and ex parte proceedings against Blackbird Technologies patents in the coming months.

We will make sure to keep you updated.

11 min read

In today’s world, technology is quickly evolving and some practices that were once considered the gold standard are quickly becoming outdated. At Cloudflare, we stay close to industry changes to ensure that we can provide the best solutions to our customers. One practice that we’re continuing to see in use that no longer serves its original purpose is certificate pinning. In this post, we’ll dive into certificate pinning, the consequences of using it in today’s Public Key Infrastructure (PKI) world, and alternatives to pinning that offer the same level of security without the management overhead.

PKI exists to help issue and manage TLS certificates, which are vital to keeping the Internet secure – they ensure that users access the correct applications or servers and that data between two parties stays encrypted. The mis-issuance of a certificate can pose great risk. For example, if a malicious party is able to issue a TLS certificate for your bank’s website, then they can potentially impersonate your bank and intercept that traffic to get access to your bank account. To prevent a mis-issued certificate from intercepting traffic, the server can give a certificate to the client and say “only trust connections if you see this certificate and drop any responses that present a different certificate” – this practice is called certificate pinning.

In the early 2000s, it was common for banks and other organizations that handle sensitive data to pin certificates to clients. However, over the last 20 years, TLS certificate issuance has evolved and changed, and new solutions have been developed to help customers achieve the security benefit they receive through certificate pinning, with simpler management, and without the risk of disruption.

Cloudflare’s mission is to help build a better Internet, which is why our teams are always focused on keeping domains secure and online.

Why certificate pinning is causing more outages now than it did before

			<svg width="16" height="16" viewBox="0 0 24 24">
				<path fill="currentcolor" d="m12.11 15.39-3.88 3.88a2.52 2.52 0 0 1-3.5 0 2.47 2.47 0 0 1 0-3.5l3.88-3.88a1 1 0 0 0-1.42-1.42l-3.88 3.89a4.48 4.48 0 0 0 6.33 6.33l3.89-3.88a1 1 0 1 0-1.42-1.42Zm8.58-12.08a4.49


16_IX_AI, move_16_ix_ai),
        op_entry!(MASK_OUT_Y, OP_MOVE_16_AW_AI, move_16_aw_ai),
        op_entry!(MASK_OUT_Y, OP_MOVE_16_AL_AI, move_16_al_ai),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_DN_PI, move_16_dn_pi),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_AI_PI, move_16_ai_pi),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_PI_PI, move_16_pi_pi),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_PD_PI, move_16_pd_pi),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_DI_PI, move_16_di_pi),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_IX_PI, move_16_ix_pi),
        op_entry!(MASK_OUT_Y, OP_MOVE_16_AW_PI, move_16_aw_pi),
        op_entry!(MASK_OUT_Y, OP_MOVE_16_AL_PI, move_16_al_pi),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_DN_PD, move_16_dn_pd),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_AI_PD, move_16_ai_pd),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_PI_PD, move_16_pi_pd),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_PD_PD, move_16_pd_pd),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_DI_PD, move_16_di_pd),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_IX_PD, move_16_ix_pd),
        op_entry!(MASK_OUT_Y, OP_MOVE_16_AW_PD, move_16_aw_pd),
        op_entry!(MASK_OUT_Y, OP_MOVE_16_AL_PD, move_16_al_pd),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_DN_DI, move_16_dn_di),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_AI_DI, move_16_ai_di),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_PI_DI, move_16_pi_di),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_PD_DI, move_16_pd_di),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_DI_DI, move_16_di_di),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_IX_DI, move_16_ix_di),
        op_entry!(MASK_OUT_Y, OP_MOVE_16_AW_DI, move_16_aw_di),
        op_entry!(MASK_OUT_Y, OP_MOVE_16_AL_DI, move_16_al_di),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_DN_IX, move_16_dn_ix),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_AI_IX, move_16_ai_ix),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_PI_IX, move_16_pi_ix),
        op_entry!(MASK_OUT_X_Y, OP_MOVE_16_PD_IX, move_16_pd_ix),
        op_entry!(MASK_OUT_X


 add those to [fromSkeyApps]
        // reason: we might need those terms for storage path parsing in the context of storage comparison
        //  (they're also added to terms of interest, either one-by-one, or from_skey as a whole)
        skeyConstructors.forEach { e ->
            e.args.forEach { arg ->
                fromSkeyApps.add(
                    lxf {
                        applyExp(AxiomatizedFunctionSymbol.SKeyDt.FromSkey(Tag.Bit256), arg) as LExpression.ApplyExpr
                    }
                )
            }
        }

        // to_skey and from_skey are inverses of each other
        BijectionAxiomHelper.axiomatizeFunctionsAsInverses(
            axiomContainer,
            lxf,
            AxiomatizedFunctionSymbol.SKeyDt.ToSkey(Tag.Int),
            toSkeyApps.map { it.args },
            AxiomatizedFunctionSymbol.SKeyDt.FromSkey(Tag.Int),
            fromSkeyApps.map { it.args },
        )

        // from_skey should be in bv256 bounds
        // should be generalized in TODO CERT-1791
        skeyConstructors.forEach { app ->
            axiomContainer.addAxioms(
                "0 <= from_skey(x) && from_skey(x) <= max_uintVMBW" to {
                    (litInt(0) le applyExp(AxiomatizedFunctionSymbol.SKeyDt.FromSkey(Tag.Bit256), app)) and
                        (applyExp(AxiomatizedFunctionSymbol.SKeyDt.FromSkey(Tag.Bit256), app) le litInt(MAX_EVM_UINT256))
                }
            )
        }

        // x <= max_solidity_slot => to_skey(x) = basic(x)
        // also: to_skey never maps to `nil` -- (`nil` by itself is unused by us)
        toSkeyApps.forEach { app ->
            val arg = app.args.single()
            axiomContainer.addAxioms(
                "x <= max_solidity_slot => to_skey(x) = basic(x)" to {
                    (arg le maxSoliditySlotLExp) implies
                            (applyExp(AxiomatizedFunctionSymbol.SKeyDt.ToSkey(arg.tag), arg) eq basicSkey(arg))
                },
            )
        }

        // x > max_solidity_slot && <x does not equal one of the a large literals> => (not (is (to_skey x) 'basic')))
        // using the define-fun pattern, since we need to list all largeConstantsInCode here, which might lead to much
        // duplication
        // note that it's not sound to just filter for arg !in largeConstants in code here, because the program
        // might force some identifier that appears under `to_skey` to be equal to one of these constants
        //  --> thus we have to make this big conjunction in the antecedent
        toSkeyNonBasic.addAllToContainer(axiomContainer, toSkeyApps.map { it.args.single() })

        fromSkeyVsBasic.addAllToContainer(axiomContainer, fromSkeyApps.map { it.args.single() })

        // (from_skey (skey_add <skey> <offset>)) = (+ (from_skey <skey>) <offset>)))
        skeyAdditions.forEach { skeyAdd ->
            val (skey, offset) = skeyAdd.args
            axiomContainer.addAxioms(
                "(from_skey (skey_add <skey> <offset>)) = (+ (from_skey <skey>) <offset>)))" to {
                    (applyExp(AxiomatizedFunctionSymbol.SKeyDt.FromSkey(Tag.Bit256), skeyAdd)) eq
                            (applyExp(AxiomatizedFunctionSymbol.SKeyDt.FromSkey(Tag.Bit256), skey) intAdd offset)
                },
            )
        }

        // toSkey(<largeConstantInCode>) = basic(<largeConstantInCode>)
        largeConstantsInCode.forEach { c ->
            axiomContainer.addAxioms(
                "toSkey(<largeConstantInCode>)


<E> addAll(E[] elements, int offset, int length);

	@Override
	public XIncreasingEnum<E> addAll(XGettingCollection<? extends E> elements);

	@SuppressWarnings("unchecked")
	@Override
	public XIncreasingEnum<E> putAll(E... elements);

	@Override
	public XIncreasingEnum<E> putAll(E[] elements, int offset, int length);

	@Override
	public XIncreasingEnum<E> putAll(XGettingCollection<? extends E> elements);

	@SuppressWarnings("unchecked")
	@Override
	public XIncreasingEnum<E> prependAll(E... elements);

	@Override
	public XIncreasingEnum<E> prependAll(E[] elements, int offset, int length);

	@Override
	public XIncreasingEnum<E> prependAll(XGettingCollection<? extends E> elements);

	@SuppressWarnings("unchecked")
	@Override
	public XIncreasingEnum<E> preputAll(E... elements);

	@Override
	public XIncreasingEnum<E> preputAll(E[] elements, int offset, int length);

	@Override
	public XIncreasingEnum<E> preputAll(XGettingCollection<? extends E> elements);

	@Override
	public XIncreasingEnum<E> swap(long indexA, long indexB);

	@Override
	public XIncreasingEnum<E> swap(long indexA, long indexB, long length);

	@Override
	public XIncreasingEnum<E> copy();

	@Override
	public XIncreasingEnum<E> toReversed();
	@Override
	public XIncreasingEnum<E> reverse();

	@Override
	public XIncreasingEnum<E> range(long fromIndex, long toIndex);

	@Override
	public XIncreasingEnum<E> sort(Comparator<? super E> comparator);

}
package org.eclipse.serializer.collections.types;

/*-
 * #%L
 * Eclipse Serializer Base
 * %%
 * Copyright (C) 2023 MicroStream Software
 * %%
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 * #L%
 */

import java.util.function.Consumer;

public interface XGettingEnum<E> extends XGettingSet<E>, XGettingSequence<E>
{
	public interface Creator<E> extends XGettingSet.Creator<E>, XGettingSequence.Factory<E>
	{
		@Override
		public XGettingEnum<E> newInstance();
	}

	///////////////////////////////////////////////////////////////////////////
	// override methods //
	/////////////////////

	/**
	 * {@inheritDoc}
	 */
	@Override
	public XImmutableEnum<E> immure();

	@Override
	public XGettingEnum<E> copy();

	@Override
	public XGettingEnum<E> toReversed();

	@Override
	public XGettingEnum<E> view();

	@Override
	public XGettingEnum<E> view(long lowIndex, long highIndex);

	@Override
	public XGettingEnum<E> range(long lowIndex, long highIndex);

	@Override
	public <P extends Consumer<? super E>> P iterate(P procedure);

}
package org.eclipse.serializer.collections.types;

/*-
 * #%L
 * Eclipse Serializer Base
 * %%
 * Copyright (C) 2023 MicroStream Software
 * %%
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 * #L%
 */

import org.eclipse.serializer.functional.Aggregator;

/**
 * A collection is the root type for all collections (level 0 collection type).
 *
 * @param <E> type of contained elements
 */
public interface XCollection<E> extends XPutGetCollection<E


main.features.impl.dungeon.dungeonwaypoints.DungeonWaypoints.glList
import me.odinmain.features.impl.dungeon.dungeonwaypoints.DungeonWaypoints.setWaypoints
import me.odinmain.features.impl.dungeon.dungeonwaypoints.SecretWaypoints.resetSecrets
import me.odinmain.utils.isHexaDecimal
import me.odinmain.utils.render.Color
import me.odinmain.utils.skyblock.dungeon.DungeonUtils
import me.odinmain.utils.skyblock.modMessage
import me.odinmain.utils.writeToClipboard
import net.minecraft.client.gui.GuiScreen
import net.minecraft.util.BlockPos

val dungeonWaypointsCommand = Commodore("dwp", "dungeonwaypoints") {
    runs {
        DungeonWaypoints.onKeybind()
    }

    literal("edit").runs {
        DungeonWaypoints.onKeybind()
    }

    literal("fill").runs {
        DungeonWaypoints.filled = !DungeonWaypoints.filled
        modMessage("Fill status changed to: ${DungeonWaypoints.filled}")
    }

    literal("size").runs { size: Double ->
        if (size !in 0.1..1.0) return@runs modMessage("§cSize must be between 0.1 and 1.0!")
        DungeonWaypoints.size = size
        modMessage("Size changed to: ${DungeonWaypoints.size}")
    }

    literal("distance").runs { reach: Int ->
        DungeonWaypoints.distance = reach.toDouble()
    }

    literal("resetsecrets").runs {
        resetSecrets()
        modMessage("§aSecrets have been reset!")
    }

    literal("type").runs { type: String ->
        DungeonWaypoints.WaypointType.getByName(type)?.let {
            DungeonWaypoints.waypointType = it.ordinal
            modMessage("Waypoint type changed to: ${it.displayName}")
        } ?: modMessage("§cInvalid waypoint type!")
    }

    literal("timer").runs { type: String ->
        DungeonWaypoints.TimerType.getByName(type)?.let {
            DungeonWaypoints.timerSetting = it.ordinal
            modMessage("Waypoint timer type changed to: ${it.displayName}")
        } ?: modMessage("§cInvalid timer type!")
    }

    literal("useblocksize").runs {
        DungeonWaypoints.useBlockSize = !DungeonWaypoints.useBlockSize
        modMessage("Use block size status changed to: ${DungeonWaypoints.useBlockSize}")
    }

    literal("offset").runs { x: Double, y: Double, z: Double ->
        DungeonWaypoints.offset = BlockPos(x, y, z)
        modMessage("Next waypoint will be added with an offset of: ${DungeonWaypoints.offset}")
    }

    literal("through").runs {
        DungeonWaypoints.throughWalls = !DungeonWaypoints.throughWalls
        modMessage("Next waypoint will be added with through walls: ${DungeonWaypoints.throughWalls}")
    }

    literal("color").runs { hex: String ->
        if (hex.length != 8 || hex.any { !it.isHexaDecimal }) return@runs modMessage("Color hex not properly formatted! Use format RRGGBBAA")
        DungeonWaypoints.color = Color(hex)
        modMessage("Color changed to: $hex")
    }

    literal("export").runs {
        scope.launch {
            writeToClipboard(encodeWaypoints() ?: return@launch modMessage("Failed to write waypoint config to clipboard."))
            modMessage("Wrote waypoint config to clipboard.")
        }
    }

    literal("import").runs {
        scope.launch {
            val base64Data = GuiScreen.getCl


// Wild Magic Source Code
// David Eberly
// http://www.geometrictools.com
// Copyright (c) 1998-2007
//
// This library is free software; you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation; either version 2.1 of the License, or (at
// your option) any later version.  The license is available for reading at
// either of the locations:
//     http://www.gnu.org/copyleft/lgpl.html
//     http://www.geometrictools.com/License/WildMagicLicense.pdf
// The license applies to versions 0 through 4 of Wild Magic.
//
// Version: 4.0.0 (2006/06/28)

#ifndef WM4QUERY3_H
#define WM4QUERY3_H

#include "Wm4FoundationLIB.h"
#include "Wm4Query.h"
#include "Wm4Vector3.h"

namespace Wm4
{

template <class Real>
class Query3 : public Query
{
public:
    // The base class handles floating-point queries.
    Query3 (int iVQuantity, const Vector3<Real>* akVertex);
    virtual ~Query3 ();

    // run-time type information
    virtual Query::Type GetType () const;

    // member access
    int GetQuantity () const;
    const Vector3<Real>* GetVertices () const;

    // Queries about the relation of a point to various geometric objects.

    // returns
    //   +1, on positive side of plane
    //   -1, on negative side of line
    //    0, on the plane
    virtual int ToPlane (int i, int iV0, int iV1, int iV2) const;
    virtual int ToPlane (const Vector3<Real>& rkP, int iV0, int iV1, int iV2)
        const;

    // returns
    //   +1, outside tetrahedron
    //   -1, inside tetrahedron
    //    0, on tetrahedron
    virtual int ToTetrahedron (int i, int iV0, int iV1, int iV2, int iV3)
        const;
    virtual int ToTetrahedron (const Vector3<Real>& rkP, int iV0, int iV1,
        int iV2, int iV3) const;

    // returns
    //   +1, outside circumsphere of tetrahedron
    //   -1, inside circumsphere of tetrahedron
    //    0, on circumsphere of tetrahedron
    virtual int ToCircumsphere (int i, int iV0, int iV1, int iV2, int iV3)
        const;
    virtual int ToCircumsphere (const Vector3<Real>& rkP, int iV0, int iV1,
        int iV2, int iV3) const;

protected:
    // input points
    int m_iVQuantity;
    const Vector3<Real>* m_akVertex;

    static Real Dot (Real fX0, Real fY0, Real fZ0, Real fX1, Real fY1,
        Real fZ1);

    static Real Det3 (Real fX0, Real fY0, Real fZ0, Real fX1, Real fY1,
        Real fZ1, Real fX2, Real fY2, Real fZ2);

    static Real Det4 (Real fX0, Real fY0, Real fZ0, Real fW0, Real fX1,
        Real fY1, Real fZ1, Real fW1, Real fX2, Real fY2, Real fZ2, Real fW2,
        Real fX3, Real fY3, Real fZ3, Real fW3);
};

}

#include "Wm4Query3.inl"

namespace Wm4
{
typedef Query3<float> Query3f;
typedef Query3<double> Query3d;

}

#endif


 - non assault point targeted in assault point chain" );
		}
		ap = static_cast<rvCTF_AssaultPoint*>(ap->toStrogg.GetEntity());
		ap->index = assignIndices++;

		ptr = ap;
		gameLocal.mpGame.assaultPoints.Append( ptr );

		if ( !ap->linked ) {
			ap->Event_InitializeLinks();
		}

		if( !ap->toStrogg ) {
			gameLocal.Error( "rvCTF_AssaultPoint::ResetIndices() - break in assault point chain" );
		}
	}
}

/*
================
rvCTF_AssaultPoint::Event_Activate
================
*/
void rvCTF_AssaultPoint::Event_Touch( idEntity *activator, trace_t *trace ) {
	if( !activator->IsType( idPlayer::GetClassType() ) || ((gameLocal.mpGame.GetGameState())->GetMPGameState() != GAMEON && !cvarSystem->GetCVarBool( "g_testCTF" )) ) {
		return;
	}

	idPlayer* player = static_cast<idPlayer*>(activator);
	int oldOwner = owner;

	if ( owner == player->team )
		return;

	int enemyPowerup = -1;
	int friendlyPowerup = -1;

	if ( owner == TEAM_MARINE ) {
		friendlyPowerup = POWERUP_CTF_STROGGFLAG;
		enemyPowerup = POWERUP_CTF_MARINEFLAG;
	} else if ( owner == TEAM_STROGG ) {
		friendlyPowerup = POWERUP_CTF_MARINEFLAG;
		enemyPowerup = POWERUP_CTF_STROGGFLAG;
	} else {
		// neutral assault point
		if ( player->team == TEAM_MARINE ) {
			friendlyPowerup = POWERUP_CTF_MARINEFLAG;
			enemyPowerup = POWERUP_CTF_STROGGFLAG;
		} else {
			friendlyPowerup = POWERUP_CTF_STROGGFLAG;
			enemyPowerup = POWERUP_CTF_MARINEFLAG;
		}
	}

	if ( !player->PowerUpActive ( enemyPowerup ) ) {
		return;
	}

	switch( player->team ) {
		case TEAM_MARINE: {
			if( !toMarine || owner == TEAM_MARINE ) {
				break;
			}

			if( toMarine->IsType( rvItemCTFFlag::GetClassType() ) ) {
				owner = TEAM_MARINE;
				gameLocal.Printf("Assault point %s captured by marines!\n", name.c_str());
			} else if( toMarine->IsType( rvCTF_AssaultPoint::GetClassType() ) ) {
				if( static_cast<rvCTF_AssaultPoint*>(toMarine.GetEntity())->owner == TEAM_MARINE ) {
					owner = TEAM_MARINE;
					gameLocal.Printf("Assault point %s captured by marines!\n", name.c_str());
				}
			}
			break;
		}
		case TEAM_STROGG: {
			if( !toStrogg || owner == TEAM_STROGG ) {
				break;
			}

			if( toStrogg->IsType( rvItemCTFFlag::GetClassType() ) ) {
				owner = TEAM_STROGG;
				gameLocal.Printf("Assault point %s captured by strogg!\n", name.c_str());
			} else if( toStrogg->IsType( rvCTF_AssaultPoint::GetClassType() ) ) {
				if( static_cast<rvCTF_AssaultPoint*>(toStrogg.GetEntity())->owner == TEAM_STROGG ) {
					owner = TEAM_STROGG;
					gameLocal.Printf("Assault point %s captured by strogg!\n", name.c_str());
				}
			}
			break;
		}
	}

	if( oldOwner != owner ) {
		// we switched hands, reset forward spawns
		gameLocal.ClearForwardSpawns();

		if( oldOwner ==


db: 6
[Parsed_volumedetect_0  0xa23120] histogram_5db: 62
[Parsed_volumedetect_0  0xa23120] histogram_6db: 286
[Parsed_volumedetect_0  0xa23120] histogram_7db: 1042
[Parsed_volumedetect_0  0xa23120] histogram_8db: 2551
[Parsed_volumedetect_0  0xa23120] histogram_9db: 4609
[Parsed_volumedetect_0  0xa23120] histogram_10db: 8409

It means that:

The mean square energy is approximately -27 dB, or 10^-2.7.

The largest sample is at -4 dB, or more precisely between -4 dB and -5 dB.

There are 6 samples at -4 dB, 62 at -5 dB, 286 at -6 dB, etc.

In other words, raising the volume by +4 dB does not cause any clipping,
raising it by +5 dB causes clipping for 6 samples, etc.

30 Audio Sources# TOC

Below is a description of the currently available audio sources.

30.1 abuffer# TOC

Buffer audio frames, and make them available to the filter chain.

This source is mainly intended for a programmatic use, in particular
through the interface defined in <samp class="file">libavfilter/buffersrc.h</samp>.

It accepts the following parameters:

<samp class="option">time_base</samp>

The timebase which will be used for timestamps of submitted frames. It must be
either a floating-point number or in <var class="var">numerator</var>/<var class="var">denominator</var> form.

<samp class="option">sample_rate</samp>

The sample rate of the incoming audio buffers.

<samp class="option">sample_fmt</samp>

The sample format of the incoming audio buffers.
Either a sample format name or its corresponding integer representation from
the enum AVSampleFormat in <samp class="file">libavutil/samplefmt.h</samp>

<samp class="option">channel_layout</samp>

The channel layout of the incoming audio buffers.
Either a channel layout name from channel_layout_map in
<samp class="file">libavutil/channel_layout.c</samp> or its corresponding integer representation
from the AV_CH_LAYOUT_* macros in <samp class="file">libavutil/channel_layout.h</samp>

<samp class="option">channels</samp>

The number of channels of the incoming audio buffers.
If both <var class="var">channels</var> and <var class="var">channel_layout</var> are specified, then they
must be consistent.

30.1.1 Examples<a class="anc


Another action
#}
{#
#}
{#
#}
{#
#}
{#
Something else here
#}
{#
#}
{#
#}
{#                        {% if users %}#}
{#
#}
{#                                我的相册#}
{#
#}
{#
#}
{#                                留言板#}
{#
#}
{#                        {% endif %}#}
{#
#}
{##}
{#                    #}
{#                    <form class="d-flex mx-auto" style="max-width: 300px;" role="search">#}
{#                        <input class="form-control me-2" type="search" placeholder="搜你想搜" aria-label="Search">#}
{#                        <button class="btn btn-outline-success" type="submit" style="white-space: nowrap; min-width: 60px;">#}
{#                            搜索#}
{#                        </button>#}
{#                    </form>#}
{##}
{#                    #}
{#
#}
{#                        {% if users %}#}
{#
#}
{#
#}
{#                                    #}
{#                                        您好, {{ users.username }}#}
{#                                    #}
{#
#}
{#
编辑
#}
{#
设置
#}
{#
#}
{#
#}
{#
#}
{#
退出
#}
{#
#}
{#
#}
{#
#}
{#                        {% else %}#}
{#
#}
{#
#}
{#                                    登录#}
{#
#}
{#
#}
{#                        {% endif %}#}
{#
#}
{#
#}
{#
#}
{#        </


turn Success(msg="视频删除成功")
    except Exception as e:
        logger.error(f"删除视频失败: {str(e)}")
        return Fail(msg=f"删除视频失败: {str(e)}")

@video_router.post("/parse-video", summary="解析视频链接", dependencies=[DependPermisson])
async def parse_video_url(
    video_url: str = Query(..., description="视频链接")
):
    """解析视频链接，获取视频信息"""
    logger.info(f"=== 收到视频解析请求 ===")
    logger.info(f"请求的视频链接: {video_url}")
    logger.info(f"视频链接类型: {type(video_url)}")
    logger.info(f"视频链接长度: {len(video_url) if video_url else 0}")

    try:
        logger.info(f"开始调用video_parser.parse_video_url...")
        video_info = video_parser.parse_video_url(video_url)
        logger.info(f"视频解析成功，返回数据: {video_info}")
        return Success(data=video_info)
    except Exception as e:
        logger.error(f"解析视频链接失败: {str(e)}")
        logger.error(f"异常类型: {type(e)}")
        import traceback
        logger.error(f"异常堆栈: {traceback.format_exc()}")
        return Fail(msg=f"解析视频链接失败: {str(e)}")


. CURRENT selects the active browser. ALL closes all browsers. When a browser id is provided, that browser is closed.	\n
\n
\n
Returns a list of dictionaries containing id, errors and console messages from the page.
\n
Example
\n
\nClose Page                                       # Closes current page, within the current context and browser\nClose Page    CURRENT     CURRENT     CURRENT    # Closes current page, within the current context and browser\nClose Page    ALL         ALL         ALL        # Closes all pages, within all contexts and browsers\n
\n
Comment >>
", "shortdoc": "Closes the ``page`` in ``context`` in ``browser``.", "tags": ["BrowserControl", "Setter"], "source": "/Users/tatuaalto/workspace/robotframework-playwright/Browser/keywords/playwright_state.py", "lineno": 236}, {"name": "Connect To Browser", "args": [{"name": "wsEndpoint", "type": {"name": "str", "typedoc": "string", "nested": [], "union": false}, "types": ["str"], "typedocs": {"str": "string"}, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "wsEndpoint: str"}, {"name": "browser", "type": {"name": "SupportedBrowsers", "typedoc": "SupportedBrowsers", "nested": [], "union": false}, "types": ["SupportedBrowsers"], "typedocs": {"SupportedBrowsers": "SupportedBrowsers"}, "defaultValue": "chromium", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "browser: SupportedBrowsers = chromium"}], "doc": "
Connect to a playwright Browser.
\n
See Browser, Context and Page for more information about Browser and related concepts.
\n
Returns a stable identifier for the connected browser.
\n
\n
\nArgument	\nDescription	\n
\n
\nwsEndpoint	\nAddress to connect to.	\n
\n
\nbrowser	\nOpens the specified browser. Defaults to chromium.	\n
\n
\n
Comment >>
", "shortdoc": "Connect to a playwright Browser.", "tags": ["BrowserControl", "Setter"], "source": "/Users/tatuaalto/workspace/robotframework-playwright/Browser/keywords/playwright_state.py", "lineno": 319}, {"name": "Crawl Site", "args": [{"name": "url", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "types": ["str", "None"], "typedocs": {"str": "string", "None": "None"}, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "url: str | None = None"}, {"name": "page_crawl_keyword", "type": null, "types": [], "typedocs": {}, "defaultValue": "take_screenshot", "kind": "POSITIONAL_OR_NAM


31748 -6.25512,-0.96 -5.15906,-1.04693 -11.50111,-2.985829 -14.94426,-5.355594 l -0.0718,-0.04536 a 11.346149,11.346149 0 0 1 -0.51024,-0.385512 c -0.0605,-0.04535 -0.12472,-0.09071 -0.17764,-0.136063 a 8.0730761,8.0730761 0 0 1 -0.56693,-0.506457 37.587426,37.587426 0 0 1 -2.19212,-2.392442 39.96853,39.96853 0 0 1 -5.00032,-7.445675 c -0.26457,-0.529134 -0.51402,-1.054488 -0.73701,-1.579843 -0.89575,-2.097639 -1.40976,-4.146144 -1.41732,-5.888508 0,-1.307717 0.24189,-2.418899 0.8126,-3.401577 0.18897,-0.328819 0.41574,-0.64252 0.68409,-0.944882 0.1663,-0.188977 0.34016,-0.370394 0.52158,-0.536694 0.0378,-0.03779 0.0756,-0.06425 0.11338,-0.09449 a 7.9710288,7.9710288 0 0 1 1.73859,-1.171654 c 1.36063,-0.672756 2.97071,-1.012914 4.74331,-1.058269 z m -31.21136,9.274967 a 1.9842532,1.9842532 0 0 0 -1.92378,2.044725 c 0.0756,2.381104 -0.40441,3.77953 -0.96,4.42205 -0.5556,0.638741 -1.32284,0.963781 -3.099219,0.767245 a 1.9842532,1.9842532 0 0 0 -2.188348,1.753702 1.9842532,1.9842532 0 0 0 1.753702,2.192127 c 2.562521,0.279686 5.000315,-0.351496 6.531025,-2.116536 1.53449,-1.768821 2.01449,-4.221735 1.92756,-7.135753 a 1.9842532,1.9842532 0 0 0 -2.04094,-1.92756 z" class="class1" style="fill:%2397c0ff;fill-opacity:1;stroke-width:3.77953;stroke-linecap:round;stroke-linejoin:round" id="path1" /></g></svg>');
}
.empty-state-container::before {
  content: var(--tab-img);
}/*Styling*/
.empty-state-container {
  transition: transform 0.3s ease-in-out, box-shadow 0.3s ease-in-out;
}
.empty-state-container:hover {
  transform:scale(1.03);
}
.empty-state-title, .empty-state-action:nth-child(3), .empty-state-action.mod-close {
  display: none;
}
.empty-state-container {
  max-width: max-content;
}
.empty-state-action {
  background-color: var(--text-selection);
  padding: 0px 10px;
  border-radius: 7px;
}
.empty-state-action:nth-child(1), .empty-state-action:nth-child(2) {
  margin-bottom: 10px;
}

/*Loading screen*/
.progress-bar-message::before {
  content: "✨ ";
}

/*Vault icon*/
.workspace-drawer-vault-name::af


						token = Token.LITERAL2;
						lastOffset = lastKeyword = i;
					}
					break;
				case ':':
					if(lastKeyword == offset)
					{
						if(doKeyword(line,i,c))
							break;
						backslash = false;
						addToken(i1 - lastOffset,Token.LABEL);
						lastOffset = lastKeyword = i1;
					}
					else if(doKeyword(line,i,c))
						break;
					break;
				case '/':
					backslash = false;
					doKeyword(line,i,c);
					if(length - i > 1)
					{
						switch(array[i1])
						{
						case '*':
							addToken(i - lastOffset,token);
							lastOffset = lastKeyword = i;
							if(length - i > 2 && array[i+2] == '*')
								token = Token.COMMENT2;
							else
								token = Token.COMMENT1;
							break;
						case '/':
							addToken(i - lastOffset,token);
							addToken(length - i,Token.COMMENT1);
							lastOffset = lastKeyword = length;
							break loop;
						}
					}
					break;
				default:
					backslash = false;
					if(!Character.isLetterOrDigit(c)
						&& c != '_')
						doKeyword(line,i,c);
					break;
				}
				break;
			case Token.COMMENT1:
			case Token.COMMENT2:
				backslash = false;
				if(c == '*' && length - i > 1)
				{
					if(array[i1] == '/')
					{
						i++;
						addToken((i+1) - lastOffset,token);
						token = Token.NULL;
						lastOffset = lastKeyword = i+1;
					}
				}
				break;
			case Token.LITERAL1:
				if(backslash)
					backslash = false;
				else if(c == '"')
				{
					addToken(i1 - lastOffset,token);
					token = Token.NULL;
					lastOffset = lastKeyword = i1;
				}
				break;
			case Token.LITERAL2:
				if(backslash)
					backslash = false;
				else if(c == '\'')
				{
					addToken(i1 - lastOffset,Token.LITERAL1);
					token = Token.NULL;
					lastOffset = lastKeyword = i1;
				}
				break;
			default:
				throw new InternalError("Invalid state: "
					+ token);
			}
		}

		if(token == Token.NULL)
			doKeyword(line,length,'\0');

		switch(token)
		{
		case Token.LITERAL1:
		case Token.LITERAL2:
			addToken(length - lastOffset,Token.INVALID);
			token = Token.NULL;
			break;
		case Token.KEYWORD2:
			addToken(length - lastOffset,token);
			if(!backslash)
				token = Token.NULL;
		default:
			addToken(length - lastOffset,token);
			break;
		}

		return token;
	}

	public static KeywordMap getKeywords()
	{
		if(cKeywords == null)
		{
			cKeywords = new KeywordMap(false);
			cKeywords.add("char",Token.KEYWORD3);
			cKeywords.add("double",Token.KEYWORD3);
			cKeywords.add("enum",Token.KEYWORD3);
			cKeywords.add("float",Token.KEYWORD3);
			cKeywords.add("int",Token.KEYWORD3);
			cKeywords.add("long",Token.KEYWORD3);
			cKeywords.add("short",Token.KEYWORD3);
			cKeywords.add("signed",Token.KEYWORD3);
			cKeywords.add("struct",Token.KEYWORD3);
			cKeywords.add("typedef",Token.KEYWORD3);
			cKeywords.add("union",Token.KEYWORD3);
			cKeywords.add("unsigned",Token.KEYWORD3);
			cKeywords.add("void",Token.KEYWORD3);
			cKeywords.add("auto",Token.KEYWORD1);
			cKeywords.add("const",Token.KEYWORD


ies_list = modalities.split('\\');
      const validMode = ['CT', 'PT'].every(modality => modalities_list.includes(modality));
      return validMode;
    },
    /*
    ...
    */
  }
}
```
---
sidebar_position: 4
sidebar_label: Pub Sub
title: Publish-Subscribe Pattern
summary: Documentation of the publish-subscribe pattern implementation in OHIF, which enables event-based communication between services, allowing components to subscribe to events and receive updates when they occur, reducing direct dependencies between modules.
---

# Pub sub

## Overview

Publish–subscribe pattern is a messaging pattern that is one of the fundamentals
patterns used in reusable software components.

In short, services that implement this pattern, can have listeners subscribed
to their broadcasted events. After the event is fired, the corresponding
listener will execute the function that is registered.

You can read more about this design pattern
[here](https://cloud.google.com/pubsub/docs/overview).

## Example: Default Initialization

In `Mode.jsx` we have a default initialization that demonstrates a series of
subscriptions to various events.

```js
async function defaultRouteInit({
  servicesManager,
  studyInstanceUIDs,
  dataSource,
}) {
  const {
    DisplaySetService,
    HangingProtocolService,
  } = servicesManager.services;

  const unsubscriptions = [];

  const {
    unsubscribe: instanceAddedUnsubscribe,
  } = DicomMetadataStore.subscribe(
    DicomMetadataStore.EVENTS.INSTANCES_ADDED,
    ({ StudyInstanceUID, SeriesInstanceUID, madeInClient = false }) => {
      const seriesMetadata = DicomMetadataStore.getSeries(
        StudyInstanceUID,
        SeriesInstanceUID
      );

      DisplaySetService.makeDisplaySets(seriesMetadata.instances, madeInClient);
    }
  );

  unsubscriptions.push(instanceAddedUnsubscribe);

  studyInstanceUIDs.forEach(StudyInstanceUID => {
    dataSource.retrieve.series.metadata({ StudyInstanceUID });
  });

  const { unsubscribe: seriesAddedUnsubscribe } = DicomMetadataStore.subscribe(
    DicomMetadataStore.EVENTS.SERIES_ADDED,
    ({ StudyInstanceUID }) => {
      HangingProtocolService.run({studies, displaySets, activeStudy});
    }
  );
  unsubscriptions.push(seriesAddedUnsubscribe);

  return unsubscriptions;
}
```

## Unsubscription

You need to be careful if you are adding custom subscriptions to the app. Each
subscription will return an unsubscription function that needs to be executed on
component destruction to avoid adding multiple subscriptions to the same
observer.

Below, we can see `simplified` `Mode.jsx` and the corresponding `useEffect`
where the unsubscription functions are executed upon destruction.

```js title="platform/app/src/routes/Mode/Mode.jsx"
export default function ModeRoute(/**..**/) {
  /**...**/
  useEffect(() => {
    /**...**/

    DisplaySetService.init(extensionManager, sopClassHandlers);

    extensionManager.onModeEnter();
    mode?.onModeEnter({ servicesManager, extensionManager });

    const setupRouteInit = async () => {
      if (route.init) {
        return await route.init(/**...**/);
      }

      return await defaultRouteInit(/**...**/);
    };

    let unsubscriptions;
    setupRouteInit().then(unsubs => {
      unsubscriptions = unsubs;
    });

    return () => {
      extensionManager.onModeExit();
      mode?.onModeExit({ servicesManager, extensionManager });
      unsubscriptions.forEach(unsub => {
        unsub();
      });
    };
  });
  return <> /**...**/ </>;
}
```
---
sidebar_position: 1
sidebar_


o carino**!」 (이거 너무 귀여워!) / (한국어) '아이고!' -> (이탈리아어) 「Oh mamma mia!」 또는 「Accidenti!」

* **7.3. 감정 표현의 직접성/간접성 조절:**
    * **강화 전략:** 이탈리아 문화에서는 감정을 비교적 직접적으로 표현하는 경향이 있습니다. 한국어 원문이 완곡하게 표현된 경우, 이탈리아 독자들이 자연스럽게 이해할 수 있도록 직접성을 높여 번역할 수 있습니다. 단, 상황과 캐릭터의 관계(예: 공식적인 자리)에 따라 예의를 갖춘 표현을 유지하는 것이 중요합니다. 이탈리아어에서는 비언어적 제스처가 언어적 표현과 함께 중요한 의미를 전달하므로, 이를 암시하는 문맥을 살립니다.
    * **예시:** "정말 화가 났다!" → 「Sono **davvero arrabbiato**!」 (나는 **정말 화가 났다!** - 직접적 표현) 또는 「Mi ha fatto **veramente infuriare**。」 (그것은 나를 **정말로 격분하게 했다** - 좀 더 강조된 표현)

* **7.4. 'Tu'와 'Lei'의 적절한 사용:**
    * **강화 전략:** 이탈리아어는 'tu' (친칭, 단수)와 'Lei' (존칭, 단수/복수)의 구분이 명확하고, 이는 관계, 상황, 사회적 계층을 나타내는 중요한 요소입니다. 번역 시 원문의 관계성(친밀도, 권위, 거리감)을 정확히 파악하여 적절한 대명사를 선택합니다. 잘못 사용하면 오역을 넘어 문화적 실례가 될 수 있습니다. 이는 이탈리아 사회에서 매우 중요하게 여겨지는 부분입니다.

## 8. 최종 결과물 형식 (이탈리아 시장 최적화)

번역 결과는 명확하고 가독성이 높은 형태로 제공됩니다.

* **번역문:** 이탈리아어로 번역된 콘텐츠를 명확하게 제시합니다.
* **역번역 및 설명 (필요시):** 원


Name());
					stream.writeTextElement("uuid", getUuid());
					stream.writeTextElement("absolute", isRelative() ? "0" : "1");
					if (!isRelative())
					{
						stream.writeTextElement("minValue", QString::number(m_absoluteMinValue, 'g', 12));
						stream.writeTextElement("range", QString::number(m_absoluteRange, 'g', 12));
					}
				}
				stream.writeEndElement(); // Properties

				// Data
				stream.writeStartElement(s_xmlColorScaleData);
				{
					// write each step
					{
						for (QList<ccColorScaleElement>::const_iterator it = m_steps.begin(); it != m_steps.end(); ++it)
						{
							stream.writeStartElement("step");
							{
								const ccColorScaleElement& elem        = *it;
								const QColor&              color       = elem.getColor();
								double                     relativePos = elem.getRelativePos();

								stream.writeAttribute("r", QString::number(color.red()));
								stream.writeAttribute("g", QString::number(color.green()));
								stream.writeAttribute("b", QString::number(color.blue()));
								stream.writeAttribute("pos", QString::number(relativePos, 'g', 12));
							}
							stream.writeEndElement(); // step
						}
					}

					// write custom labels as well (if any)
					{
						for (LabelSet::const_iterator it = m_customLabels.begin(); it != m_customLabels.end(); ++it)
						{
							stream.writeStartElement("label");
							{
								stream.writeAttribute("val", QString::number(it->value, 'g', 12));
								if (!it->text.isEmpty())
								{
									stream.writeAttribute("text", it->text);
								}
							}
							stream.writeEndElement(); // label
						}
					}
				}
				stream.writeEndElement(); // Data
			}
			stream.writeEndElement(); // ColorScale
		}
		stream.writeEndElement(); // CloudCompare
	}
	stream.writeEndDocument();

	return true;
}

ccColorScale::Shared ccColorScale::LoadFromXML(const QString& filename)
{
	QFile file(filename);
	if (!file.open(QFile::ReadOnly | QFile::Text))
	{
		ccLog::Error(QString("Failed to open file '%1' for reading!").arg(filename));
		return Shared(nullptr);
	}

	Shared scale(nullptr);

	// read content
	QXmlStreamReader stream(&file);
	bool             error = true;
	while (true) // fake loop for easy break
	{
		// expected: CloudCompare
		if (!stream.readNextStartElement()
		    || stream.name() != s_xmlCloudCompare)
		{
			break;
		}

		// expected: ColorScale
		if (!stream.readNextStartElement()
		    || stream.name() != s_xmlColorScaleTitle)
		{
			break;
		}

		// read version number
		QXmlStreamAttributes attributes = stream.attributes();
		if (attributes.size() == 0 || attributes[0].name() != "version")
		{
			break;
		}
		bool ok      = false;
		int  version = attributes[0].value().toString().toInt(&ok);
		if (!ok || version > s_xmlColorScaleVer)
		{
			if (ok)
				ccLog::Warning(QString("[ccColorScale::LoadFromXML] Unhandled version: %1").arg(version));
			break;
		}

		// expected: Properties
		if (!stream.readNextStartElement()
		    || stream.name() != s_xmlColorScaleProperties)
		{
			break;
		}

		// we can now create the scale structure
		scale = Shared(new ccColorScale("temp"));

		// read elements
		int missingItems = 3;
		while (!stream.atEnd() && missingItems > 0)
		{
			if (!stream.readNextStartElemen


 bdUseInf.setFrstRegisterId(boardMaster.getFrstRegisterId());
	    bdUseInf.setUseAt("Y");

	    bbsUseDAO.insertBBSUseInf(bdUseInf);

	    UserInfVO userVO = new UserInfVO();
	    userVO.setTrgetId(boardMaster.getTrgetId());

	    List<UserInfVO> tmpList = null;
	    Iterator<UserInfVO> iter = null;

	    if ("REGC05".equals(boardMaster.getRegistSeCode())) {
		tmpList = userService.selectAllClubUser(userVO);
		iter = tmpList.iterator();
		while (iter.hasNext()) {
		    bdUseInf = new BoardUseInf();

		    bdUseInf.setBbsId(bbsId);
		    bdUseInf.setTrgetId(((UserInfVO)iter.next()).getUniqId());
		    bdUseInf.setRegistSeCode("REGC07");
		    bdUseInf.setUseAt("Y");
		    bdUseInf.setFrstRegisterId(boardMaster.getFrstRegisterId());

		    bbsUseDAO.insertBBSUseInf(bdUseInf);
		}
	    } else if ("REGC06".equals(boardMaster.getRegistSeCode())) {
		tmpList = userService.selectAllCmmntyUser(userVO);
		iter = tmpList.iterator();
		while (iter.hasNext()) {
		    bdUseInf = new BoardUseInf();

		    bdUseInf.setBbsId(bbsId);
		    bdUseInf.setTrgetId(((UserInfVO)iter.next()).getUniqId());
		    bdUseInf.setRegistSeCode("REGC07");
		    bdUseInf.setUseAt("Y");
		    bdUseInf.setFrstRegisterId(boardMaster.getFrstRegisterId());

		    bbsUseDAO.insertBBSUseInf(bdUseInf);
		}
	    }
	}
	return bbsId;
    }

    /**
     * 게시판 속성 정보의 목록을 조회 한다.
     *
     * @see egovframework.let.cop.bbs.brd.service.EgovBBSAttributeManageService#selectAllBBSMasteInf(egovframework.let.cop.bbs.brd.service.BoardMasterVO)
     */
    public List<BoardMasterVO> selectAllBBSMasteInf(BoardMasterVO vo) throws Exception {
	return attrbMngDAO.selectAllBBSMasteInf(vo);
    }

    /**
     * 게시판 속성정보 한 건을 상세조회한다.
     *
     * @see egovframework.let.cop.bbs.brd.service.EgovBBSAttributeManageService#selectBBSMasterInf(egovframework.let.cop.bbs.brd.service.BoardMasterVO)
     */
    public BoardMasterVO selectBBSMasterInf(BoardMaster searchVO) throws Exception {
	//---------------------------------
	// 2009.06.26 : 2단계 기능 추가
	//---------------------------------
	//return attrbMngDAO.selectBBSMasterInf(searchVO);

	BoardMasterVO result = attrbMngDAO.selectBBSMasterInf(searchVO);

	String flag = propertyService.getString("Globals.addedOptions");
	if (flag != null && flag.trim().equalsIgnoreCase("true")) {
	    BoardMasterVO options = addedOptionsDAO.selectAddedOptionsInf(searchVO);

	    if (options != null) {
		if (options.getCommentAt().equals("Y")) {
		    result.setOption("comment");
		}

		if (options.getStsfdgAt().equals("Y")) {
		    result.setOption("stsfdg");
		}
	    } else {
		result.setOption("na");	// 미지정 상태로 수정 가능 (이미 지정된 경우는 수정 불가


: {
      mode: 'interpolate',
      intersect: false
    },
    plugins: {
      crosshair: {
        line: {
          color: '#F66',  // crosshair line color
          width: 1        // crosshair line width
        },
        sync: {
          enabled: true,            // enable trace line syncing with other charts
          group: 1,                 // chart group
          suppressTooltips: false   // suppress tooltips when showing a synced tracer
        },
        zoom: {
          enabled: true,                                      // enable zooming
          zoomboxBackgroundColor: 'rgba(66,133,244,0.2)',     // background color of zoom box
          zoomboxBorderColor: '#48F',                         // border color of zoom box
          zoomButtonText: 'Reset Zoom',                       // reset zoom button text
          zoomButtonClass: 'reset-zoom',                      // reset zoom button class
        },
        callbacks: {
          beforeZoom(start, end) {                  // called before zoom, return false to prevent zoom
            return true;
          },
          afterZoom(start, end) {                   // called after zoom
          }
        }
      }
    }
  }
});

// samples from: https://github.com/AbelHeinsbroek/chartjs-plugin-crosshair/blob/master/samples/basic.html
function generateDataset(shift: number, label: string, color: string): Chart.ChartDataSets {
  const data: Chart.ChartPoint[] = [];
  let x = 0;
  while (x < 30) {
    data.push({ x, y: Math.sin(shift + x / 3) });
    x += Math.random();
  }
  const dataset: Chart.ChartDataSets = {
    backgroundColor: color,
    borderColor: color,
    showLine: true,
    fill: false,
    pointRadius: 2,
    label,
    data,
    lineTension: 0,
    interpolate: true
  };
  return dataset;
}

const chart1 = new Chart(ctx, {
  type: "scatter",
  options: {
    plugins: {
      crosshair: {
        sync: {
          enabled: false
        }
      }
    },

    tooltips: {
      mode: "interpolate",
      intersect: false,
    }
  },
  data: {
    datasets: [
      generateDataset(0, "A", "red"),
      generateDataset(1, "B", "green"),
      generateDataset(2, "C", "blue")
    ]
  }
});

const chart2 = new Chart(ctx, {
  type: "scatter",
  options: {
    tooltips: {
      mode: "interpolate",
      intersect: false,
    }
  },
  data: {
    datasets: [generateDataset(0, "A", "red")]
  }
});

const chart3 = new Chart(ctx, {
  type: "scatter",
  options: {
    tooltips: {
      mode: "interpolate",
      intersect: false,
    }
  },
  data: {
    datasets: [generateDataset(1, "B", "green")]
  }
});
const chart4 = new Chart(ctx, {
  type: "scatter",
  options: {
    tooltips: {
      mode: "interpolate",
      intersect: false,
    }
  },
  data: {
    datasets: [generateDataset(1, "C", "blue")]
  }
});

const chart5 = new Chart(ctx, {
  type: "scatter",
  options: {
    plugins: {
      crosshair: {
        sync: {
          enabled: false
        },
      }
    },
    tooltips: {
      mode: "interpolate",
      intersect: false,
    },
    animation: {
      duration: 0
    },

    responsiveAnimationDuration: 0
  },
  data: {
    datasets: [
      generateDataset(0, "A", "red"),
      generateDataset(1, "B", "green"),
      generateDataset(2, "C", "blue")
    ]
  }
});

const panZoom = (e: KeyboardEvent) => {
  if (e.keyCode === 37) {
    chart5.panZoom(-5);
  } else if (e.keyCode === 39) {
    chart5.panZoom(5);
  }
};
import axios from 'axios';
import { Actions, } from './store';
import { ITrip } from './../../../server


(err, "error deleting RoleBinding for mesh ServiceAccount", "RoleBinding", roleBindingName)
			allErrors = append(allErrors, err)
		}
	}

	// if there were errors, we've logged them and there's not really anything we can do, as we're in an uncertain state
	// maybe a following reconcile will add the required role binding that failed.  if it was a delete that failed, we're
	// just leaving behind some cruft.
	return utilerrors.NewAggregate(allErrors)
}

// Removes the labels that the pruner uses to determine which objects to prune.
// These labels need to be removed when copying objects from the mesh namespace
// to the member namespace if those objects are managed by the member controller
// and should thus never be deleted by the pruner.
func removeLabelsUsedByPruner(obj metav1.Object) {
	common.DeleteLabel(obj, common.OwnerKey)
	common.DeleteLabel(obj, common.OwnerNameKey)
	common.DeleteLabel(obj, common.KubernetesAppVersionKey)
}

func (r *namespaceReconciler) addNetworkAttachmentDefinition(ctx context.Context, namespace string, netAttachDefName string) error {
	log := common.LogFromContext(ctx)
	nadList := &multusv1.NetworkAttachmentDefinitionList{}
	if err := r.Client.List(ctx, nadList, client.InNamespace(namespace), client.MatchingLabels{common.MemberOfKey: r.meshNamespace}); err != nil {
		if meta.IsNoMatchError(err) {
			log.Info("skipping creation of NetworkAttachmentDefinition, because this cluster doesn't support them")
			return nil
		}
		return pkgerrors.Wrapf(err, "could not list NetworkAttachmentDefinition resources in member namespace %s", namespace)
	}

	found := false
	var allErrors []error
	for _, nad := range nadList.Items {
		if nad.GetName() == netAttachDefName {
			found = true
		} else if err := r.Client.Delete(ctx, &nad, client.PropagationPolicy(metav1.DeletePropagationOrphan)); err != nil && !apierrors.IsNotFound(err) {
			allErrors = append(allErrors, err)
		}
	}
	if found {
		// TODO: update resource if its state isn't what we want
		return utilerrors.NewAggregate(allErrors)
	}

	log.Info("creating NetworkAttachmentDefinition", "NetworkAttachmentDefinition", netAttachDefName)
	netAttachDef := &multusv1.NetworkAttachmentDefinition{}
	netAttachDef.SetNamespace(namespace)
	netAttachDef.SetName(netAttachDefName)
	common.SetLabel(netAttachDef, common.MemberOfKey, r.meshNamespace)
	if err := r.Client.Create(ctx, netAttachDef); err != nil {
		allErrors = append(allErrors, pkgerrors.Wrapf(err, "could not create NetworkAttachmentDefinition %s/%s", namespace, netAttachDefName))
	}
	return utilerrors.NewAggregate(allErrors)
}

func (r *namespaceReconciler) removeNetworkAttachmentDefinition(ctx context.Context, namespace string) error {
	log := common.LogFromContext(ctx)
	nadList := &multusv1.NetworkAttachmentDefinitionList{}
	if err := r.Client.List(ctx, nadList, client.InNamespace(namespace), client.MatchingLabels{common.MemberOfKey: r.meshNamespace}); err != nil {
		if meta.IsNoMatc


 work.
		 */
		it ('shouldn\'t be possible to use read parameter with directive', () => {

			// given
			const fixture = TestBed.createComponent(TestComponent),
				compInstance = fixture.componentInstance;

			// when
			fixture.detectChanges();

			// then
			let dirAsElementRefs = compInstance.dirAsElementRefs.toArray();
			expect(dirAsElementRefs.length).toEqual(0);
			expect(dirAsElementRefs[0] instanceof ElementRef).toBe(false, 'directiveRef as ElementRef'); // FALSE

			let dirAsTempRefs = compInstance.dirAsTempRefs.toArray();
			expect(dirAsTempRefs.length).toEqual(0);
			expect(dirAsTempRefs[0] instanceof TemplateRef).toBe(false, 'directiveRef as TemplateRef'); // FALSE

			let dirAsVcrs = compInstance.dirAsVcrs.toArray();
			expect(dirAsVcrs.length).toEqual(0);
			expect(isViewContainerRef(dirAsVcrs[0])).toBe(false, 'directiveRef as ViewContainerRef'); // FALSE
		});

		/**
		 * @ViewChildren allows to get reference to a directive by template variable
		 */
		it ('should be possible to get reference by template variable', () => {
			// given
			const fixture = TestBed.createComponent(TestComponent),
				compInstance = fixture.componentInstance;

			// when
			fixture.detectChanges();

			// then
			let dirByTemplVarRefs = compInstance.dirByTemplVarRefs.toArray();
			expect(dirByTemplVarRefs.length).toEqual(1);
			expect(dirByTemplVarRefs[0].value).toEqual('#1');
			expect(dirByTemplVarRefs[0] instanceof PropDirective).toBe(true, 'directiveRef as directiveRef'); // TRUE
		});

	});

	/**
	 * @ViewChildren allows to get different types when referencing a template
	 */
	describe ('read ng-template -', () => {

		@Component({
			selector: 'test',
			template: `

				<ng-template #templOne >
				</ng-template>

				<ng-template #templTwo >
				</ng-template>

			`
		})
		class TestComponent {
			/**
			 * ng-template references
			 */
			@ViewChildren(TemplateRef)
			templRefs: QueryList<TemplateRef<any>>;

			/**
			 * ng-template references as ElementRefs
			 */
			@ViewChildren(TemplateRef, {read: ElementRef})
			templAsElementRefs: QueryList<ElementRef>;

			/**
			 * ng-template references as ComponentRefs
			 */
			@ViewChildren(TemplateRef, {read: SimpleComponent})
			templAsCompRefs: QueryList<SimpleComponent>;

			/**
			 * ng-template references as ViewContainerRef
			 */
			@ViewChildren(TemplateRef, {read: ViewContainerRef})
			templAsVcrs: QueryList<ViewContainerRef>;

			/**
			 * ng-template references by template variable
			 */
			@ViewChildren('templOne')
			templByTemplVarRefs: QueryList<SimpleComponent>;
		}

		beforeEach(() => {
			TestBed.configureTestingModule({
				declarations: [
					SimpleComponent,
					TestComponent
				]
			});
		});

		it ('should get template references as different objects', () => {

			// given
			const fixture = TestBed.createComponent(TestComponent),
				compInstance = fixture.componentInstance;

			// when
			fixture.detectChanges();

			// then
			let templRefs = compInstance.templRefs.toArray();
			expect(templRefs.length).toEqual(2);
			expect(templRefs[0] instanceof TemplateRef).toBe(true, 'TemplateRef as TemplateRef'); // TRUE

			let templAsElementRefs = compInstance.templAsElementRefs.toArray();
			expect(templAsElementRefs.length).toEqual(2);
			e


                [(B // self.node_num) * keep_node * self.node_list[i]] + self.node_list[(i + 1):] + [L, C])
            cross_tmp = cross_expand.view(
                [(B // self.node_num) * keep_node * self.node_list[i]] + self.node_list[(i + 1):] + [S, C])
            # reduce node for multi-scales
            for j in range(len(self.node_list) - i - 1):
                x_tmp = torch.mean(x_tmp, dim=1)
                cross_tmp = torch.mean(cross_tmp, dim=1)
            # x_tmp: B*keep_node*node_list[i], L, C; cross_tmp: B*keep_node*node_list[i], S, C
            # multi-correlation in a certain layer
            x_tmp = \
                self.cross_correlation(x_tmp, cross_tmp, cross_tmp, attn_mask=mask,
                                       n_nodes=self.node_list[i])[0] \
                    .unsqueeze(1).repeat(1, reduce_node, 1, 1)  # x_tmp: B*keep_node*node_list[i], reduce_node, L, C
            x_intermedia.append(x_tmp.view([B // self.node_num] + self.node_list + [L, C]))
        x_intermedia = torch.mean(torch.stack(x_intermedia, dim=0), dim=0).view(B, L, C)
        res = self.dropout(x_leaf) + self.dropout(x_intermedia)
        return res


	Vector target = parentMatrix.WorldToLocal( vecWorldTarget );

	float quadTarget = target.LengthSqr();
	float quadTargetXY = target.x*target.x + target.y*target.y;

	// Target is too close!  Can't aim at it
	if ( quadTarget > m_vecBarrelPos.LengthSqr() )
	{
		// We're trying to aim the offset barrel at an arbitrary point.
		// To calculate this, I think of the target as being on a sphere with
		// it's center at the origin of the gun.
		// The rotation we need is the opposite of the rotation that moves the target
		// along the surface of that sphere to intersect with the gun's shooting direction
		// To calculate that rotation, we simply calculate the intersection of the ray
		// coming out of the barrel with the target sphere (that's the new target position)
		// and use atan2() to get angles

		// angles from target pos to center
		float targetToCenterYaw = atan2( target.y, target.x );
		float centerToGunYaw = atan2( m_vecBarrelPos.y, sqrt( quadTarget - (m_vecBarrelPos.y*m_vecBarrelPos.y) ) );

		float targetToCenterPitch = atan2( target.z, sqrt( quadTargetXY ) );
		float centerToGunPitch = atan2( -m_vecBarrelPos.z, sqrt( quadTarget - (m_vecBarrelPos.z*m_vecBarrelPos.z) ) );

		QAngle angles;
		angles.Init( -RAD2DEG(targetToCenterPitch+centerToGunPitch), RAD2DEG( targetToCenterYaw + centerToGunYaw ), 0 );

		SetPoseParameter( "vehicle_weapon_yaw", angles.y );
		SetPoseParameter( "vehicle_weapon_pitch", angles.x );
		StudioFrameAdvance();

		float curPitch = GetPoseParameter( "vehicle_weapon_pitch" );
		float curYaw = GetPoseParameter( "vehicle_weapon_yaw" );
		m_bInFiringCone = (fabs(curPitch - angles.x) < 1e-3) && (fabs(curYaw - angles.y) < 1e-3);
	}
	else
	{
		m_bInFiringCone = false;
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CPropAPC::GetTracerType( void )
{
	return "HelicopterTracer";
}

//-----------------------------------------------------------------------------
// Allows the shooter to change the impact effect of his bullets
//-----------------------------------------------------------------------------
void CPropAPC::DoImpactEffect( trace_t &tr, int nDamageType )
{
	UTIL_ImpactTrace( &tr, nDamageType, "HelicopterImpact" );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropAPC::DoMuzzleFlash( void )
{
	CEffectData data;
	data.m_nEntIndex = entindex();
	data.m_nAttachmentIndex = m_nMachineGunMuzzleAttachment;
	data.m_flScale = 1.0f;
	DispatchEffect( "ChopperMuzzleFlash", data );

	BaseClass::DoMuzzleFlash();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropAPC::FireMachineGun( void )
{
	if ( m_flMachineGunTime > gpGlobals->curtime )
		return;

	// If we're still firing the salvo, fire quickly
	m_iMachineGunBurstLeft--;
	if ( m_iMachineGunBurstLeft > 0 )
	{
		m_flMachineGunTime = gpGlobals->curtime + MACHINE_GUN_BURST_TIME;
	}
	else
	{
		// Reload the salvo
		m_iMachineGunBurstLeft = MACHINE


�民的选托.我门时CE的快名时国让农R自己E选择当吃店还受引导我门的农村发展就会有一个面的局面。

爱更实电听听农民的意见，首星空民是不电自器的。有不的地方：我相信农民不完全是自觉自愿的：基次.定省出来的地是连的，很多地方是不明地的：民的土地整理出来：的省出来的一地定是5的EE多78 它直按变为国家的工 第三.省出来的土地指标如集主控市政业设，去搞房地产，去整开发区，这个上地实的铁是维的有生地方业不明地，就为定压府的.这个能应黄是农民的.因为地地大心的。

从长远来香我直具力：农专生展量大的资动是土地.日品士地现在在装种程度上来讲可以说证记江畔的进本、厅五理的动本就电此牌的设SEE 儿睡大觉呢.加同有些基屋干部计：士地有巨大的一产开值的游力现在都计制这一点下。有人话过去政府就是展农民观单.皮话. 现套达电地,5常3 迫：发门门1公店我认为农村这会大的一个建设用地

现在费城乡绝筹.书&城务洗等不能悦尔式心司光居产动日农民的地就到就里来。现在经营

## 农民增收应与市民同步

据”“被上模于当前国家的农村政策好，一般 H五国A的家爱能中E白L2 加上打工成其地多种经营收人.就可以装得： 超出退管井体面的生活术平、中国社科院近用一项开究正示人成受访空民工表示不品批帝农社户口器

判定农民收人是香增加及幅空如间,令人信国的比较应设在表民同市民之间进行。

在日益深化的社全发展中.应使大多教空民能在证防员我到己时出租亚得当地县域：水平的平均收人。日本，韩中的农户明于工程价医：固是国事络中高新补助.共收人一般高于城市普通工薪媒座：所以王确的比较，应设在普通农户同当哈城业中的中等收人者空间进行。、增农民收人.星小城多收人差距.应性大多教农民收入紧盯城市中等家庭的衣人。

土地流转的本意是希望士地能向


//deadends
            case "DontRemoveDeadEnds":
                return builder.DontRemoveDeadEnds();
            case "WithSmallChanceToRemoveDeadEnds":
                return builder.WithSmallChanceToRemoveDeadEnds();
            case "WithMediumChanceToRemoveDeadEnds":
                return builder.WithMediumChanceToRemoveDeadEnds();
            case "WithBigChanceToRemoveDeadEnds":
                return builder.WithBigChanceToRemoveDeadEnds();
            case "RemoveAllDeadEnds":
                return builder.RemoveAllDeadEnds();
            //room size
            case "WithSmallSizeRooms":


1, d2, d3, d4;

  static Pointer<CGFloat32x4> callocPointer(
          double d1, double d2, double d3, double d4) =>
      calloc<CGFloat32x4>()
        ..ref.d1 = d1
        ..ref.d2 = d2
        ..ref.d3 = d3
        ..ref.d4 = d4;
}

class CGFloat64x4 extends Struct {
  @Double()
  external double d1, d2, d3, d4;

  static Pointer<CGFloat64x4> callocPointer(
          double d1, double d2, double d3, double d4) =>
      calloc<CGFloat64x4>()
        ..ref.d1 = d1
        ..ref.d2 = d2
        ..ref.d3 = d3
        ..ref.d4 = d4;
}

abstract class CGFloatx4Wrapper extends NativeStruct {
  late Pointer<CGFloat32x4> _ptr32;
  late Pointer<CGFloat64x4> _ptr64;

  double get d1 => LP64 ? _ptr64.ref.d1 : _ptr32.ref.d1;
  set d1(double d1) {
    if (LP64) {
      _ptr64.ref.d1 = d1;
    } else {
      _ptr32.ref.d1 = d1;
    }
  }

  double get d2 => LP64 ? _ptr64.ref.d2 : _ptr32.ref.d2;
  set d2(double d2) {
    if (LP64) {
      _ptr64.ref.d2 = d2;
    } else {
      _ptr32.ref.d2 = d2;
    }
  }

  double get d3 => LP64 ? _ptr64.ref.d3 : _ptr32.ref.d3;
  set d3(double d3) {
    if (LP64) {
      _ptr64.ref.d3 = d3;
    } else {
      _ptr32.ref.d3 = d3;
    }
  }

  double get d4 => LP64 ? _ptr64.ref.d4 : _ptr32.ref.d4;
  set d4(double d4) {
    if (LP64) {
      _ptr64.ref.d4 = d4;
    } else {
      _ptr32.ref.d4 = d4;
    }
  }

  CGFloatx4Wrapper(double d1, double d2, double d3, double d4) {
    if (LP64) {
      _ptr64 = CGFloat64x4.callocPointer(d1, d2, d3, d4);
    } else {
      _ptr32 = CGFloat32x4.callocPointer(d1, d2, d3, d4);
    }
  }

  @override
  Pointer get addressOf => LP64 ? _ptr64 : _ptr32;

  CGFloatx4Wrapper.fromPointer(Pointer<Void> ptr) {
    if (LP64) {
      _ptr64 = ptr.cast();
    } else {
      _ptr32 = ptr.cast();
    }
    wrapper;
  }

  @override
  bool operator ==(other) {
    if (other is CGFloatx4Wrapper) {
      return d1 == other.d1 &&
          d2 == other.d2 &&
          d3 == other.d3 &&
          d4 == other.d4;
    }
    return false;
  }

  @override
  int get hashCode => d1.hashCode ^ d2.hashCode ^ d3.hashCode ^ d4.hashCode;

  @override
  String toString() {
    return '$runtimeType=($d1, $d2, $d3, $d4)';
  }
}

class CGFloat32x6 extends Struct {
  @Float()


using System.Collections.Generic;
using System.Linq;

using Raven.Yabt.Database.Infrastructure;
using Raven.Yabt.Database.Models.BacklogItems;
using Raven.Yabt.Domain.CustomFieldServices.Query.DTOs;
using Raven.Yabt.Domain.Helpers;

namespace Raven.Yabt.Domain.BacklogItemServices.ByIdQuery.DTOs;

/// <summary>
///		Adapter design pattern in mapping DTOs instead of AutoMapper to enforce strong type checks (see more https://gigi.nullneuron.net/gigilabs/the-adapter-design-pattern-for-dtos-in-c/, https://cezarypiatek.github.io/post/why-i-dont-use-automapper/)
/// </summary>
internal static class ConversionExtensions
{
	public static TResponse ConvertToDto<TEntity, TResponse>(this TEntity entity, List<BacklogItemCustomFieldValue>? customFieldValues)
		where TEntity : BacklogItem
		where TResponse : BacklogItemGetResponseBase, new()
	{
		var response = new TResponse
			{
				Title = entity.Title,
				State = entity.State,
				EstimatedSize = entity.EstimatedSize,
				Assignee = entity.Assignee is null ? null : (entity.Assignee with {}).RemoveEntityPrefixFromId(),
				HistoryDescOrder = entity.ModifiedBy.OrderByDescending(i => i.Timestamp).ToList(),
				Tags = entity.Tags,
				Comments = GetCommentsList(entity.Comments),
				RelatedItems = entity.RelatedItems.AsReadOnly(),
				CustomFields = customFieldValues?.AsReadOnly(),
				Type = entity.Type
			};

		switch (entity)
		{
			case BacklogItemBug entityBug when response is BugGetResponse responseBug:
				responseBug.Priority = entityBug.Priority;
				responseBug.Severit