m>This function is deprecated and unavailable in the Core profile
     */
    public static void glEdgeFlagPointer(@NativeType("GLsizei") int stride, @NativeType("GLboolean const *") ByteBuffer pointer) {
        nglEdgeFlagPointer(stride, memAddress(pointer));
    }

    /**
     * Specifies the location and organization of an edge flag array.
     *
     * @param stride  the vertex stride in bytes. If specified as zero, then array elements are stored sequentially
     * @param pointer the edge flag array data
     *
     * @see Reference Page - This function is deprecated and unavailable in the Core profile
     */
    public static void glEdgeFlagPointer(@NativeType("GLsizei") int stride, @NativeType("GLboolean const *") long pointer) {
        nglEdgeFlagPointer(stride, pointer);
    }

    // --- [ glEnableClientState ] ---

    /**
     * Enables a client-side capability.
     *
     *
If the {@link NVVertexBufferUnifiedMemory} extension is supported, this function is available even in a core profile context.

     *
     * @param cap the capability to enable. One of:

{@link #GL_COLOR_ARRAY COLOR_ARRAY}	{@link #GL_EDGE_FLAG_ARRAY EDGE_FLAG_ARRAY}	{@link GL15#GL_FOG_COORD_ARRAY FOG_COORD_ARRAY}	{@link #GL_INDEX_ARRAY INDEX_ARRAY}

{@link #GL_NORMAL_ARRAY NORMAL_ARRAY}	{@link GL14#GL_SECONDARY_COLOR_ARRAY SECONDARY_COLOR_ARRAY}	{@link #GL_TEXTURE_COORD_ARRAY TEXTURE_COORD_ARRAY}	{@link #GL_VERTEX_ARRAY VERTEX_ARRAY}

{@link NVVertexBufferUnifiedMemory#GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV VERTEX_ATTRIB_ARRAY_UNIFIED_NV}	{@link NVVertexBufferUnifiedMemory#GL_ELEMENT_ARRAY_UNIFIED_NV ELEMENT_ARRAY_UNIFIED_NV}

     *
     * @see Reference Page - This function is deprecated and unavailable in the Core profile
     */
    public static native void glEnableClientState(@NativeType("GLenum") int cap);

    // --- [ glEnd ] ---

    /**
     * Ends the definition of vertex attributes of a sequence of primitives to be transferred to the GL.
     *
     * @see Reference Page - This function is deprecated and unavailable in the Core profile
     */
    public static native void glEnd();

    // --- [ glEvalCoord1f ] ---

    /**
     * Causes evaluation of the enabled one-dimensional evaluator maps.
     *
     * @param u the domain coordinate u
     *
     * @see Reference Page - This function is deprecated and unavailable in the Core profile
     */
    public static native void glEvalCoord1f(@NativeType("GLfloat") float u);

    // --- [ glEvalCoord1fv ] ---

    /** Unsafe version of: {@link #glEvalCoord1fv EvalCoord1fv} */
    public static native void nglEvalCoord1fv(long u);

    /**
     * Pointer version of {@link #glEvalCoord1f EvalCoord1f}.
     *
     * @param u the domain coordinate buffer
     *
     * @see Reference Page


/../assets/js/prism.min.js"></script>

<meta name="viewport" content="width=device-width, initial-scale=1">

<link rel="apple-touch-icon-precomposed" sizes="144x144" href="../../assets/img/favicon-144.png">
<link rel="apple-touch-icon-precomposed" sizes="114x114" href="../../assets/img/favicon-144.png">
<link rel="apple-touch-icon-precomposed" sizes="72x72" href="../../assets/img/favicon-72.png">
<link rel="apple-touch-icon-precomposed" href="../../assets/img/favicon-32.png">
<link rel="shortcut icon" href="../../assets/img/favicon-32.png">

<link rel="stylesheet" href="../../assets/css/vk.css"/>
<link rel="stylesheet" href="../../assets/css/prism.css"/>

<vk-title>vkGetPhysicalDeviceQueueFamilyProperties | NVK</vk-title>

<vk-centered>

  <vk-navigation>
  <vk-search-title>Search</vk-search-title>
  <vk-search>
    <input type="text" id="search" autocomplete="off" />
    <vk-search-results>

No Results

    </vk-search-results>
  </vk-search>
  <vk-section-title style="margin-top: 1em;">Categories</vk-section-title>
  <vk-categories></vk-categories>
</vk-navigation>

  <vk-struct>

    <vk-name>vkGetPhysicalDeviceQueueFamilyProperties</vk-name>

    <vk-description>Reports properties of the queues of the specified physical device</vk-description>

    <vk-section-title>Syntax</vk-section-title>
    <vk-syntax>

void vkGetPhysicalDeviceQueueFamilyProperties();

    </vk-syntax>

    <vk-section-title>Parameters</vk-section-title>

    <vk-properties>
      <vk-property-entry>
        <vk-property-parameter>physicalDevice</vk-property-parameter>
        <vk-property-type type="object">VkPhysicalDevice</vk-property-type>
        <vk-property-description> is the handle to the physical device whose properties will be queried.</vk-property-description>
      </vk-property-entry>
      <vk-property-entry>
        <vk-property-parameter>pQueueFamilyPropertyCount</vk-property-parameter>
        <vk-property-type type="object">Object.$<vk-property-type type="object">(Number)</vk-property-type></vk-property-type>
        <vk-property-description> is a reference to a number related to the number of queue families available or queried, as described below.</vk-property-description>
      </vk-property-entry>
      <vk-property-entry>
        <vk-property-parameter>pQueueFamilyProperties</vk-property-parameter>
        <vk-property-type type="array">Array<vk-property-type type="object">[VkQueueFamilyProperties]</vk-property-type></vk-property-type>
        <vk-property-description> is either null or a reference to an array of VkQueueFamilyProperties structures.</vk-property-description>
      </vk-property-entry>

    </vk-properties>

  </vk-struct>

</vk-centered>


/*
 * Copyright (c) 2018-2019 Arm Limited.
 *
 * SPDX-License-Identifier: MIT
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#ifndef ARM_COMPUTE_TEST_RANGE_H
#define ARM_COMPUTE_TEST_RANGE_H

#include "tests/SimpleTensor.h"
#include "tests/validation/Helpers.h"

namespace arm_compute
{
namespace test
{
namespace validation
{
namespace reference
{
template <typename T>
SimpleTensor<T> range(SimpleTensor<T> &dst, float start, size_t num_elements, float step);

} // namespace reference
} // namespace validation
} // namespace test
} // namespace arm_compute
#endif /* ARM_COMPUTE_TEST_RANGE_H */


dled SQLite sample "employee" database with tables for employees, departments, salaries, and more.

 Claude Desktop

  Claude Desktop only supports

   stdio

  transport https://github.com/orgs/modelcontextprotocol/discussions/16

// claude_desktop_config.json
{
  "mcpServers": {
    "dbhub-postgres-docker": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "bytebase/dbhub",
        "--transport",
        "stdio",
        "--dsn",
        // Use host.docker.internal as the host if connecting to the local db
        "postgres://user:password@host.docker.internal:5432/dbname?sslmode=disable"
      ]
    },
    "dbhub-postgres-npx": {
      "command": "npx",
      "args": [
        "-y",
        "@bytebase/dbhub",
        "--transport",
        "stdio",
        "--dsn",
        "postgres://user:password@localhost:5432/dbname?sslmode=disable"
      ]
    },
    "dbhub-demo": {
      "command": "npx",
      "args": ["-y", "@bytebase/dbhub", "--transport", "stdio", "--demo"]
    }
  }
}

 Cursor

  Cursor supports both

   stdio

  and

   http

  .

  Follow

   Cursor MCP guide

  and make sure to use

   Agent

  mode.

 Usage

 SSL Connections

 You can specify the SSL mode using the

  sslmode

 parameter in your DSN string:

    Database

     sslmode=disable

     sslmode=require


.Emit(OpCodes.Stloc, expect);

            if (IsStatic)
            {
                il.Emit(OpCodes.Ldsflda, fi);
            }
            else
            {
                if (DeclaringType.IsNonPrimitiveValueType)
                    il.Emit(OpCodes.Unbox, DeclaringType.TypeAsTBD);

                il.Emit(OpCodes.Ldflda, fi);
            }

            il.Emit(OpCodes.Ldloc, expect);
            il.Emit(OpCodes.Ldloc, value);

            if (FieldTypeWrapper == DeclaringType.Context.PrimitiveJavaTypeFactory.LONG)
            {
                il.Emit(OpCodes.Call, DeclaringType.Context.ByteCodeHelperMethods.CompareAndSwapLong);
            }
            else if (FieldTypeWrapper


result.append(warning(text, file=path, line=line, col=m.start() + 1, fix=fix_fun))

    def error_by_regex(pattern: str, text: str, fix: Union[None, str, Callable[[Match[str]], str]] = None) -> None:
        nonlocal result
        m = re.search(pattern, msg)
        if m:
            fix_fun: Optional[Callable[[str], str]] = None
            if fix is not None:
                fix_fun = lambda s: re.subn(pattern, fix, s)[0]  # type: ignore
            result.append(error(text, file=path, line=line, col=m.start() + 1, fix=fix_fun))

    error_by_regex(
        pattern=r'です。|ます。',
        text='日本語: 敬体ではなく常体を使ってください。',
    )
    error_by_regex(
        pattern=r'，|．',
        text="日本語: `，` と `．` ではなく `、` と `。` を使ってください。",
        fix=from_table({
            '，': '、',
            '．': '。',
        }),
    )

    error_by_regex(
        pattern=r'\\\(\|\\\)',
        text=r"KaTeX: inline 表示をしたいときは `\(` や `\)` ではなく `$` を使ってください。`\(` や `\)` は Markdown でのエスケープと解釈されて壊れることがあります。",
        fix='$',
    )
    error_by_regex(
        pattern=r'\\\[\|\\\]',
        text=r"KaTeX: 数式中の角括弧には `\[` と `\]` ではなく `\lbrack` と `\rbrack` を使ってください。文章中の角括弧には `\[` と `\]` ではなく `[` と `]` を使ってください。display 表示をしたいときは `\[` と `\]` ではなく `$$` を使ってください。`\[` や `\]` は Markdown でのエスケープと解釈されて壊れることがあります。",
    )
    error_by_regex(
        pattern=r'^\$$',
        text=r"KaTeX: display 表示をしたいときは `$` ではなく `$$` を使ってください。`$` は inline 表示になります。",
        fix='$$',
    )
    error_by_regex(
        pattern=r'\\\\',
        text=r"KaTeX: `\\` ではなく `\cr` を使ってください。`\\` が Markdown でのエスケープと解釈されて壊れることがあります。",
        fix=r'\cr',
    )
    error_by_regex(
        pattern=r'\\{|\\}',
        text=r"KaTeX: `\{` と `\}` ではなく `\lbrace` と `\rbrace` を使ってください。`\{` や `\}` が Markdown でのエスケープと解釈されて壊れることがあります。",
        fix=from_table({
            r'\{': r'\lbrace',
            r'\}': r'\rbrace',
        }),
    )
    error_by_regex(
        pattern=r' *_{',
        text=r"KaTeX: `a_{i + 1}` ではなく `a _ {i + 1}` を使ってください。`_` のまわりに空白がないと、Markdown の強調と解釈されて壊れることがあります。",
        fix=' _ {',
    )
    error_by_regex(
        pattern=r'\\_',
        text=r"""KaTeX: アンダースコアを表示するには `\_` ではなく `\textunderscore` や `\char95` を使ってください。`\_` が Markdown でのエスケープと解釈されて壊れることがあります。""",
    )
    if '$' in msg:
        error_by_regex(
            pattern=r'\|',
            text=r"KaTeX: 絶対値記号などには `|` や `\|` ではなく `\vert` や `\lvert` `\rvert` を使ってください。`|` は Markdown のテーブルと解釈されて壊れることがあり、また `\|` は Markdown の処理系によっては HTML 上で `|` ではなく `\|` になって壊れることがあります。",
        )
    else:
        if msg.count('|') <= 2:
            error_by_regex(
                pattern=r'\|',
                text=r"Markdown: `|` を文字として表示したい場合は `|` ではなく `|` を使ってください。`|` は Markdown のテーブルと解釈されて壊れることがあります。",
                fix='|',
            )
    if '' not in msg:
        error_by_regex(
            pattern=r'\$.*[<>].*\$',
            text=r"KaTeX: 数式中では `<` や `>` ではなく `\lt` や `gt` や `\langle` や `\rangle` を使ってください。`<` や `>` は HTML のタグと解釈されて壊れることがあります。",
        )

    for m in re.finditer(r'(\w+)', msg):
        result.extend(check_atcoder_user(m.group(1), file=path, line=line, col=m.start() + 1))

    # internal links
    for m in re.finditer(r'(!?)\[([^]]*)\]\((/[-0-9a-z]+)\)', msg):
        is_image = m.group(1)
        actual_title = m.group(2)
        urlpath = m.group(3)
        if is_image:
            if urlpath not in list_image_urlpaths():
                result.append(error(r'link: リンクされている画像ファイルは存在していません。URL を間違えていませんか？', file=path, line=line, col=m.start() + 1))
        else:
            expected_title = get_title_from_urlpath(urlpath)
            if expected_title is None:
                result.append(error(r'link: リンクされているページは存在していません。URL を間違えていませんか？', file=path, line=line, col=m.start() + 1))
            elif actual_title != expected_title:
                result.append(error(r'link: リンクアンカーの文字列とリンクされているページのタイトルは揃えてください。', file=path, line=line, col=m.start() + 1))

    # external links
    found_urls: List[Tuple[str, int]] = []
    archived_urls: List[str] = []
    for m in re.finditer(r'!?\[[^]]*\]\((https?://.*?)\)', msg):
        url = m.group(1)
        hostname = urllib.parse.urlparse(url).hostname
        if hostname == get_cname():
            result.append(error(r'link: 内部のページへのリンクにはパスだけを書いてください。`![Dijkstra 法](https://{}/dijkstra)` ではなく `![Dijkstra 法](/dijkstra)` のように書いてください。'.format(get_cname() or 'example.com'), file=path, line=line, col=m.start() + 1))


from docutils.parsers.rst import Directive

class mydirective(Directive):
    has_content = True
    required_arguments = 0
    optional_arguments = 0
    final_argument_whitespace = False
    option_spec = {}

    def run(self):
        # This directive doesn't need to do anything for validation
        return []

class my_directive_name(Directive):
    """
    @rst
    .. mydirective:: arg1 arg2
         :option1: value1asdasds22
         :option2: value2

         This is the content of the directive.

    .. anotherdirective:: arg1 arg222
            :option1: value1sss
            :option2: value2ssssd

            This is the content of the directsdaive.22asadad
    @endrst
    """
    has_content = True
    required_arguments = 0
    optional_arguments = 0
    final_argument_whitespace = False
    option_spec = {}

    def run(self):
        return []

class first_directive(Directive):
    has_content = True
    required_arguments = 0
    optional_arguments = 0
    final_argument_whitespace = False
    option_spec = {}

    def run(self):
        return []

class second_directive(Directive):
    has_content = True
    required_arguments = 0
    optional_arguments = 0
    final_argument_whitespace = False
    option_spec = {}

    def run(self):
        return []

class first(Directive):
    has_content = True
    required_arguments = 0
    optional_arguments = 0
    final_argument_whitespace = False
    option_spec = {}

    def run(self):
        return []

class second(Directive):
    has_content = True
    required_arguments = 0
    optional_arguments = 0
    final_argument_whitespace = False
    option_spec = {}

    def run(self):
        return []

class existing_directive(Directive):
    has_content = True
    required_arguments = 0
    optional_arguments = 0
    final_argument_whitespace = False
    option_spec = {}

    def run(self):
        return []

class mydirective_extra(Directive):
    has_content = True
    required_arguments = 0
    optional_arguments = 0
    final_argument_whitespace = False
    option_spec = {}

    def run(self):
        return []


� |
|---------|----------|-------|------------|-------|
| **规模性** | 高吞吐量数据收集\低开销采集机制 | 高效数据处理\流式计算 | 海量数据存储\高效查询 | 大数据可视化\交互性能 |
| **复杂性** | 多源数据一致性\异构环境适配 | 数据关联\上下文重建 | 复杂查询支持\时序关联 | 复杂拓扑展示\多维分析UI |
| **可靠性** | 容错收集\缓冲机制 | 处理保证\数据丢失检测 | 高可用存储\数据完整性 | 降级展示\错误处理 |
| **安全性** | 数据脱敏\访问控制 | 安全处理\隐私保护 | 加密存储\审计追踪 | 权限控制\数据隔离 |
| **灵活性** | 可配置收集器\多格式支持 | 可扩展处理器\自定义转换 | 多后端支持\架构适应性 | 自定义仪表盘\多视图切换 |

这个矩阵揭示了OpenTelemetry在不同层次和维度需要应对的挑战，为架构设计提供了全面视角。

## 3. 架构设计解决方案

### 3.1 多层次架构模型

OpenTelemetry采用多层次架构来解决分布式监测的复杂问题，每一层专注于特定职责：

-**1. API层**

- **定义**：提供语言特定的API，用于创建和管理遥测数据
- **职责**：
  - 定义追踪、度量、日志的接口抽象
  - 提供上下文管理机制
  - 实现与具体实现无关的操作
- **设计原则**：稳定性、兼容性、简洁性

-**2. SDK层**

- **定义**：实现API规范的具体功能，提供可配置的框架
- **职责**：
  - 管理遥测数据的生命周期
  - 实现采样、缓冲和批处理
  - 处理导出器配置和管理
- **设计原则**：可配置性、性能优化、可扩展性

-**3. Collector层**

- **定义**：独立运行的组件，接收、处理和导出遥测数据
- **职责**：
  - 从多个源接收数据
  - 处理（转换、过滤、聚合）数据
  - 将数据导出到多个目标
- **设计原则**：高可靠性、可扩展性、资源效率

-**4. 插件生态层**

- **定义**：围绕核心组件的扩展和集成
- **职责**：
  - 提供与特定后端系统的集成
  - 扩展核心功能到特定领域
  - 适配不同环境和需求
- **设计原


](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

<!-- next-header -->
## [Unreleased] - ReleaseDate
## [0.6.5] - 2024-08-21
### Fixed
- [PR#137](https://github.com/Jake-Shadle/xwin/pull/137) fixes the fix introduced in [PR#136](https://github.com/Jake-Shadle/xwin/pull/136).

## [0.6.4] - 2024-08-21
### Fixed
- [PR#136](https://github.com/Jake-Shadle/xwin/pull/136) fixed an issue introduced in [PR#131](https://github.com/Jake-Shadle/xwin/pull/131) where symlink disabling when a case-insensitive file system was detected was...not being respected. At all.

## [0.6.3] - 2024-08-09
### Fixed
- [PR#134](https://github.com/Jake-Shadle/xwin/pull/134) added back onecoreuap headers that were moved from the main SDK header package in recent versions of the SDK. Thanks [@tomager](https://github.com/tomager)!

## [0.6.2] - 2024-07-02
### Fixed
- [PR#131](https://github.com/Jake-Shadle/xwin/pull/131) resolved [#130](https://github.com/Jake-Shadle/xwin/issues/130) by adding detection of case-insensitive file systems, which then disables symlink creation since it is not needed, and breaks.

## [0.6.1] - 2024-06-30
### Fixed
- [PR#129](https://github.com/Jake-Shadle/xwin/pull/129) fixed [#128](https://github.com/Jake-Shadle/xwin/issues/128) by adding the additional `onecoreuap` MSI package that contains headers that were previously (before SDK 10.0.26100) part of other MSI packages. Thanks [@bigfoodK](https://github.com/bigfoodK)!

## [0.6.0] - 2024-06-03
### Added
- [PR#123](https://github.com/Jake-Shadle/xwin/pull/123) (a rework of [#119](https://github.com/Jake-Shadle/xwin/pull/119)) adds the ability to splat in the format understood by clang-cl `/winsysroot` option.

## [0.5.2] - 2024-05-06
### Changed
- [PR#117](https://github.com/Jake-Shadle/xwin/pull/117) updated a few crates, notably `zip`.

## [0.5.1] - 2024-04-02
### Changed
- [PR#116](https://github.com/Jake-Shadle/xwin/pull/116) (a rework of [#115](https://github.com/Jake-Shadle/xwin/pull/115)) improves the speed of the `x86_64-unknown-linux-musl` binary by using `mimalloc`.

## [0.5.0] - 2023-11-13
### Changed
- [PR#110](https://github.com/Jake-Shadle/xwin/pull/110) changed how `Ctx` is built. It was getting too complicated to support niche use cases, some of which didn't belong in a library (like reading environment variables), so this functionality has been completely removed. Instead, one must pass in a `ureq::Agent` that is fully configured how the user wants it.
- [PR#110](https://github.com/Jake-Shadle/xwin/pull/110) changed the environment variable read to the `xwin` binary instead of the library, as well as its name `https_proxy` -> `HTTPS_PROXY`, and added it to an an option on the command line.

## [0.4.1] - 2023-11-09
### Fixed
- [PR#108](https://github.com/Jake-Shadle/xwin/pull/


spanic', 'latino']
    topic_words_t4 = ['rich', 'wealthy', 'affluent', 'prosperous', 'plentiful', 'poor', 'impoverished', 'needy', 'penniless', 'miserable']

    target_words_t5 = ['asian', 'african', 'hispanic', 'latino']
    topic_words_t5 = ['education', 'learned', 'educated', 'professional', 'elite', 'ignorance', 'foolish', 'rude', 'folly', 'ignorant']

    # 1. 绘制bias曲线
    target_words = target_words_t2
    topic_words = topic_words_t2
    year_sets = [None, [2016, 2017, 2018, 2019], [2020, 2021]]

    # (1)
    media_target_matrix_list = []
    for year_set in year_sets[:1]:
        media_2_bias_data = {}
        media_target_matrix = []
        # test_media_subset = media_list[:]
        test_media_subset = ['base']
        # 绘制bias曲线(1)
        for media_name in test_media_subset:
            target_bias_list = calculate_bias_by_media(media_name, year_set, target_words, topic_words)
            media_target_matrix.extend(target_bias_list)
        # 绘制bias heatmap
        s1 = len(test_media_subset)  # Debug: 变更 test_media_subset , 观察结果
        s2 = len(target_words)
        pos_label = topic_words[0]
        neg_label = topic_words[int(len(topic_words)/2)]
        media_target_matrix = np.array(media_target_matrix[:(s1*s2)]).reshape(s1, s2)
        figsize = (max(1, int(len(test_media_subset) / 30)) * 13, max(1, int(len(target_words) / 30)) * 6)
        colorbar_boundary = math.ceil(max(abs(media_target_matrix.min()), abs(media_target_matrix.max())) / 0.01 + 0) * 0.01  # heatmap-colorbar的取值区间    winter plasma
        util_draw.draw_pairwise_matrix_2(np.around(media_target_matrix, 3).T, target_words, test_media_subset, neg_label, pos_label, figsize, 13, threshold=0, cmap='winter', vmin=(-1)*colorbar_boundary, vmax=colorbar_boundary)
        media_target_matrix_list.append(media_target_matrix)

    print('test down')


"""

MCCP - Mud Client Compression Protocol

This implements the MCCP v2 telnet protocol as per
http://tintin.sourceforge.net/mccp/. MCCP allows for the server to
compress data when sending to supporting clients, reducing bandwidth
by 70-90%.. The compression is done using Python's builtin zlib
library. If the client doesn't support MCCP, server sends uncompressed
as normal.  Note: On modern hardware you are not likely to notice the
effect of MCCP unless you have extremely heavy traffic or sits on a
terribly slow connection.

This protocol is implemented by the telnet protocol importing
mccp_compress and calling it from its write methods.
"""

import weakref
import zlib

# negotiations for v1 and v2 of the protocol
MCCP = bytes([86])  # b"\x56"
FLUSH = zlib.Z_SYNC_FLUSH

def mccp_compress(protocol, data):
    """
    Handles zlib compression, if applicable.

    Args:
        data (str): Incoming data to compress.

    Returns:
        stream (binary): Zlib-compressed data.

    """
    if hasattr(protocol, "zlib"):
        return protocol.zlib.compress(data) + protocol.zlib.flush(FLUSH)
    return data

class Mccp:
    """
    Implements the MCCP protocol. Add this to a
    variable on the telnet protocol to set it up.

    """

    def __init__(self, protocol):
        """
        initialize MCCP by storing protocol on
        ourselves and calling the client to see if
        it supports MCCP. Sets callbacks to
        start zlib compression in that case.

        Args:
            protocol (Protocol): The active protocol instance.

        """

        self.protocol = weakref.ref(protocol)
        self.protocol().protocol_flags["MCCP"] = False
        # ask if client will mccp, connect callbacks to handle answer
        self.protocol().will(MCCP).addCallbacks(self.do_mccp, self.no_mccp)

    def no_mccp(self, option):
        """
        Called if client doesn't support mccp or chooses to turn it off.

        Args:
            option (Option): Option dict (not used).

        """
        if hasattr(self.protocol(), "zlib"):
            del self.protocol().zlib
        self.protocol().protocol_flags["MCCP"] = False
        self.protocol().handshake_done()

    def do_mccp(self, option):
        """
        The client supports MCCP. Set things up by
        creating a zlib compression stream.

        Args:
            option (Option): Option dict (not used).

        """
        self.protocol().protocol_flags["MCCP"] = True
        self.protocol().requestNegotiation(MCCP, b"")
        self.protocol().zlib = zlib.compressobj(9)
        self.protocol().handshake_done()


+(dy^2+dx^2)*r^2-cx^2*dy^2+2*cx*cy*dx*dy-cy^2*dx^2)+dy*y+dx*x-cy*dy-cx*dx)/(dy^2+dx^2)
            //l=(sqrt(-dx^2*y^2+(2*dx*dy*x-2*cx*dx*dy+2*cy*dx^2)*y-dy^2*x^2+(2*cx*dy^2-2*cy*dx*dy)*x+(dy^2+dx^2)*r^2-cx^2*dy^2+2*cx*cy*dx*dy-cy^2*dx^2)-dy*y-dx*x+cy*dy+cx*dx)/(dy^2+dx^2)]

            //if (Precision.IsEqual(direction, new GeoVector2D(0, 0)) || radius <= Precision.eps)
            if (direction.IsNullVector() || radius <= Precision.eps) return new GeoPoint2D[0];
            double x = pointofline.x;
            double y = pointofline.y;
            double dx = direction.x;
            double dy = direction.y;
            double cx = center.x;
            double cy = center.y;

            double d = Math.Abs(Geometry.DistPL(center, pointofline, direction));
            if (d / radius > 1 + Precision.eps)
                return new GeoPoint2D[0];

            if (Math.Abs(d - radius) < Precision.eps)
            {
                // line is tangential to radius
                return new GeoPoint2D[] { DropPL(center, pointofline, direction) };
            }

            double root = -dx * dx * y * y + (2 * dx * dy * x - 2 * cx * dx * dy + 2 * cy * dx * dx) * y - dy * dy * x * x + (2 * cx * dy * dy - 2 * cy * dx * dy) * x + (dy * dy + dx * dx) * radius * radius - cx * cx * dy * dy + 2 * cx * cy * dx * dy - cy * cy * dx * dx;
            if (root < 0.0)
                root = 0.0;

            double deno = dy * dy + dx * dx;
            double l1 = -(Math.Sqrt(root) + dy * y + dx * x - cy * dy - cx * dx) / deno;
            GeoPoint2D p1 = new GeoPoint2D(x + l1 * dx, y + l1 * dy);
            if (d / radius >= 1 - Precision.eps)
                return new GeoPoint2D[] { p1 };
            double l2 = (Math.Sqrt(root) - dy * y - dx * x + cy * dy + cx * dx) / deno;
            GeoPoint2D p2 = new GeoPoint2D(x + l2 * dx, y + l2 * dy);
            return new GeoPoint2D[] { p1, p2 };
        }

        internal static void GetEllipseModOps(GeoPoint2D Center, double MajorRadius, double MinorRadius, Angle MajorAngle,
            out ModOp2D ToUnitCircle, out ModOp2D FromUnitCircle)
        {
            double s = Math.Sin(MajorAngle);
            double c = Math.Cos(MajorAngle);
            ToUnitCircle = new ModOp2D(c / MajorRadius, s / MajorRadius,
                (-c * Center.x - s * Center.y) / MajorRadius, -s / MinorRadius,
                c / MinorRadius, (s * Center.x - c * Center.y) / MinorRadius);
            FromUnitCircle = new ModOp2D(MajorRadius * c, -MinorRadius * s, Center.x,
                MajorRadius * s, MinorRadius * c, Center.y);
        }

        internal static GeoPoint2D[] IntersectEL(GeoPoint2D Center, double MajorRadius, double MinorRadius, Angle MajorAngle,
            GeoPoint2D StartPoint, GeoPoint2D EndPoint)
        {
            ModOp2D ToUnitCircle, FromUnitCircle;
            GetEllipseModOps(Center, MajorRadius, MinorRadius, MajorAngle, out ToUnitCircle, out FromUnitCircle);
            GeoPoint2D s = ToUnitCircle * StartPoint;
            GeoPoint2D e = ToUnitCircle * EndPoint;
            GeoPoint2D[] ip = new GeoP


","trace","warn"],C3={},rB=o=>{let l=new O6.PassThrough,f=new O6.PassThrough;l.write=E=>o("stdout",E),f.write=E=>o("stderr",E);let h=new console.Console(l,f);for(let E of M6)C3[E]=console[E],console[E]=h[E];return()=>{for(let E of M6)console[E]=C3[E];C3={}}};k6.exports=rB});var R3=nt(x3=>{"use strict";Object.defineProperty(x3,"__esModule",{value:!0});x3.default=new WeakMap});var O3=nt(A3=>{"use strict";Object.defineProperty(A3,"__esModule",{value:!0});var iB=Mi(),L6=iB.createContext({exit:()=>{}});L6.displayName="InternalAppContext";A3.default=L6});var k3=nt(M3=>{"use strict";Object.defineProperty(M3,"__esModule",{value:!0});var uB=Mi(),F6=uB.createContext({stdin:void 0,setRawMode:()=>{},isRawModeSupported:!1,internal_exitOnCtrlC:!0});F6.displayName="InternalStdinContext";M3.default=F6});var L3=nt(N3=>{"use strict";Object.defineProperty(N3,"__esModule",{value:!0});var oB=Mi(),P6=oB.createContext({stdout:void 0,write:()=>{}});P6.displayName="InternalStdoutContext";N3.default=P6});var P3=nt(F3=>{"use strict";Object.defineProperty(F3,"__esModule",{value:!0});var lB=Mi(),I6=lB.createContext({stderr:void 0,write:()=>{}});I6.displayName="InternalStderrContext";F3.default=I6});var f4=nt(I3=>{"use strict";Object.defineProperty(I3,"__esModule",{value:!0});var sB=Mi(),b6=sB.createContext({activeId:void 0,add:()=>{},remove:()=>{},activate:()=>{},deactivate:()=>{},enableFocus:()=>{},disableFocus:()=>{},focusNext:()=>{},focusPrevious:()=>{}});b6.displayName="InternalFocusContext";I3.default=b6});var U6=nt((Lq,B6)=>{"use strict";var aB=/[|\\{}()[\]^$+*?.-]/g;B6.exports=o=>{if(typeof o!="string")throw new TypeError("Expected a string");return o.replace(aB,"\\$&")}});var q6=nt((Fq,H6)=>{"use strict";var fB=U6(),z6=[].concat(hi("module").builtinModules,"bootstrap_node","node").map(o=>new RegExp(`(?:\\(${o}\\.js:\\d+:\\d+\\)$|^\\s*at ${o}\\.js:\\d+:\\d+$)`));z6.push(/\(internal\/[^:]+:\d+:\d+\)$/,/\s*at internal\/[^:]+:\d+:\d+$/,/\/\.node-spawn-wrap-\w+-\w+\/node:\d+:\d+\)?$/);var yg=class{constructor(l){l={ignoredPackages:[],...l},"internals"in l||(l.internals=yg.nodeInternals()),"cwd"in l||(l.cwd=process.cwd()),this._cwd=l.cwd.replace(/\\/g,"/"),this._internals=[].concat(l.internals,cB(l.ignoredPackages)),this


 0");
        success("∀ a, a mod 2 = 2 -> False");
    }

    #[test]
    fn sigma_simple() {
        success("∀ n: ℤ, sigma 0 (n + 1 + 1) (λ i: ℤ, i) = sigma 0 (n + 1) (λ i: ℤ, i) + n + 1");
        fail("∀ n: ℤ, sigma 0 (n + 1 + 1) (λ i: ℤ, i) = sigma 0 (n + 1) (λ i: ℤ, i) + n");
        success("sigma (-2) (4) (λ i: ℤ, i * i) = 19");
        success("sigma 2 4 (λ i: ℤ, i * i) = 13");
        success("2 * sigma 0 (0 + 1) (λ i: ℤ, i) = 0 * (0 + 1)");
    }

    #[test]
    fn sigma_hard() {
        success("∀ n: ℤ, 0 ≤ n → sigma 0 n (λ i: ℤ, 2 * i + 1) = n * n → sigma 0 (n + 1) (λ i: ℤ, 2 * i + 1) = (n + 1) * (n + 1)");
    }

    #[test]
    fn transitivity() {
        success("∀ a b c d: ℤ, a < b -> b < c -> c < d -> a < d");
        success("∀ a b c d: ℤ, a ≤ b -> b ≤ c -> c ≤ d -> a ≤ d");
        fail("∀ a b c d: ℤ, a ≤ b -> b ≤ c -> c ≤ d -> a < d");
        success("∀ a b c d: ℤ, a ≤ b -> b < c -> c ≤ d -> a < d");
    }

    #[test]
    fn pow_simple() {
        success("∀ n: ℤ, n ^ 2 = n * n");
        fail("∀ n: ℤ, 2 * 2 ^ n = 2 ^ (n+1)"); // wrong for n = -1
        fail("∀ n: ℤ, 0 ^ n = 0"); // wrong for n = 0
        success("0 ^ 0 = 1");
        success("0 ^ 1 = 0");
        success("∀ n: ℤ, n ^ 1 = n");
        success("∀ n: ℤ, n ^ 0 = 1");
    }

    #[test]
    fn very_huge_variables() {
        use std::fmt::{Error, Write};
        (|| -> Result<(), Error> {
            let mut s = String::new();
            write!(s, "∀ x y ")?;
            let t = 30;
            for i in 1..=t {
                write!(s, "a{i} ")?;
            }
            write!(s, ": ℤ, a1 = 1 -> ")?;
            for i in 2..=t {
                write!(s, "a{} = a{} * 1000 -> ", i, i - 1)?;
            }
            write!(s, "x = a{t} -> y = a{t} + 1 -> x = y")?;
            dbg!(&s);
            fail(&s);
            Ok(())
        })()
        .unwrap();
    }

    #[test]
    fn calculator_mode() {
        with_params("lia=calculator", || {
            success("1 < 2");
            success("2 + 2 = 4");
            fail("1 < 1");
            fail("2 < 1");
            success("-1000000000000000000 < 1");
            fail("∀ x: ℤ, 2 * x = 4 -> x = 2");
            success("∀ x: ℤ, x + x = 2 * x");
        });
        success("∀ x: ℤ, 2 * x = 4 -> x = 2");
    }

    #[test]
    fn lists() {
        success(r#" ∀ l, |l| < |l ++ "x"| "#);
        success(r#" ∀ l, cnt 'x' l + 1 = cnt 'x' (l ++ "x") "#);
        success(r#" ∀ l, cnt 'y' l = cnt 'y' (l ++ "x") "#);
        fail(r#" ∀ A: U, ∀ a b: list A, |a| < |a ++ b| "#);
        success(r#" ∀ A: U, ∀ a b: list A, |a| ≤ |a ++ b| "#);
    }
}
<reponame>anopara/country-slice
use bevy_ecs::prelude::*


toolsLogs[Audit.DEFAULT_PASS];
const metricData={
devtoolsLog,
trace,
settings:context.settings};

const{timing}=await ComputedAdRenderTime.request(metricData,context);

if(!(timing>0)){
context.LighthouseRunWarnings.push(runWarning.NoAdRendered);
return auditNotApplicable.NoAdRendered;
}

let normalScore=
Audit.computeLogNormalScore(timing,PODR,MEDIAN);
if(normalScore>=0.9)normalScore=1;

return{
numericValue:timing*1e-3,
score:normalScore,
displayValue:
str_(UIStrings.displayValue,{timeInMs:timing})};

}}

module.exports=FirstAdRender;
module.exports.UIStrings=UIStrings;

}).call(this,"/node_modules/lighthouse-plugin-publisher-ads/audits/first-ad-render.js");
},{"../computed/ad-render-time":127,"../messages/common-strings":132,"lighthouse":54,"lighthouse/lighthouse-core/lib/i18n/i18n":66}],"lighthouse-plugin-publisher-ads/audits/full-width-slots":[function(require,module,exports){
(function(__filename){

const i18n=require('lighthouse/lighthouse-core/lib/i18n/i18n');
const NetworkRecords=require('lighthouse/lighthouse-core/computed/network-records');
const{auditNotApplicable}=require('../messages/common-strings');
const{Audit}=require('lighthouse');
const{isAdRequest}=require('../utils/resource-classification');
const{URL}=require('url');

const UIStrings={
title:'Ad slots effectively use horizontal space',
failureTitle:'Increase the width of ad slots',
description:'Ad slots that utilize most of the page width generally '+
'experience increased click-through rate over smaller ad sizes. We '+
'recommend leaving no more than 25% of the viewport width unutilized on '+
'mobile devices.',
failureDisplayValue:'{percentUnused, number, percent} of viewport width '+
'is underutilized'};

const str_=i18n.createMessageInstanceIdFn(__filename,UIStrings);

class FullWidthSlots extends Audit{

static get meta(){
return{
id:'full-width-slots',
title:str_(UIStrings.title),
failureTitle:str_(UIStrings.failureTitle),
description:str_(UIStrings.description),
requiredArtifacts:['ViewportDimensions','devtoolsLogs']};

}

static async audit(artifacts,context){
const devtoolsLogs=artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
const networkRecords=await NetworkRecords.request(devtoolsLogs,context);
const viewport=artifacts.ViewportDimensions;
const vpWidth=viewport.innerWidth;

const adRequestUrls=networkRecords.
filter(isAdRequest).
map(record=>new URL(record.url));

if(!adRequestUrls.length){
return auditNotApplicable.NoAds;
}

const sizeArrs=adRequestUrls.map(url=>
url.searchParams.get('prev_iu_szs')||url.searchParams.get('sz'));

const sizes=sizeArrs.join('|').split(/[|,]/);

const widths=sizes.map(size=>parseInt(size.split('x')[0])).
filter(w=>w<=vpWidth&&w>1);

if(!widths.length){
return auditNotApplicable.NoValidAdWidths;
}

const maxWidth=Math.max(...widths);

const pctUnoccupied=1-maxWidth/vpWidth;

const score=pctUnoccupied>.25?0:1;

return{
score,
numericValue:pctUnoccupied,

displayValue:score?
'':
str_(UIStrings.failureDisplayValue,{percentUnused:pctUnoccupied})};

}}

module.exports=FullWid


64e35]]

### System.Nullable`1[[System.UInt32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]

### System.String

### System.Nullable`1[[Microsoft.WindowsServerSolutions.MultipointServer.PowerShell.Commands.Library.EScheduleUpdateReturnState, MultiPoint, Version=10.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35]]

## OUTPUTS

### Microsoft.WindowsServerSolutions.MultipointServer.PowerShell.Commands.Library.WmsScheduledUpdate

## NOTES

## RELATED LINKS

[Disable-WmsScheduledUpdate](./Disable-WmsScheduledUpdate.md)

[Enable-WmsScheduledUpdate](./Enable-WmsScheduledUpdate.md)

[Get-WmsScheduledUpdate](./Get-WmsScheduledUpdate.md)

---
description: Use this topic to help manage Windows and Windows Server technologies with Windows PowerShell.
external help file: MultiPoint.dll-Help.xml
Module Name: MultiPoint
ms.date: 12/20/2016
online version: https://learn.microsoft.com/powershell/module/multipoint/get-wmsscheduledupdate?view=windowsserver2022-ps&wt.mc_id=ps-gethelp
schema: 2.0.0
title: Get-WmsScheduledUpdate
---

# Get-WmsScheduledUpdate

## SYNOPSIS
Gets the scheduled update configuration.

## SYNTAX

```
Get-WmsScheduledUpdate [-Server <String>] [<CommonParameters>]
```

## DESCRIPTION
The **Get-WmsScheduledUpdate** cmdlet gets the current configuration for scheduled updates while disk protection is set to discard mode.

## EXAMPLES

### Example 1: Get the scheduled update configuration
```
PS C:\> Get-WmsScheduledUpdate

IsScheduleUpdateEnabled       : True
AutomaticUpdateMode           : WindowsOnly
HourToScheduleUpdates         : 3
CustomScript                  : c:\myapps\sampleapp.exe
MaxTimeAllowedForCustomScript : 30
ReturnState                   : PreviousState
```

This command gets the current scheduled update configuration.

## PARAMETERS

### -Server
Specifies the fully qualified host name of the MultiPoint Server that is the target of the command.
The default is localhost.

```yaml
Type: String
Parameter Sets: (All)
Aliases: ComputerName

Required: False
Position: Named
Default value: None
Accept pipeline input: True (ByPropertyName)
Accept wildcard characters: False
```

### CommonParameters
This cmdlet supports the common parameters: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutVariable, -OutBuffer, -PipelineVariable, -Verbose, -WarningAction, and -WarningVariable. For more information, see [about_CommonParameters](https://go.microsoft.com/fwlink/?LinkID=113216).

## INPUTS

### System.String

## OUTPUTS

### Microsoft.WindowsServerSolutions.MultipointServer.PowerShell.Commands.Library.WmsScheduledUpdate

## NOTES

## RELATED LINKS

[Disable-WmsScheduledUpdate](./Disable-WmsScheduledUpdate.md)

[Enable-WmsScheduledUpdate](./Enable-WmsScheduledUpdate.md)

[Set-WmsScheduledUpdate](./Set-WmsScheduledUpdate.md)

---
UID: NC:d3d12umddi.PFND3D12DDI_CLEAR_RENDER_TARGET_VIEW_0003
title: PFND3D12DDI_CLEAR_RENDER_TARGET_VIEW_0003 (d3d12umddi.h)
description: The pfnClearRenderTargetView function clears the specified render-target view by setting it to a constant value.
tech.root: display
ms.date: 11/28/2018
keywords: ["PFND3D12DDI_CLEAR_RENDER_TARGET_VIEW_0003 callback function"]
req.header: d3d12umddi.h
req.include-header:
req.target-type:
req.target-min-winverclnt: Windows 10
req.target-min-winversvr:
req.kmdf-ver:
req.umdf-ver:
req.lib:
req.dll:
req.irql:
req.ddi-compliance:
req.unicode-


ine]
    pub(crate) fn len(&self) -> HeapIndex {
        HeapIndex(self.data.len())
    }

    #[inline]
    pub(crate) fn usize_len(&self) -> usize {
        self.data.len()
    }

    #[inline]
    pub(crate) fn is_empty(&self) -> bool {
        self.data.is_empty()
    }

    #[inline]
    pub(crate) fn clear(&mut self) {
        self.data.clear()
    }

    #[inline]
    pub(crate) fn iter(&self) -> BinaryHeapIterator<TPriority> {
        BinaryHeapIterator {
            inner: self.data.iter(),
        }
    }

    pub(crate) fn produce_from_iter_hash<TKey, TIter, S>(
        iter: TIter,
    ) -> (Self, crate::mediator::Mediator<TKey, S>)
    where
        TKey: std::hash::Hash + Eq,
        TIter: IntoIterator<Item = (TKey, TPriority)>,
        S: BuildHasher + Default,
    {
        use crate::mediator::{Mediator, MediatorEntry};

        let iter = iter.into_iter();
        let (min_size, _) = iter.size_hint();

        let mut heap_base: Vec<HeapEntry<TPriority>> = Vec::with_capacity(min_size);
        let mut map: Mediator<TKey, S> = Mediator::with_capacity_and_hasher(min_size, S::default());

        for (key, priority) in iter {
            match map.entry(key) {
                MediatorEntry::Vacant(entry) => {
                    let outer_pos = entry.index();
                    unsafe {
                        // Safety: resulting reference never used
                        entry.insert(HeapIndex(heap_base.len()));
                    }
                    heap_base.push(HeapEntry {
                        outer_pos,
                        priority,
                    });
                }
                MediatorEntry::Occupied(entry) => {
                    let HeapIndex(heap_pos) = entry.get_heap_idx();
                    heap_base[heap_pos].priority = priority;
                }
            }
        }

        let heapify_start = std::cmp::min(heap_base.len() / 2 + 2, heap_base.len());
        let mut heap = BinaryHeap { data: heap_base };
        for pos in (0..heapify_start).rev().map(HeapIndex) {
            heap.heapify_down(pos, &mut |_, _| {});
        }

        for (i, pos) in heap.data.iter().map(HeapEntry::to_outer).enumerate() {
            let heap_idx = map.get_index_mut(pos);
            *heap_idx = HeapIndex(i);
        }

        (heap, map)
    }

    fn heapify_up<TChangeHandler: std::ops::FnMut(MediatorIndex, HeapIndex)>(
        &mut self,
        position: HeapIndex,
        change_handler: &mut TChangeHandler,
    ) {
        debug_assert!(position < self.len(), "Out of index in heapify_up");
        let HeapIndex(mut position) = position;
        while position > 0 {
            let parent_pos = (position - 1) / 2;
            if self.data[parent_pos].priority >= self.data[position].priority {
                break;
            }
            self.data.swap(parent_pos, position);
            change_handler(self.data[position].outer_pos, HeapIndex(position));
            position = parent_pos;
        }
        change_handler(self.data[position].outer_pos, HeapIndex(position));
    }

    fn heapify_down<TChangeHandler: std::ops::FnMut(MediatorIndex, HeapIndex)>(
        &mut self,
        position: HeapIndex,
        change_handler: &mut TChangeHandler,
    ) {
        debug_assert!(position < self.len(), "Out of index in heap


gnu.org/licenses/>.
 */
#endregion

using System;
using System.Data.Linq;
using System.Linq;

namespace HeuristicLab.Services.Hive.DataAccess.Daos {
  public class RequiredPluginDao : GenericDao<Guid, RequiredPlugin> {
    public RequiredPluginDao(DataContext dataContext) : base(dataContext) { }

    public override RequiredPlugin GetById(Guid id) {
      return GetByIdQuery(DataContext, id);
    }

    #region Compiled queries
    private static readonly Func<DataContext, Guid, RequiredPlugin> GetByIdQuery =
      CompiledQuery.Compile((DataContext db, Guid requiredPluginId) =>
        (from requiredPlugin in db.GetTable<RequiredPlugin>()
         where requiredPlugin.RequiredPluginId == requiredPluginId
         select requiredPlugin).SingleOrDefault());
    #endregion
  }
}


.include "macros.inc"

.section .text, "ax"  # 0x80006980 - 0x803E1E60

.global NHTTPStartup
NHTTPStartup:
/* 802FEE28 002FAA88  94 21 FF E0 */	stwu r1, -0x20(r1)
/* 802FEE2C 002FAA8C  7C 08 02 A6 */	mflr r0
/* 802FEE30 002FAA90  90 01 00 24 */	stw r0, 0x24(r1)
/* 802FEE34 002FAA94  93 E1 00 1C */	stw r31, 0x1c(r1)
/* 802FEE38 002FAA98  7C BF 2B 78 */	mr r31, r5
/* 802FEE3C 002FAA9C  93 C1 00 18 */	stw r30, 0x18(r1)
/* 802FEE40 002FAAA0  7C 9E 23 78 */	mr r30, r4
/* 802FEE44 002FAAA4  93 A1 00 14 */	stw r29, 0x14(r1)
/* 802FEE48 002FAAA8  7C 7D 1B 78 */	mr r29, r3
/* 802FEE4C 002FAAAC  48 00 10 1D */	bl NHTTPi_GetSystemInfoP
/* 802FEE50 002FAAB0  7F A4 EB 78 */	mr r4, r29
/* 802FEE54 002FAAB4  7F C5 F3 78 */	mr r5, r30
/* 802FEE58 002FAAB8  7F E6 FB 78 */	mr r6, r31
/* 802FEE5C 002FAABC  4B FF 8D BD */	bl NHTTPi_Startup
/* 802FEE60 002FAAC0  7C 60 00 34 */	cntlzw r0, r3
/* 802FEE64 002FAAC4  83 E1 00 1C */	lwz r31, 0x1c(r1)
/* 802FEE68 002FAAC8  54 00 D9 7E */	srwi r0, r0, 5
/* 802FEE6C 002FAACC  83 C1 00 18 */	lwz r30, 0x18(r1)
/* 802FEE70 002FAAD0  7C 60 00 D0 */	neg r3, r0
/* 802FEE74 002FAAD4  83 A1 00 14 */	lwz r29, 0x14(r1)
/* 802FEE78 002FAAD8  80 01 00 24 */	lwz r0, 0x24(r1)
/* 802FEE7C 002FAADC  7C 08 03 A6 */	mtlr r0
/* 802FEE80 002FAAE0  38 21 00 20 */	addi r1, r1, 0x20
/* 802FEE84 002FAAE4  4E 80 00 20 */	blr

.global NHTTPCleanupAsync
NHTTPCleanupAsync:
/* 802FEE88 002FAAE8  94 21 FF F0 */	stwu r1, -0x10(r1)
/* 802FEE8C 002FAAEC  7C 08 02 A6 */	mflr r0
/* 802FEE90 002FAAF0  90 01 00 14 */	stw r0, 0x14(r1)
/* 802FEE94 002FAAF4  93 E1 00 0C */	stw r31, 0xc(r1)
/* 802FEE98 002FAAF8  7C 7F 1B 78 */	mr r31, r3
/* 802FEE9C 002FAAFC  48 00 0F CD */	bl NHTTPi_GetSystemInfoP
/* 802FEEA0 002FAB00  7F E4 FB 78 */	mr r4, r31
/* 802FEEA4 002FAB04  4B FF 8F 01 */	bl NHTTPi_CleanupAsync
/* 802FEEA8 002FAB08  80 01 00 14 *


())) {
            return Result.buildParamIllegal("节点状态为空");
        }
        if (AriusObjUtils.isNullStr(param.getNodeSet())) {
            return Result.buildParamIllegal("节点set为空");
        }
        return Result.buildSucc();
    }

    private boolean addNodeBatch(List<ESClusterRoleHostPO> nodePOs) {
        // 数据修改的行数成功数
        int count = 0;
        for (ESClusterRoleHostPO param : nodePOs) {
            if (null != clusterRoleHostDAO.getDeleteHostByHostNameAnRoleId(param.getHostname(),
                param.getRoleClusterId())) {
                count += clusterRoleHostDAO.restoreByHostNameAndRoleId(param.getHostname(), param.getRoleClusterId());
                continue;
            }
            count += clusterRoleHostDAO.insert(param);
        }
        return CollectionUtils.isEmpty(nodePOs) || nodePOs.size() == count;
    }

    private boolean editNodeBatch(List<ESClusterRoleHostPO> nodePOs) {
        if (CollectionUtils.isEmpty(nodePOs)) {
            return true;
        }

        boolean succ = true;
        for (ESClusterRoleHostPO nodePO : nodePOs) {
            succ &= editNode(ConvertUtil.obj2Obj(nodePO, ESClusterRoleHostDTO.class)).success();
        }

        return succ;
    }

    /**
     * 获取集群内节点配置
     * @param cluster 集群名称
     * @return EsClusterNodePO列表
     */
    private List<ESClusterRoleHostPO> getClusterHostFromEsAndCreateRoleClusterIfNotExist(String cluster) throws ESOperateException {
        List<ESClusterRoleHostPO> nodePOList = Lists.newArrayList();

        // 从ES集群中获取初始的节点信息列表
        List<ClusterNodeInfo> clusterNodeInfos = buildAllClusterNodeInfoFromES(cluster);
        Map<String, String> node2machineSpecMap = buildESClusterNodeMachineSpecMap(cluster);

        // 根据集群节点角色信息构建入DB的host列表信息
        for (ClusterNodeInfo nodeInfoListFromArius : clusterNodeInfos) {
            // 构造节点记录数据
            ESClusterRoleHostPO roleClusterHostPO = buildEsClusterHostPO(nodeInfoListFromArius, node2machineSpecMap,
                cluster);
            // 节点所属的角色记录如果不存在，则去设置
            setRoleClusterId(roleClusterHostPO, cluster);

            nodePOList.add(roleClusterHostPO);
        }

        return nodePOList;
    }

    private Map<String, String> buildESClusterNodeMachineSpecMap(String cluster) throws ESOperateException {
        Map<String, String> node2machineSpecMap = Maps.newHashMap();
        Map<String, Integer> node2CpuNum = esClusterNodeService.syncGetNodesCpuNum(cluster);
        Map<String, Tuple<Long, Long>> node2MemAndDisk = esClusterNodeService.syncGetNodesMemoryAndDisk(cluster);
        Set<String> nodes = Sets.intersection(node2CpuNum.keySet(), node2MemAndDisk.keySet());
        if (CollectionUtils.isNotEmpty(nodes)) {
            nodes.forEach(node -> {
                Integer cpuNum = node2CpuNum.get(node);
                Tuple<Long, Long> memAndDisk = node2MemAndDisk.get(node);
                Long memoryBytes = memAndDisk.getV1();
                Long diskBytes = memAndDisk.getV2();
                if (null != cpuNum && null != memoryBytes && null != diskBytes) {
                    node2machineSpecMap.put(node, SizeUtil.getMachineSpec(cpuNum,


_cpl_1_1_persistent_1_1_data_record.html#a5c759351949a50f36588731bb683280c">Cpl::Persistent::DataRecord

~Decoder() : Cpl::Text::Frame::Decoder

~DFString() : Cpl::Text::DFString

~DirectoryWalker() : Cpl::Io::File::Api::DirectoryWalker

~DirList_() : Cpl::Io::File::DirList_

~DString() : Cpl::Text::DString

~Encoder() : Cpl::Text::Frame::Encoder

~Equipment() : Storm::Component::Control::Equipment

~EraseRequest() : Cpl::Dm::Persistent::EraseRequest

~EraseResponse() : Cpl::Dm::Persistent::EraseResponse

~EventFlag() : Cpl::System::EventFlag

~EventLoop() : Cpl::System::EventLoop

~Factory() : Cpl::Io::Socket::Factory


.file	"rsa_head.S"
	.text

##################################################################################################
	###										###
	### 	montmul_1st montsqu_1st 						###
	###										###
##################################################################################################

/* 16 256bit vector registers */
#########################################################

	#########################################
	#	A0 	A1	A2	A3 	#
	#					#
	# A[i]  9	11	13	15	#
	# 	8	10	12	14	#
	# 	1	3	5	7	#
	# 	0	2	4	6	#
	#########################################
	#	B0 	B1	B2	B3 	#
	#					#
	# B[i]  9	11	13	15	#
	# 	8	10	12	14	#
	# 	1	3	5	7	#
	# 	0	2	4	6	#
	#########################################
	# 	M0 	M1	M2	M3 	#
	#					#
	# M[i]  9	11	13	15	#
	# 	8	10	12	14	#
	# 	1	3	5	7	#
	# 	0	2	4	6	#
	#########################################
	# 	T0 	T1	T2	T3 	#
	#					#
	# T[i]  9	11	13	15	#
	# 	8	10	12	14	#
	# 	1	3	5	7	#
	# 	0	2	4	6	#
	#########################################

#########################################################

/* A0-A3 */
.set	A0,	%ymm0
.set	A1,	%ymm1
.set	A2,	%ymm2
.set	A3,	%ymm3

/* B0-B3 */
.set 	B0,	%ymm4
.set	B1,	%ymm5
.set	B2,	%ymm6
.set	B3,	%ymm7

/* M0-M3 */
.set	M0,	%ymm8
.set	M1,	%ymm9
.set	M2,	%ymm10
.set	M3,	%ymm11

/* T0-T3 Exponent */
.set	T0,	%ymm12
.set	T1,	%ymm13
.set	T2,	%ymm14
.set	T3,	%ymm15

##### A0xmm is the xmm register, low 128bit of ymm register #####
##### A0xmm is used for vpextrq #####

/* A0-A3 */
.set	A0xmm,	%xmm0
.set	A1xmm,	%xmm1
.set	A2xmm,	%xmm2
.set	A3xmm,	%xmm3

/* B0-B3 */
.set 	B0xmm,	%xmm4
.set	B1xmm,	%xmm5
.set	B2xmm,	%xmm6
.set	B3xmm,	%xmm7

/* M0-M3 */
.set	M0xmm,	%xmm8
.set	M1xmm,	%xmm9
.set	M2xmm,	%xmm10
.set	M3xmm,	%xmm11

/* T0-T3 Exponent */
.set	T0xmm,	%xmm12
.set	T1xmm,	%xmm13
.set	T2xmm,	%xmm14
.set	T3xmm,	%xmm15

/* 8 64bit mmx registers */
/* q0-q7 */
.set	q0,	%mm0
.set    q1,	%mm1
.set    q2,	%mm2
.set    q3,	%mm3
.set    q4,	%mm4
.set    q5,	%mm5
#.set    q6,	%rbp
#.set


109q-23 0-34-20t0-40l217-375L55-792q-12-12-11.5-28.5T56-849q12-12 28.5-12t28.5 12l735 736q12 12 12 28t-12 28q-12 12-28.5 12T791-57ZM499-348Zm45-181Z|0 -960 960 960'
export const symRoundedWash = 'M700-640q-39 0-69.5-30.5T600-740q0-45 29-87.5t56-74.5q6-8 15-8t15 8q27 32 56 74.5t29 87.5q0 39-30.5 69.5T700-640ZM240-80q-66 0-113-47T80-240v-216q0-31 14.5-57.5T135-557l306-199q11-7 23-5.5t21 10.5q20 20 23.5 47.5T497-652l-45 72h308q17 0 28.5 11.5T800-540q0 17-11.5 28.5T760-500H380q-23 0-35-20.5t1-40.5l39-63-207 134q-9 5-13.5 14t-4.5 20v216q0 33 23.5 56.5T240-160h480q17 0 28.5 11.5T760-120q0 17-11.5 28.5T720-80H240Zm600-280H520q-17 0-28.5-11.5T480-400q0-17 11.5-28.5T520-440h320q17 0 28.5 11.5T880-400q0 17-11.5 28.5T840-360Zm-40 140H520q-17 0-28.5-11.5T480-260q0-17 11.5-28.5T520-300h280q17 0 28.5 11.5T840-260q0 17-11.5 28.5T800-220ZM320-330Z|0 -960 960 960'
export const symRoundedWatch = 'M420-800h120-120Zm0 640h120-120Zm0 80q-26 0-47.5-15.5T343-137l-23-77q-6-20-18.5-40.5T269-297q-34-37-51.5-84T200-480q0-51 17.5-98t51.5-85q20-23 32.5-43t18.5-40l23-77q8-26 29.5-41.5T420-880h120q26 0 47.5 15.5T617-823l23 77q6 20 18.5 40.5T691-663q34 37 51.5 84t17.5 99q0 51-17.5 98T691-297q-20 23-32.5 43T640-214l-23 77q-8 26-29.5 41.5T540-80H420Zm60-200q83 0 141.5-58.5T680-480q0-83-58.5-141.5T480-680q-83 0-141.5 58.5T280-480q0 83 58.5 141.5T480-280Zm-76-470q20-5 38.5-8t37.5-3q19 0 37.5 3t38.5 8l-16-50H420l-16 50Zm16 590h120l16-50q-20 5-38.5 7.5T480-200q-19 0-37.5-2.5T404-210l16 50Z|0 -960 960 960'
export const symRoundedWatchArrow = 'M466-440h-86q-17 0-28.5-11.5T340-480q0-17 11.5-28.5T380-520h86l-15-16q-11-12-11-28t12-28q11-11 28-11t28 11l84 84q6 6 8.5 13t2.5 15q0 8-2.5 1


bed()
                    .setColor('RANDOM')
                    .setThumbnail("https://cdn.discordapp.com/attachments/340683078899073034/606110685885235201/0oYW3Ta.jpg")
                    .addField(':bust_in_silhouette: | Private Server by : ', `${welcomeChannel.guild.owner}`)
                    .addField(':microphone2: | Welcome!', `Welcome to the server, ${welcomeChannel.guild.name}`)
                    .addField(':id: | User :', "**[" + `${welcomeChannel.guild.id}` + "]**")
                    .addField(':family_mwgb: | You are member number', `${welcomeChannel.guild.memberCount}`)
                    .addField("Name", `<@` + `${welcomeChannel.id}` + `>`, true)
                    .addField('Server', `${welcomeChannel.guild.name}`, true )
                    .setFooter(`**${welcomeChannel.guild.name}**`)
                    .setTimestamp()
             welcomeChannel.send(embed)
         .catch(console.error);
   })

client.on("guildMemberAdd", member => {

    let welcomeChannel = member.guild.channels.find(channel => channel.name === "🍌💦i-like-katkit🍌💦") as Discord.TextChannel;
    welcomeChannel.send(`Welcome ${member.displayName}! This stupid command took 2 days to make!`)

    let memberRole = member.guild.roles.find(role => role.id == "578838550045523998");
    member.addRole(memberRole);

})

client.on("guildMemberRemove", member => {

    let welcomeChannel = member.guild.channels.find(channel => channel.name === "🍌💦i-like-katkit🍌💦") as Discord.TextChannel;
    welcomeChannel.send(`Wow, ${member.displayName}! Why you left...`)
})

client.on("message", msg => {

    //Ignore the message if it was by the bot
    if (msg.author.bot) { return; }

    //Ignore the message if send in dm
    if (msg.channel.type == "dm") { return; }

    //Ignore message that dont have prefix
    if (!msg.content.startsWith(ConfigFile.config.prefix)) { return; }

    //Handle the command
    handleCommand(msg);

})

async function handleCommand(msg: Discord.Message){

    //Split the string into the command and all the string
    let command = msg.content.split(" ")[0].replace(ConfigFile.config.prefix, "").toLowerCase();
    let args = msg.content.split(" ").slice(1);

    //loop through all of our commands
    for(const commandClass of commands){

        //Attempt to execute code but ready in case of a possible error
        try{

            //Check if our command class is the correct one
            if(!commandClass.isThisCommand(command)){

                //Go to the next iteration of the loop if this isnt the correct command class
                continue;
            }

            //Pause execution whilst we run the command's code
            await commandClass.runCommand(args, msg, client);
        }
        catch(exception){

            //If there is an error, then log in exception
            console.log(exception);
        }
    }
}

function loadCommands(commandsPath: string) {

    //Exit if there are no commands
    if(!ConfigFile.config || (ConfigFile.config.commands as string[]).length === 0) { return; }

    //Loop through all commands in config file
    for(const commandName of ConfigFile.config.commands as string[]) {

        const commandsClass = require(`${commandsPath}/${commandName}`).default;

        const command = new commandsClass() as IBotCommand;

        commands.push(command);
    }
}

client.login(process.env.BOT_TOKEN);import { Pipe, PipeTransform } from '@angular/core';

@Pipe({


--================================================================
--
-- 配置
--
--================================================================

-- 怪物
monsters = {
	{ config_id = 33001, monster_id = 21011001, pos = { x = -86.0, y = 202.9, z = -788.9 }, rot = { x = 0.0, y = 0.0, z = 0.0 }, level = 30, drop_tag = "远程丘丘人", disableWander = true, pose_id = 32 },
	{ config_id = 33004, monster_id = 21010901, pos = { x = -93.6, y = 200.2, z = -786.8 }, rot = { x = 0.0, y = 32.1, z = 0.0 }, level = 30, drop_tag = "远程丘丘人", disableWander = true, pose_id = 32 },
	{ config_id = 33005, monster_id = 21011201, pos = { x = -88.8, y = 200.4, z = -783.5 }, rot = { x = 0.0, y = 10.7, z = 0.0 }, level = 30, drop_tag = "丘丘人", pose_id = 9010 },
	{ config_id = 33006, monster_id = 21010501, pos = { x = -84.1, y = 204.5, z = -794.7 }, rot = { x = 0.0, y = 352.2, z = 0.0 }, level = 30, drop_tag = "远程丘丘人", pose_id = 32 }
}

-- NPC
npcs = {
}

-- 装置
gadgets = {
	{ config_id = 33002, gadget_id = 70211012, pos = { x = -91.3, y = 200.6, z = -789.1 }, rot = { x = 359.4, y = 4.3, z = 8.0 }, level = 32, drop_tag = "战斗中级璃月", state = GadgetState.ChestLocked, isOneoff = true, persistent = true },
	{ config_id = 33007, gadget_id = 70310001, pos = { x = -89.0, y = 200.9, z = -792.7 }, rot = { x = 357.3, y = 359.7, z = 6.2 }, level = 32, state = GadgetState.GearStart }
}

-- 区域
regions = {
}

-- 触发


ット地点から現在までの歴史が消失してしまうため)
    ///
    /// なお、`head`以前の記録は歴史から削除される.
    pub fn record_snapshot_installed(
        &mut self,
        new_head: LogPosition,
        config: ClusterConfig,
    ) -> Result<()> {
        track_assert!(
            self.head().index <= new_head.index,
            ErrorKind::InconsistentState,
            "self.head={:?}, new_head={:?}",
            self.head(),
            new_head
        );

        // スナップショット地点までの歴史は捨てる
        while self
            .records
            .front()
            .map_or(false, |r| r.head.index <= new_head.index)
        {
            self.records.pop_front();
        }

        // 新しいログの先頭をセット
        let record = HistoryRecord::new(new_head, config);
        self.records.push_front(record);

        if self.appended_tail.index < new_head.index {
            self.appended_tail = new_head;
        }
        if self.committed_tail.index < new_head.index {
            self.committed_tail = new_head;
        }
        Ok(())
    }

    /// スナップショットが読み込まれたことを記録する.
    ///
    /// ローカルログ内のスナップショット地点までのエントリは、消費されたものとして扱われる.
    pub fn record_snapshot_loaded(&mut self, snapshot: &LogPrefix) -> Result<()> {
        if self.consumed_tail.index < snapshot.tail.index {
            track_assert!(
                snapshot.tail.index <= self.committed_tail.index,
                ErrorKind::InconsistentState,
                "snapshot.tail.index={:?}, self.committed_tail.index={:?}",
                snapshot.tail.index,
                self.committed_tail.index
            );
            self.consumed_tail = snapshot.tail;
        }
        Ok(())
    }
}

/// `LogHistory`に保持されるレコード.
#[derive(Debug, Clone)]
pub struct HistoryRecord {
    /// 記録地点.
    pub head: LogPosition,

    /// 記録時のクラスタ構成.
    pub config: ClusterConfig,
}
impl HistoryRecord {
    fn new(head: LogPosition, config: ClusterConfig) -> Self {
        HistoryRecord { head, config }
    }
}
// Generated by `scripts/generate.js`

use utils::c_bindings::*;
use utils::vk_traits::*;
use utils::vk_ptr::*;
use utils::vk_convert::*;
use std::os::raw::c_char;
use std::ops::Drop;
use std::ptr;
use std::mem;
use std::cmp;
use std::slice;
use vulkan::*;
use vulkan::vk::*;

#[doc(hidden)]
pub type RawVkDevice = u64;

/// Wrapper for [VkDevice](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDevice.html).
#[derive(Debug, Clone, Copy)]
pub struct VkDevice {
    _handle: RawVkDevice,
    _fn_table: *mut VkFunctionTable
}

impl VkRawType<VkDevice> for RawVkDevice {
    fn vk_to_wrapped(src: &RawVkDevice) -> VkDevice {
        VkDevice {
            _handle: *src,
            _fn_table: ptr::null_mut()
        }
    }
}

impl VkWrappedType<RawVkDevice> for VkDevice {
    fn vk_to_raw(src: &VkDevice, dst: &mut RawVkDevice) {
        *dst = src._handle
    }
}

impl Default for VkDevice {
    fn


pre>

쿠버네티스 클러스터 프로비저닝하기<button data-href="#Provision-a-Kubernetes-cluster" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button>

이 가이드에서는 GKE(구글 쿠버네티스 엔진) 서비스를 사용하여 us-west1-a 영역에 두 개의 노드가 있는 쿠버네티스 클러스터를 프로비저닝하겠습니다. 각 노드는 COS_CONTAINERD 이미지를 실행하는 e2-standard-4 컴퓨팅 엔진 가상 머신입니다.

서비스 안정성을 보장하기 위해 최소 16GB의 메모리를 제공하는 유형의 머신을 사용하는 것이 좋습니다.

gcloud container clusters create "milvus-cluster-1" \
    --project "milvus-testing-nonprod" \
    --zone "us-west1-a" \
    --workload-pool "milvus-testing-nonprod.svc.id.goog" \
    --no-enable-basic-auth \
    --cluster-version "1.28.10-gke.1075001" \
    --release-channel "regular" \
    --machine-type "c2-standard-4" \
    --image-type "COS_CONTAINERD" \
    --disk-type


ues;
  }

// Helper function to build an address string
  String? _buildAddress(Map<String, dynamic> tags) {
    final String? street = tags["addr:street"];
    final String? houseNo = tags["addr:housenumber"];
    final String? city = tags["addr:city"];

    if (street == null && houseNo == null && city == null) {
      return null;
    }

    final String houseNoAndStreet = [
      if (street != null && street.isNotEmpty) street,
      if (houseNo != null && houseNo.isNotEmpty) houseNo,
    ].join(' ');

    return [
      if (houseNoAndStreet.isNotEmpty) houseNoAndStreet,
      if (city != null && city.isNotEmpty) city,
    ].join(', ');
  }
}
// SPDX-FileCopyrightText: 2022 Foundation Devices Inc.
//
// SPDX-License-Identifier: GPL-3.0-or-later

// ignore_for_file: constant_identifier_names

import 'dart:async';
import 'dart:convert';
import 'package:envoy/account/envoy_transaction.dart';
import 'package:envoy/business/local_storage.dart';
import 'package:envoy/util/bug_report_helper.dart';
import 'package:envoy/util/console.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:http_tor/http_tor.dart';
import 'package:json_annotation/json_annotation.dart';
import 'package:ngwallet/ngwallet.dart';
import 'package:envoy/business/fee_rates.dart';
import 'package:envoy/util/tuple.dart';

// Generated
part 'fees.g.dart';

const int FEE_UNKNOWN = 0x7FFFFFFFFFFFFFFF; // i64::MAX from rust

final mempoolBlocksMedianFeeRateProvider =
    Provider.family<List<double>, Network>((ref, network) {
  return Fees().fees[network]?.mempoolBlocksMedianFeeRate ?? [];
});

final txEstimatedConfirmationTimeProvider =
    Provider.family<int, Tuple<EnvoyTransaction, Network>>((ref, txNetwork) {
  final tx = txNetwork.item1;
  final network = txNetwork.item2;

  final feeRate = tx.fee / tx.vsize;
  final medianFeeRates = ref.watch(mempoolBlocksMedianFeeRateProvider(network));

  int minutesToConfirmation = 10;
  for (final blockFeeRate in medianFeeRates) {
    if (feeRate > blockFeeRate) {
      return minutesToConfirmation;
    }
    minutesToConfirmation += 10;
  }

  return minutesToConfirmation;
});

LocalStorage _ls = LocalStorage();

@JsonSerializable()
class Fees {
  // All in BTC per kb
  int fastRate(Network network) {
    return fees[network]?.mempoolFastestRate ?? 1;
  }

  int slowRate(Network network) {
    return fees[network]?.mempoolHourRate ?? 1;
  }

  static Map<Network, FeeRates> _defaultFees() {
    return {
      Network.bitcoin: FeeRates(),
      Network.testnet: FeeRates(),
      Network.signet: FeeRates()
    };
  }

  static Map<String, dynamic> _feesToJson(Map<Network, FeeRates> fees) {
    Map<String, dynamic> jsonMap = {};
    for (var entry in fees.entries) {
      jsonMap[entry.key.name] = entry.value.toJson();
    }

    return jsonMap;
  }

  static Map<Network, FeeRates> _feesFromJson(Map<String, dynamic> fees) {
    Map<Network, FeeRates> map = {};
    for (var entry in fees.entries) {
      map[Network.values.byName(entry.key)] = FeeRates.f


   */
  setTextBaseline: () => void;

  /**
   * 画出当前路径的边框。默认颜色色为黑色。
   */
  stroke: () => void;

  /**
   * 画一个矩形(非填充)。
   */
  strokeRect: () => void;

  /**
   * 对当前坐标系的原点(0, 0)进行变换，默认的坐标系原点为页面左上角。
   */
  translate: () => void;
}

interface _writeBLECharacteristicValueany {
  /**
   * 蓝牙设备 id，参考 device 对象
   */
  deviceId: string;

  /**
   * 蓝牙特征值对应服务的 uuid
   */
  serviceId: string;

  /**
   * 蓝牙特征值的 uuid
   */
  characteristicId: string;

  /**
   * 蓝牙设备特征值对应的二进制值
   */
  value: any;

  /**
   * 成功则返回本机蓝牙适配器状态
   */
  success: (result: _writeBLECharacteristicValueSuccessany) => void;

  /**
   * 接口调用失败的回调函数
   */
  fail: () => void;

  /**
   * 接口调用结束的回调函数（调用成功、失败都会执行）
   */
  complete: () => void;
}

interface _writeBLECharacteristicValueSuccessany {
  /**
   * 成功：ok，错误：详细信息
   */
  errMsg: string;
}

interface _vibrateShortany {
  /**
   * 接口调用成功的回调函数
   */
  success: () => void;

  /**
   * 接口调用失败的回调函数
   */
  fail: () => void;

  /**
   * 接口调用结束的回调函数（调用成功、失败都会执行）
   */
  complete: () => void;
}
interface _vibrateLongany {
  /**
   * 接口调用成功的回调函数
   */
  success: () => void;

  /**
   * 接口调用失败的回调函数
   */
  fail: () => void;

  /**
   * 接口调用结束的回调函数（调用成功、失败都会执行）
   */
  complete: () => void;
}
interface _uploadFileany {
  /**
   * 开发者服务器 url
   */
  url: string;

  /**
   * 要上传文件资源的路径
   */
  filePath: string;

  /**
   * 文件对应的 key , 开发者在服务器端通过这个 key 可以获取到文件二进制内容
   */
  name: string;

  /**
   * HTTP 请求 Header, header 中不能设置 Referer
   */
  header: any;

  /**
   * HTTP 请求中其他额外的 form data
   */
  formData: any;

  /**
   * 接口调用成功的回调函数
   */
  success: (result: _uploadFileSuccessany) => void;

  /**
   * 接口调用失败的回调函数
   */
  fail: () => voi


8s.io",
					Kind:     "User",
					Name:     "b",
				},
			},
			wantErr: false,
		},
		{
			Name: "add resource with groups in rolebinding",
			obj: &rbacv1.RoleBinding{
				ObjectMeta: metav1.ObjectMeta{
					Name:      "rolebinding",
					Namespace: "one",
				},
				Subjects: []rbacv1.Subject{
					{
						APIGroup: "rbac.authorization.k8s.io",
						Kind:     "Group",
						Name:     "a",
					},
				},
			},
			subjects: []rbacv1.Subject{
				{
					APIGroup: "rbac.authorization.k8s.io",
					Kind:     "Group",
					Name:     "a",
				},
				{
					APIGroup: "rbac.authorization.k8s.io",
					Kind:     "Group",
					Name:     "b",
				},
			},
			expected: []rbacv1.Subject{
				{
					APIGroup: "rbac.authorization.k8s.io",
					Kind:     "Group",
					Name:     "a",
				},
				{
					APIGroup: "rbac.authorization.k8s.io",
					Kind:     "Group",
					Name:     "b",
				},
			},
			wantErr: false,
		},
		{
			Name: "add resource with serviceaccounts in rolebinding",
			obj: &rbacv1.RoleBinding{
				ObjectMeta: metav1.ObjectMeta{
					Name:      "rolebinding",
					Namespace: "one",
				},
				Subjects: []rbacv1.Subject{
					{
						Kind:      "ServiceAccount",
						Namespace: "one",
						Name:      "a",
					},
				},
			},
			subjects: []rbacv1.Subject{
				{
					Kind:      "ServiceAccount",
					Namespace: "one",
					Name:      "a",
				},
				{
					Kind:      "ServiceAccount",
					Namespace: "one",
					Name:      "b",
				},
			},
			expected: []rbacv1.Subject{
				{
					Kind:      "ServiceAccount",
					Namespace: "one",
					Name:      "a",
				},
				{
					Kind:      "ServiceAccount",
					Namespace: "one",
					Name:      "b",
				},
			},
			wantErr: false,
		},
		{
			Name: "add resource with serviceaccounts in clusterrolebinding",
			obj: &rbacv1.ClusterRoleBinding{
				ObjectMeta: metav1.ObjectMeta{
					Name: "clusterrolebinding",
				},
				Subjects: []rbacv1.Subject{
					{
						APIGroup: "rbac.authorization.k8s.io",
						Kind:     "User",
						Name:     "a",
					},
					{
						APIGroup: "rbac.authorization.k8s.io",
						Kind:     "Group",
						Name:     "a",
					},
				},
			},
			subjects: []rbacv1.Subject{
				{
					Kind:      "ServiceAccount",
					Namespace: "one",
					Name:      "a",
				},
			},
			expected: []rbacv1.Subject{
				{
					APIGroup: "rbac.authorization.k8s.io",
					Kind:     "User",
					Name:     "a",
				},
				{
					APIGroup: "rbac.authorization.k8s.io",
					Kind:     "Group",
					Name:     "a",
				},
				{
					Kind:      "ServiceAccount",
					Namespace: "one",
					Name:      "a",
				},
			},
			wantErr: false,
		},
	}
	for _, tt := range tests {
		if _, err := updateSubjectForObject(tt.


//////////
/ /usr/src/libm/i387/log87.s
/ i387 mathematics library
/ log(x), log10(x), ylog2x
//////////

RASIZE	=	4

	.globl  log10
	.globl	log
	.globl	_ylog2x
/	.globl	_cfcc
	.globl	_tstcc
	.globl	_edomain

//////////
/ double
/ log(x)
/ double x;
/
/ double
/ log10(x)
/ double x;
/
/ ylog2x does the work for log functions and pow().
/ Passed args x, y on the NDP stack,
/ it pops both and returns y * log base 2 of x on the NDP stacktop %st.
/
/ Useful identity:
/	 log base n of x = log base n of 2 * log base 2 of x.
/ Uses fyl2x, which requires x > 0.
//////////

x	=	RASIZE		/ arg offset

log10:
	fldlg2			/ Load y = log base 10 of 2.
	jmp	.L1

log:
	fldln2			/ Load y = log base e of 2.

.L1:
	fldl	x(%esp)		/ Load argument x.

_ylog2x:			/ x, y
	call	_tstcc		/ Check sign of x.
	ja	?2		/ x > 0., ok.
	fstp	%st		/ x <= 0, pop y.
	jmp	_edomai


from pydantic import BaseModel
from typing import List, Dict, Optional

class DocumentChunk(BaseModel):
    content: str
    metadata: Dict[str, str]

class Document(BaseModel):
    file_path: str
    file_type: str
    chunks: List[DocumentChunk]

class Query(BaseModel):
    question: str
    chat_history: Optional[List[Dict]] = None

class QueryResponse(BaseModel):
    answer: str
    sources: List[Dict] = []
    sqlite_results: List[Dict] = []


start.type === 'relative' && end.type === 'relative') {
      if (-start.moment > -end.moment) {
        throw new TypeError('开始时间在结束时间之后');
      }
      if (end.number) {
        throw new TypeError('不支持的结束时间（目前只支持结束时间为当前时间）');
      }
      this.display = {
        type: this.relativeTimes.includes(start.value as string) ? 'fast' : 'relative',
        value: start.value,
        number: start.number,
        unit: start.unit,
        moment: +moment.duration(start.moment as number),
      };
      // $state.go($state.current, {
      //   start: 'now' + (start.value !== '0d' ? `-${start.value}` : ''),
      //   end: 'now' + (end.value !== '0d' ? `-${end.value}` : ''),
      // });
    } else if (start.type === 'absolute' && end.type === 'absolute') {
      if (start.value >= end.value) {
        throw new TypeError('开始时间在结束时间之后');
      }
      this.display = {
        type: 'absolute',
        start: start.value,
        end: end.value,
      };
      // $state.go($state.current, {
      //   start: start.value,
      //   end: end.value,
      // });
    } else {
      throw new TypeError('不支持的时间段类型');
    }
  }

  destroyed() {
    clearInterval(this.refreshPromise);
  }

  setRefresh(t: string) {
    console.log(t)
    clearInterval(this.refreshPromise);

    if (t) {
      const duration = +parseDuration(t);
      this.$emit('update:refreshDuration', t);
      this.refreshPromise = setInterval($event => {
        this.$emit('on-refresh', $event);
      }, duration);
    } else {
      this.$emit('update:refreshDuration', null);
    }
  }

  setRelative(t: string) {
    this.$emit('input', ['now-' + t, 'now']);
  }

  initRelative() {
    this.now = newDateWithoutMilliseconds();
    switch (this.display.type) {
      case 'fast':
      case 'relative':
        this.defaultValue = this.display.number;
        break;

      case 'absolute': {
        const duration = moment.duration(this.display.end as number - (this.display.start as number));
        const unit = ['y', 'M', 'd', 'h', 'm', 's', 'ms'].find(u => duration.get(u as any));
        this.defaultValue = duration.get(unit as any);
        this.setRelative(this.defaultValue + unit);
        break;
      }
    }
    this.relativeValue = this.defaultValue;
  }

  setAbsolute() {
    this.$emit('input', this.absoluteValue.map(x => +new Date(x)));
  }

  initAbsolute() {
    this.now = newDateWithoutMilliseconds();
    switch (this.display.type) {
      case 'fast':
      case 'relative':
        this.absoluteValue = [
          newDateWithoutMilliseconds(+this.now - this.display.moment),
          newDateWithoutMilliseconds(this.now),
        ];
        this.setAbsolute();
        break;

      case 'absolute':
        this.absoluteValue = [
          newDateWithoutMilliseconds(this.display.start),
          newDateWithoutMilliseconds(this.display.end),
        ];
        break;
    }
  }

  switchTab(pane) {
    switch (pane.name) {
      case 'fast':


tput_path) is False

    # Test with exception
    ipfs_storage.ipfs_kit.get.side_effect = Exception("IPFS error")
    assert ipfs_storage.get_file_from_ipfs("QmTestCid", output_path) is False

    # Test with IPFS not available
    ipfs_storage.ipfs_kit = None
    assert ipfs_storage.get_file_from_ipfs("QmTestCid", output_path) is False

def test_calculate_cid(ipfs_storage):
    """Test calculating a CID without adding to IPFS."""
    # Create a test file
    fd, file_path = tempfile.mkstemp()
    os.write(fd, b"test content")
    os.close(fd)

    try:
        # Calculate CID
        cid = ipfs_storage.calculate_cid(file_path)

        # Check result
        assert cid == "QmCalculatedCid1234"

        # Check that calculate_cid was called
        ipfs_storage.ipfs_kit.calculate_cid.assert_called_once_with(file_path)
    finally:
        # Cleanup
        os.remove(file_path)

    # Test with exception
    ipfs_storage.ipfs_kit.calculate_cid.side_effect = Exception("IPFS error")
    assert ipfs_storage.calculate_cid("nonexistent.txt") is None

    # Test with method not available
    del ipfs_storage.ipfs_kit.calculate_cid
    assert ipfs_storage.calculate_cid(file_path) is None

    # Test with IPFS not available
    ipfs_storage.ipfs_kit = None
    assert ipfs_storage.calculate_cid(file_path) is None


}.navbar form .md-form input{margin:0 5px 1px 8px}.navbar .breadcrumb{padding:.3rem 0 0 1rem;margin:0;font-size:15px;font-weight:300;background-color:inherit}.navbar .breadcrumb .breadcrumb-item{color:#fff}.navbar .breadcrumb .breadcrumb-item.active{color:rgba(255,255,255,0.65)}.navbar .breadcrumb .breadcrumb-item:before{color:rgba(255,255,255,0.65)}.navbar .navbar-toggler{border-width:0;outline:0}.navbar .nav-flex-icons{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-direction:row;flex-direction:row}@media (max-width: 992px){.navbar .container{width:100%}.navbar .container .navbar-toggler-right{right:0}}.navbar .nav-item .nav-link{display:block}.navbar .nav-item .nav-link.disabled:active{pointer-events:none}.navbar .nav-item .nav-link .fas,.navbar .nav-item .nav-link .fab,.navbar .nav-item .nav-link .far{padding-right:3px;padding-left:3px}@media (max-width: 992px){.navbar .nav-item .nav-link{padding-right:6px;padding-left:6px}}.navbar .dropdown-menu{position:absolute !important;margin-top:0}.navbar .dropdown-menu a{padding:10px;font-size:.9375rem;font-weight:300}.navbar .dropdown-menu a:not(.active){color:#000}@media (max-width: 600px){.navbar .dropdown-menu form{width:17rem}}@media (min-width: 600px){.navbar .dropdown-menu form{width:22rem}}.navbar.navbar-light .navbar-nav .nav-item .nav-link.disbled{color:rgba(0,0,0,0.3)}.navbar.navbar-light .navbar-nav .nav-item .nav-link.disbled:hover{color:rgba(0,0,0,0.3)}.navbar.navbar-light .navbar-toggler-icon{cursor:pointer;background-image:url("data:image/svg+xml;charset=utf8,%3Csvg viewBox='0 0 32 32' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath stroke='rgba(0, 0, 0, 0.9)' stroke-width='2' stroke-linecap='round' stroke-miterlimit='10' d='M4 8h24M4 16h24M4 24h24'/%3E%3C/svg%3E")}.navbar.navbar-light .breadcrumb .nav-item .nav-link,.navbar.navbar-light .navbar-nav .nav-item .nav-link{color:#000;-webkit-transition:.35s;transition:.35s}.navbar.navbar-light .breadcrumb .nav-item .nav-link:hover,.navbar.navbar-light .navbar-nav .nav-item .nav-link:hover{color:rgba(0,0,0,0.7)}.navbar.navbar-light .breadcrumb .nav-item.active>.nav-link,.navbar.navbar-light .navbar-nav .nav-item.active>.nav-link{background-color:rgba(0,0,0,0.1)}.navbar.navbar-light .breadcrumb .nav-item.active>.nav-link:hover,.navbar.navbar-light .navbar-nav .nav-item.active>.nav-link:hover{color:#000}.navbar.navbar-light .navbar-toggler{color:#000}.navbar.navbar-light form .md-form input{border-bottom:1px solid #000}.navbar.navbar-light form .md-form input:focus:not([readonly]){border-color:#4285f4}.navbar.navbar-light form .md-form .form-control{color:#000}.navbar.navbar-light form .md-form .form-control::-webkit-input-placeholder


def calculaArea(largura, altura):
     area = largura * altura
     print(area)

def calculoPerimentro(largura, altura):
    perimetro = (2 * largura) + (2 * altura)
    return perimetro

largura = int(input("Digite a largura desejada :"))
altura = int(input("Digite a altura desejada :"))

#print(calculoPerimentro(5,3))
#calculaArea(altura, largura)


CT) {
	    dictid = 1; /* adler32(0, null, 0)*/
	    /* dictid = adler32(dictid, dictionary, dictLength); */
	    dictid = adler32(dictid, dictionary, dictLength, 0);
	    if (dictid !== state.check) {
	      return Z_DATA_ERROR;
	    }
	  }
	  /* copy dictionary to window using updatewindow(), which will amend the
	   existing dictionary if appropriate */
	  ret = updatewindow(strm, dictionary, dictLength, dictLength);
	  if (ret) {
	    state.mode = MEM;
	    return Z_MEM_ERROR;
	  }
	  state.havedict = 1;
	  // Tracev((stderr, "inflate:   dictionary set\n"));
	  return Z_OK;
	}

	exports.inflateReset = inflateReset;
	exports.inflateReset2 = inflateReset2;
	exports.inflateResetKeep = inflateResetKeep;
	exports.inflateInit = inflateInit;
	exports.inflateInit2 = inflateInit2;
	exports.inflate = inflate;
	exports.inflateEnd = inflateEnd;
	exports.inflateGetHeader = inflateGetHeader;
	exports.inflateSetDictionary = inflateSetDictionary;
	exports.inflateInfo = 'pako inflate (from Nodeca project)';

	/* Not implemented
	exports.inflateCopy = inflateCopy;
	exports.inflateGetDictionary = inflateGetDictionary;
	exports.inflateMark = inflateMark;
	exports.inflatePrime = inflatePrime;
	exports.inflateSync = inflateSync;
	exports.inflateSyncPoint = inflateSyncPoint;
	exports.inflateUndermine = inflateUndermine;
	*/

/***/ }),
/* 69 */
/***/ (function(module, exports) {

	'use strict';

	// See state defs from inflate.js
	var BAD = 30;       /* got a data error -- remain here until reset */
	var TYPE = 12;      /* i: waiting for type bits, including last-flag bit */

	/*
	   Decode literal, length, and distance codes and write out the resulting
	   literal and match bytes until either not enough input or output is
	   available, an end-of-block is encountered, or a data error is encountered.
	   When large enough input and output buffers are supplied to inflate(), for
	   example, a 16K input buffer and a 64K output buffer, more than 95% of the
	   inflate execution time is spent in this routine.

	   Entry assumptions:

	        state.mode === LEN
	        strm.avail_in >= 6
	        strm.avail_out >= 258
	        start >= strm.avail_out
	        state.bits < 8

	   On return, state.mode is one of:

	        LEN -- ran out of enough output space or enough available input
	        TYPE -- reached end of block code, inflate() to interpret next block
	        BAD -- error in block data

	   Notes:

	    - The maximum input bits used by a length/distance pair is 15 bits for the
	      length code, 5 bits for the length extra, 15 bits for the distance code,
	      and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
	      Therefore if strm.avail_in >= 6, then there is enough input to avoid
	      checking for available input while decoding.

	    - The maximum bytes that a single length/distance pair can output is 258
	      bytes, which is the maximum length that can be coded.  inflate_fast()
	      requires strm.avail_out >= 258 for each loop to avoid checking for
	      output space.
	 */
	module.exports = function inflate_fast(strm, start) {
	  var state;
	  var _in;                    /* local strm.input */


callback fun(result_device: SMM_Device)
function M.show_results_window(results, callback)
  -- Create Telescope picker
  local pickers = require 'telescope.pickers'
  local finders = require 'telescope.finders'
  local conf = require('telescope.config').values
  local actions = require 'telescope.actions'
  local action_state = require 'telescope.actions.state'

  local title = ' Spotify Devices'

  if require('smm.config').get().icons == true then
    title = '  ' .. title
  end

  pickers
    .new({}, {
      prompt_title = title,
      finder = finders.new_table {
        results = results,
        entry_maker = function(result)
          local display_text, ordinal_text = format_result(result)
          return {
            value = result,
            display = display_text,
            ordinal = ordinal_text,
          }
        end,
      },
      sorter = conf.generic_sorter {},
      attach_mappings = function(prompt_bufnr, _)
        actions.select_default:replace(function()
          actions.close(prompt_bufnr)
          local selection = action_state.get_selected_entry()
          if selection and callback then
            callback(selection.value)
          end
        end)
        return true
      end,
    })
    :find()
end

return M


/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (C) 2020 MediaTek Inc.
 *
 * Author:  Weijie Gao <weijie.gao@mediatek.com>
 */

#ifndef _MT7628_H_
#define _MT7628_H_

#define SYSCTL_BASE			0x10000000
#define SYSCTL_SIZE			0x100
#define MEMCTL_BASE			0x10000300
#define MEMCTL_SIZE			0x100
#define RBUSCTL_BASE			0x10000400
#define RBUSCTL_SIZE			0x100
#define RGCTL_BASE			0x10001000
#define RGCTL_SIZE			0x800

#define SYSCTL_EFUSE_CFG_REG		0x08
#define EFUSE_MT7688			0x100000

#define SYSCTL_CHIP_REV_ID_REG		0x0c
#define PKG_ID				0x10000
#define PKG_ID_AN			1
#define PKG_ID_KN			0
#define VER_S				8
#define VER_M				0xf00
#define ECO_S				0
#define ECO_M				0x0f

#define SYSCTL_SYSCFG0_REG		0x10
#define XTAL_FREQ_SEL			0x40
#define XTAL_40MHZ			1
#define XTAL_25MHZ			0
#define CHIP_MODE_S			1
#define CHIP_MODE_M			0x0e
#define DRAM_TYPE			0x01
#define DRAM_DDR1			1
#define DRAM_DDR2			0

#define SYSCTL_ROM_STATUS_REG		0x28

#define SYSCTL_CLKCFG0_REG		0x2c
#define DIS_BBP_SLEEP			0x08
#define EN_BBP_CLK			0x04
#define CPU_PLL_FROM_BBP		0x02
#define CPU_PLL_FROM_XTAL		0x01

#define SYSCTL_RSTCTL_REG		0x34
#define MC_RST				0x400

#define SYSCTL_AGPIO_CFG_REG		0x3c
#define EPHY_GPIO_AIO_EN_S		17
#define EPHY_GPIO_AIO_EN_M		0x1e0000

#define SYSCTL_GPIO_MODE1_REG		0x60
#define UART2_MODE_S			26
#define UART2_MODE_M			0xc000000
#define UART1_MODE_S			24
#define UART1_MODE_M			0x3000000
#define UART0_MODE_S			8
#define UART0_MODE_M			0x300
#define SPIS_MODE_S			2
#define SPIS_MODE_M			0x0c

#define RBUSCTL_DYN_CFG0_REG		0x40
#define CPU_FDIV_S			8
#define CPU_FDIV_M			0xf00
#define CPU_FFRAC_S			0
#define CPU_FFRAC_M			0x0f

#define RGCTL_PMU_G0_REG		0x100
#define PMU_CFG_EN			0x80000000

#define RGCTL_PMU_G1_REG		0x104
#define RG_BUCK_FPWM			0x02

#define RGCTL_PMU_G3_REG		0x10c
#define NI_DDRLDO_STB			0x40000
#define NI_DDRLDO_EN			0x10000
#define RG_DDRLDO_VOSEL			0x40

#define RGCTL_DDR_PAD_CK_G0_REG		0x700
#define RGCTL_DDR_PAD_CMD_G0_REG	0x708
#define RGCTL_DDR_PAD_DQ_G0_REG		0x710
#define RGCTL_DDR_PAD_DQS_G0_REG	0x718
#define RTT_S				8
#define RTT_M				0x700

#define RGCTL_DDR_PAD_CK_G1_REG		0x704
#define RGCTL_DDR_PAD_CMD_G1_REG	0x70c
#define RGCTL_DDR_PAD_DQ_G1_REG		0x714
#define RGCTL_DDR_PAD_DQS_G1_REG	0x71c
#define DRVP_S				0
#define DRVP_M				0x0f
#define DRVN_S				8
#define DRVN_M				0xf00

#ifndef __ASSEMBLY__
void mt7628_ddr_init(void);
#endif

#endif /* _MT7628_H_ */


/******************************************************************************
 *
 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
 *
 *
 ******************************************************************************/
#ifndef __RTL8188E_LED_H__
#define __RTL8188E_LED_H__

#include <osdep_service.h>
#include <drv_types.h>

/*  */
/*  Interface to manipulate LED objects. */
/*  */
void rtl8188eu_InitSwLeds(struct adapter *padapter);
void rtl8188eu_DeInitSwLeds(struct adapter *padapter);
void SwLedOn(struct adapter *padapter, struct LED_871x *pLed);
void SwLedOff(struct adapter *padapter, struct LED_871x *pLed);

#endif


neral Public License, version 3 or any later version (LGPLv3 or
// later), or the GNU General Public License, version 2 (GPLv2), in all
// cases as published by the Free Software Foundation.
//

package glusterfs

import (
	"fmt"
	"reflect"
	"sort"

	"github.com/boltdb/bolt"
	"github.com/heketi/heketi/v10/executors"
)

type ExaminerMode string

const (
	OnDemandExaminer ExaminerMode = "ondemand"
	OfflineExaminer  ExaminerMode = "offline"
)

type Examiner struct {
	db        *bolt.DB
	executor  executors.Executor
	optracker *OpTracker
	mode      ExaminerMode
}

type NodeData struct {
	NodeHeketiID      string
	VolumeInfo        *executors.VolInfo
	LVMPVInfo         *executors.PVSCommandOutput
	LVMVGInfo         *executors.VGSCommandOutput
	LVMLVInfo         *executors.LVSCommandOutput
	BricksMountStatus *executors.BricksMountStatus
	BlockVolumeNames  []string
}

type ClusterData struct {
	ClusterHeketiID string
	NodesData       []NodeData
}

type GlusterStateExaminationResponse struct {
	HeketiDB Db            `json:"heketidb"`
	Report   []string      `json:"report"`
	Clusters []ClusterData `json:"clusters"`
}

func (examiner Examiner) fetchClusterData(cluster ClusterEntry, heketidb Db) (clusterdata ClusterData, errorstrings []string) {

	clusterdata.ClusterHeketiID = cluster.Info.Id

	for _, node := range cluster.Info.Nodes {
		nodeEntry := heketidb.Nodes[node]
		var nodedata NodeData
		nodedata.NodeHeketiID = nodeEntry.Info.Id
		host := nodeEntry.ManageHostName()

		// Volume Info
		volinfo, err := examiner.executor.VolumesInfo(host)
		if err != nil {
			errorstrings = append(errorstrings, fmt.Sprintf("could not fetch data from node %v", host))
		} else {
			nodedata.VolumeInfo = volinfo
		}

		// Device Info
		nodedata.LVMPVInfo, err = examiner.executor.PVS(host)
		if err != nil {
			errorstrings = append(errorstrings, fmt.Sprintf("could not fetch LVM pvs data from node %v : %v", host, err))
		}
		nodedata.LVMVGInfo, err = examiner.executor.VGS(host)
		if err != nil {
			errorstrings = append(errorstrings, fmt.Sprintf("could not fetch LVM vgs data from node %v : %v", host, err))
		}
		nodedata.LVMLVInfo, err = examiner.executor.LVS(host)
		if err != nil {
			errorstrings = append(errorstrings, fmt.Sprintf("could not fetch LVM lvs data from node %v : %v", host, err))
		}

		// Brick Info
		nodedata.BricksMountStatus, err = examiner.executor.GetBrickMountStatus(host)
		if err != nil {
			errorstrings = append(errorstrings, fmt.Sprintf("could not fetch brick mount status from node %v : %v", host, err))
		}

		// Block Volume Info
		for _, blockHostingVolume := range heketidb.Volumes {
			if blockHostingVolume.Info.Block {
				names, err := examiner.executor.ListBlockVolumes(host, blockHostingVolume.Info.Name)
				if err != nil {
					errorstrings = append(errorstrings, fmt.Sprintf("could not fetch block volume list for block hosting volume %v : %v", blockHostingVolume.Info.Id, err))
				}
				for _, name := range names {
					nodedata


wner)
    })

    it('should meow', () => {
        expect(cat.meow()).to.be.eq("mew?")
    })
})

describe("Dogs", () => {
    it('should have a name', () => {
        expect(dog.name).to.be.eq("Rover")
    })

    it('should have an owner', () => {
        expect(dog.owner).to.be.eq(petOwner)
    })

    it('should not be a large animal', () => {
        expect(dog.isLargeAnimal).to.be.false
    })

    it('should bark', () => {
        expect(dog.bark()).to.be.eq("Woof!")
    })
})
export const required = (value: string): boolean => (value ? true : false);

export const isEmail = (value: string): boolean =>
  /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$/i.test(value) ? true : false;

const maxLength = (value: string, max: number) =>
  value.length > max ? false : true;

export const maxLength400 = (value: string) => maxLength(value, 400);
import { Component, OnInit } from '@angular/core';
import { Router } from '@angular/router';
import { GameControllerService } from './../../services/game-controller.service';
import {
  Hero,
  Monster,
  BaseCharacter,
  FightOptions,
  Warrior,
  Ranger,
  Rogue,
  Priest
} from '../../models/characters';

enum Teams {
  heroes,
  enemies,
  none
}

@Component({
  selector: 'app-fight',
  templateUrl: './fight.component.html',
  styleUrls: ['./fight.component.css']
})
export class FightComponent implements OnInit {
  // heroParty;
  // enemyParty;
  // displayMessage;
  // successMessages;
  // selectedAction;
  // _fightOptions;
  // showNextChapterButton = false;
  // showGameOverButton = false;
  constructor(
    private gameControllerService: GameControllerService,
    private router: Router
  ) {}

  heroTurn = true;
  actionDelay: number = this.gameControllerService.actionDeley;
  turnsBetweenSpecial = 2;
  characterIndex = 0;
  freezeActions = false;

  heroParty: Hero[] = this.gameControllerService.heroParty;
  heroesIncapacitated = 0;
  enemyParty: Monster[] = this.gameControllerService.enemyParty;
  enemiesIncapacitated = 0;

  currentCharacter: BaseCharacter = this.heroParty[this.characterIndex];
  _fightOptions: typeof FightOptions = FightOptions;
  _teams: typeof Teams = Teams;
  selectedAction: FightOptions = FightOptions.none;
  availableTargets: Teams = Teams.none;
  selectedTargets: BaseCharacter[] = [];

  displayMessage = `${this.currentCharacter.name} - twoja kolej`;
  successMessages: string[] = [];
  showNextChapterButton = false;
  showGameOverButton = false;

  ngOnInit() {}

  selectOption(selectedOption: FightOptions) {
    console.log('select option: ', selectedOption);
    if (this.freezeActions && this.heroTurn) {
      return;
    }

    this.selectedAction = selectedOption;
    this.selectedTargets = [];

    if (this.selectedAction === FightOptions.attack) {
      this.availableTargets = Teams.enemies;
      this.displayMessage = 'Wybierz cel twojego ataku';
    } else if (
      this.selectedAction === FightOptions.specialAttack &&
      this.currentCharacter instanceof Hero &&
      this.currentCharacter.level < 3
    ) {
      this.displayMessage =
        'Specjalne ataki odblokow


"ｄ" to SymbolCategory.ALPHABET_LATIN,
    "ｅ" to SymbolCategory.ALPHABET_LATIN,
    "ｆ" to SymbolCategory.ALPHABET_LATIN,
    "ｇ" to SymbolCategory.ALPHABET_LATIN,
    "ｈ" to SymbolCategory.ALPHABET_LATIN,
    "ｉ" to SymbolCategory.ALPHABET_LATIN,
    "ｊ" to SymbolCategory.ALPHABET_LATIN,
    "ｋ" to SymbolCategory.ALPHABET_LATIN,
    "ｌ" to SymbolCategory.ALPHABET_LATIN,
    "ｍ" to SymbolCategory.ALPHABET_LATIN,
    "ｎ" to SymbolCategory.ALPHABET_LATIN,
    "ｏ" to SymbolCategory.ALPHABET_LATIN,
    "ｐ" to SymbolCategory.ALPHABET_LATIN,
    "ｑ" to SymbolCategory.ALPHABET_LATIN,
    "ｒ" to SymbolCategory.ALPHABET_LATIN,
    "ｓ" to SymbolCategory.ALPHABET_LATIN,
    "ｔ" to SymbolCategory.ALPHABET_LATIN,
    "ｕ" to SymbolCategory.ALPHABET_LATIN,
    "ｖ" to SymbolCategory.ALPHABET_LATIN,
    "ｗ" to SymbolCategory.ALPHABET_LATIN,
    "ｘ" to SymbolCategory.ALPHABET_LATIN,
    "ｙ" to SymbolCategory.ALPHABET_LATIN,
    "ｚ" to SymbolCategory.ALPHABET_LATIN,
    "Á" to SymbolCategory.ALPHABET_LATIN,
    "É" to SymbolCategory.ALPHABET_LATIN,
    "Í" to SymbolCategory.ALPHABET_LATIN,
    "Ó" to SymbolCategory.ALPHABET_LATIN,
    "Ú" to SymbolCategory.ALPHABET_LATIN,
    "á" to SymbolCategory.ALPHABET_LATIN,
    "é" to SymbolCategory.ALPHABET_LATIN,
    "í" to SymbolCategory.ALPHABET_LATIN,
    "ó" to SymbolCategory.ALPHABET_LATIN,
    "ú" to SymbolCategory.ALPHABET_LATIN,
    "Ä" to SymbolCategory.ALPHABET_LATIN,
    "Ö" to SymbolCategory.ALPHABET_LATIN,
    "Ü" to SymbolCategory.ALPHABET_LATIN,
    "ä" to SymbolCategory.ALPHABET_LATIN,
    "ö" to SymbolCategory.ALPHABET_LATIN,
    "ü" to SymbolCategory.ALPHABET_LATIN,
    "À" to SymbolCategory.ALPHABET_LATIN,
    "È" to SymbolCategory.ALPHABET_LATIN,
    "Ì" to SymbolCategory.ALPHABET_LATIN,
    "Ò" to SymbolCategory.ALPHABET_LATIN,
    "Ù" to SymbolCategory.ALPHABET_LATIN,
    "à" to SymbolCategory.ALPHABET_LATIN,
    "è" to SymbolCategory.ALPHABET_LATIN,
    "ì" to SymbolCategory.ALPHABET_LATIN,
    "ò" to SymbolCategory.ALPHABET_LATIN,
    "ù" to SymbolCategory.ALPHABET_LATIN,
    "Â" to SymbolCategory.ALPHABET_LATIN,
    "Ê" to SymbolCategory.ALPHABET_LATIN,
    "Î" to SymbolCategory.ALPHABET_LATIN,
    "Ô" to SymbolCategory.AL


/* simple OMP offload kernel from Jeff Sandoval 9/22/2020 */

#include <omp.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>

#ifdef USE_MPI
#include "mpi.h"
#include <unistd.h>
#endif

int main(int argc, char* argv[]) {

    int delay = 20;
    int iters = 1000;

    if (argc > 1) {
	delay = atoi(argv[1]);
    }
    if (argc > 2) {
	iters = atoi(argv[2]);
    }
#ifdef USE_MPI
    int ierr = MPI_Init(&argc, &argv);
    if (ierr != MPI_SUCCESS) {
        fprintf(stderr,"Error: MPI_init() failed: %d\n", ierr);
    }
    int rank;
    ierr = MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    if (ierr != MPI_SUCCESS) {
        fprintf(stderr, "Error: MPI_init() failed: %d\n", ierr);
    }
    int num_ranks;
    ierr = MPI_Comm_size(MPI_COMM_WORLD, &num_ranks);
    if (ierr != MPI_SUCCESS) {
        fprintf(stderr, "Error: MPI_init() failed: %d\n", ierr);
    }

    fprintf(stderr, "max number of threads %d\n", omp_get_max_threads());
    if (delay > 0) {
        fprintf(stderr, "sleeping for %d seconds\n", delay);
        sleep(delay);
        fprintf(stderr, "continuing\n");
    }
#endif

  int runningOnGPU = 0;
  int checkVal=-1;
  const int nCells=1000000;
  double* m_gate = (double*)calloc(nCells,sizeof(double));
  double* Vm = (double*)calloc(nCells,sizeof(double));

  const double Mhu_a[] = { 9.9632117206253790e-01,  4.0825738726469545e-02,  6.3401613233199589e-04,  4.4158436861700431e-06,  1.1622058324043520e-08,  1.0000000000000000e+00,  4.0568375699663400e-02,  6.4216825832642788e-04,  4.2661664422410096e-06,  1.3559930396321903e-08, -1.3573468728873069e-11, -4.2594802366702580e-13,  7.6779952208246166e-15,  1.4260675804433780e-16, -2.6656212072499249e-18};

  const double Tau_a[] = {1.7765862602413648e+01*0.02,  5.0010202770602419e-02*0.02, -7.8002064070783474e-04*0.02, -6.9399661775931530e-05*0.02,  1.6936588308244311e-06*0.02,  5.4629017090963798e-07*0.02, -1.3805420990037933e-08*0.02, -8.0678945216155694e-10*0.02,  1.6209833004622630e-11*0.02,  6.5130101230170358e-13*0.02, -6.9931705949674988e-15*0.02, -3.1161210504114690e-16*0.02,  5.0166191902609083e-19*0.02,  7.8608831661430381e-20*0.02,  4.3936315597226053e-22*0.02, -7.0535966258003289e-24*0.02, -9.0473475495087118e-26*0.02, -2.9878427692323621e-28*0.02,  1.0000000000000000e+00};

#pragma omp target enter data map(to: m_gate[:nCells])
#pragma omp target enter data map(to: Vm[:nCells])

  for (int itime=0; itime<iters; itime++) {
    #pragma omp target teams distribute parallel for thread_limit(128) map(from:checkVal)
    for (int ii=0; ii<nCells; ii++) {
      double sum1,sum2;
      const double x = Vm[ii];
      const int Mhu_l = 10;
      const int Mhu_m = 5;

      sum1 = 0;
      for (int j = Mhu_m-1; j >= 0; j--)
         sum1 = Mhu_a[j] + x*sum1;

      sum2 = 0;
      int k = Mhu_m + Mhu_l - 1;
      for (int j = k; j >= Mhu_m; j--)
         sum2 = Mhu_a[j] + x * sum2;
      double mhu = sum1/sum2;

      const int Tau_m = 18;
     sum1 = 0;
      for (int j = Tau_m-1; j >= 0; j--)
         sum1 = Tau_a[j] + x*sum1;

      double tauR = sum1;
      m_gate[ii] += (mhu - m_gate[ii])*(1-exp(-tauR));
      if (ii == 0)
         checkVal=(int) (1000000.0 * m_gate[ii]);
    }
  }

  /* Test if GPU is available using OpenMP4.5 */
#pragma omp target map(from:runningOnGPU)
  {
    if (omp_is_initial_device() == 0)
      runningOnGPU = 1;
  }
  /* If still running on CPU, GPU must not be available */
  if (runningOnGPU && (iters != 1000 || checkVal == 996321) ) {
    printf("PASS\n");
  } else if (!runningOnGPU) {
    printf("FAIL - not running on a GPU\n");
    return 1;
  } else {
    printf("FAIL iters=%d checkDelta=%d\n", iters, checkVal-996321);
    return 1;
  }

#ifdef USE_MPI
    ierr = MPI_Finalize();
    if (ierr != MPI_SUCCESS) {
        fprintf(stderr, "Error: MPI_Finalize() failed: %d\n", ierr);
	return 1;
    }
#endif

  return 0;
}


.16.m1.2.2.2.2.1.1.2" maxsize="80%" minsize="80%" xref="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.cmml">(</mo><mrow id="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1" xref="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.cmml"><mn id="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.2" mathsize="80%" xref="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.2.cmml">12</mn><mo id="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.1" mathsize="80%" xref="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.1.cmml">−</mo><mrow id="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.3" xref="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.3.cmml"><mn id="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.3.2" mathsize="80%" xref="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.3.2.cmml">6</mn><mo id="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.3.1" xref="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.3.1.cmml"></mo><msqrt id="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.3.3" xref="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.3.3.cmml"><mn id="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.3.3.2" mathsize="80%" xref="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.3.3.2.cmml">3</mn></msqrt></mrow></mrow><mo id="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.3" maxsize="80%" minsize="80%" xref="S4.F8.16.16.16.16.16.m1.2.2.2.2.1.1.1.cmml">)</mo></mrow><mn id="S4.F8.16.16.16.16.16.m1.2.2.2.2.3" mathsize="80%" xref="S4.F8.16.16.16.16.16.m1.2.2.2.2.3.cmml">2</mn></msup></mrow><mo id="S4.F8.16.16.16.16.16.m1.2.2.6" mathsize="80%" xref="S4.F8.16.16.16.16