nsigne Foudrepique grade 3",
[17902] = "Insigne Foudrepique grade 4",
[17903] = "Insigne Foudrepique grade 5",
[17904] = "Insigne Foudrepique grade 6",
[17905] = "Insigne Loup-de-givre grade 2",
[17906] = "Insigne Loup-de-givre grade 3",
[17907] = "Insigne Loup-de-givre grade 4",
[17908] = "Insigne Loup-de-givre grade 5",
[17909] = "Insigne Loup-de-givre grade 6",
[17922] = "Armure en fourrure de lion",
[17942] = "Monster - Mace2H, War Maul",
[17943] = "Poing de pierre",
[17962] = "Sac de gemmes bleu",
[17963] = "Sac de gemmes vert",
[17964] = "Sac de gemmes gris",
[17965] = "Sac de gemmes jaune",
[17966] = "Sac à dos en cuir d'Onyxia",
[17968] = "Ecaille d'Onyxia chargée",
[17969] = "Sac de gemmes rouge",
[17982] = "Noyau de Ragnaros",
[18002] = "Monster - Axe, 2H Horde Massive Spiked Blue",
[18022] = "Sceau royal d'Alexis",
[18042] = "Flèches à pointe de thorium",
[18043] = "Bottes du mineur de charbon",
[18044] = "Pinte d'Hurley",
[18045] = "Steak de loup tendre",
[18046] = "Recette : Steak de loup tendre",
[18047] = "Brodequins des flammes",
[18048] = "Marteau du maître-forgeron",
[18062] = "Monster - Mace2H, Horde Hammer A03/C01Black",
[18082] = "Canne vexatoire de Zum'rah",
[18083] = "Poignes de Jumanza",
[18102] = "Bottes de monteur de dragon",
[18103] = "Bague de rumination",
[18104] = "Ceinturon de sauvagerie",
[18122] = "Monster - Staff, Ornate Jeweled Staff - Blue High Blue Glow",
[18123] = "Monster - Staff, Feathered Silver Glow",
[18142] = "Tête coupée d'elfe de la nuit",
[18143] = "Touffe de cheveux de gnome",
[18144] = "Bout d'os humain",
[18145] = "Sabot de tauren",
[18146] = "Mojo de troll sombrelance",
[18147] = "Coeur de Réprouvé",
[18148] = "Crâne de Korrak",
[18149] = "Rune de rappel",
[18150] = "Rune de rappel",
[18151] = "Fiole d'améthyste remplie",
[18152] = "Fiole d'améthyste",
[18154] = "Papier à lettre Blizzard",
[18160] = "Recette : Thé de chardon",
[18166] = "Monster - Shield, Royal Dreadguard",
[18167] = "Monster - Sword, Machete C01",
[18168] = "Disque de force réactif",
[18169] = "Mantelet de l'Aube de flammes",
[18170] = "Mantelet de l'Aube de givre",
[18171] = "Mantelet de l'Aube des arcanes",
[18172] = "Mantelet de l'Aube de la nature",
[18173] = "Mantelet de l'Aube de l'ombre",


11 15.39-3.88 3.88a2.52 2.52 0 0 1-3.5 0 2.47 2.47 0 0 1 0-3.5l3.88-3.88a1 1 0 0 0-1.42-1.42l-3.88 3.89a4.48 4.48 0 0 0 6.33 6.33l3.89-3.88a1 1 0 1 0-1.42-1.42Zm8.58-12.08a4.49 4.49 0 0 0-6.33 0l-3.89 3.88a1 1 0 0 0 1.42 1.42l3.88-3.88a2.52 2.52 0 0 1 3.5 0 2.47 2.47 0 0 1 0 3.5l-3.88 3.88a1 1 0 1 0 1.42 1.42l3.88-3.89a4.49 4.49 0 0 0 0-6.33ZM8.83 15.17a1 1 0 0 0 1.1.22 1 1 0 0 0 .32-.22l4.92-4.92a1 1 0 0 0-1.42-1.42l-4.92 4.92a1 1 0 0 0 0 1.42Z"></path>
			</svg>

To change authoritative nameserver behavior — how we choose IPs —  a Cloudflare engineer encodes their desired DNS business objective as a declarative Topaz program. Our nameserver stores the list of all such programs such that when it receives a DNS query for a proxied domain, it executes the list of programs in sequence until one returns an IP address. It then returns that IP to the resolver.

Topaz receives DNS queries (metadata included) for proxied domains from Cloudflare’s nameserver. It executes a list of policies in sequence until a match is found. It returns the resulting IP address to the nameserver, which forwards it to the resolver.

What do these programs look like?

Each Topaz program has three primary components:

Match function: A program’s match function specifies under which circumstances the program should execute. It takes as input DNS query metadata (e.g., datacenter information, account information) and outputs a boolean. If, given a DNS query, the match function returns true, the program’s response function is executed.

Response function: A program’s response function specifies which IP addresses should be chosen. It also takes as input all the DNS query metadata, but outputs a 3-tuple (IPv4 addresses, IPv6 addresses, and TTL). When a program’s match function returns true, its corresponding response function is executed. The resulting IP addresses and TTL are returned to the resolver that made the query.

Configuration: A program’s configuration is a set of variables that parameterize that program’s match and response function. The match and response functions reference variables in the corresponding configuration, thereby separating the macro-level behavior of a program (match/response functions) from its nitty-gritty details (specific IP addresses, names, etc.). This separation makes it easier to understand how a Topaz program behaves at a glance, without getting bogged down by specific function parameters.

Let’s walk through an example Topaz program. The goal of this program is to give all queried domains whose metadata field “tag1” is equal to “orange” a particular IP address. The program looks like this:

- name: orange
  config:


#!/usr/bin/env python3
"""Test the impact of the Unicode case handling bug"""

import sys
sys.path.insert(0, '/root/hypothesis-llm/envs/lml_env/lib/python3.13/site-packages')

from lml.plugin import PluginInfo, PluginManager

# Test with Turkish locale-specific characters
# In Turkish, 'i'.upper() = 'İ' (with dot) and 'ı'.upper() = 'I' (without dot)

class TestPlugin:
    """A simple test plugin"""
    pass

# Create a plugin manager
manager = PluginManager("test_type")

# Register a plugin with tag 'ıstanbul' (starts with dotless i)
plugin_info = PluginInfo("test_type", tags=['ıstanbul'])
plugin_info.cls = TestPlugin
manager.load_me_later(plugin_info)

print("Registered plugin with tag 'ıstanbul'")
print(f"Registry keys: {list(manager.registry.keys())}")
print()

# Try to retrieve it with the original tag
try:
    plugin = manager.load_me_now('ıstanbul')
    print(f"SUCCESS: Retrieved plugin with key 'ıstanbul'")
except Exception as e:
    print(f"FAILED: Could not retrieve plugin with key 'ıstanbul'")
    print(f"Error: {e}")
print()

# The plugin is actually stored under 'istanbul' (with regular i)
try:
    plugin = manager.load_me_now('istanbul')
    print(f"SUCCESS: Retrieved plugin with key 'istanbul' (different from original!)")
except Exception as e:
    print(f"FAILED: Could not retrieve plugin with key 'istanbul'")
    print(f"Error: {e}")


->GetUnknown0x58()) {
		LegoCacheSound* clone = p_sound->Clone();

		if (clone) {
			LegoCacheSound* sound = ManageSoundEntry(clone);
			sound->Play(p_name, p_looping);
			return sound;
		}
	}
	else {
		p_sound->Play(p_name, p_looping);
		return p_sound;
	}

	return NULL;
}

// FUNCTION: LEGO1 0x1003db80
// FUNCTION: BETA10 0x100656a7
void LegoCacheSoundManager::Stop(LegoCacheSound*& p_sound)
{
#ifdef COMPAT_MODE
	Set100d6b4c::iterator setIter;
	for (setIter = m_set.begin(); setIter != m_set.end(); setIter++) {
#else
	for (Set100d6b4c::iterator setIter = m_set.begin(); setIter != m_set.end(); setIter++) {
#endif
		if ((*setIter).GetSound() == p_sound) {
			p_sound->Stop();
			return;
		}
	}

#ifdef COMPAT_MODE
	List100d6b4c::iterator listIter;
	for (listIter = m_list.begin();; listIter++) {
#else
	for (List100d6b4c::iterator listIter = m_list.begin();; listIter++) {
#endif
		if (listIter == m_list.end()) {
			return;
		}

		LegoCacheSound* sound = (*listIter).GetSound();
		if (sound == p_sound) {
			p_sound->Stop();
			return;
		}
	}
}

// FUNCTION: LEGO1 0x1003dc40
void LegoCacheSoundManager::Destroy(LegoCacheSound*& p_sound)
{
#ifdef COMPAT_MODE
	Set100d6b4c::iterator setIter;
	for (setIter = m_set.begin(); setIter != m_set.end(); setIter++) {
#else
	for (Set100d6b4c::iterator setIter = m_set.begin(); setIter != m_set.end(); setIter++) {
#endif
		if ((*setIter).GetSound() == p_sound) {
			p_sound->Stop();

			delete p_sound;
			m_set.erase(setIter);
			return;
		}
	}

#ifdef COMPAT_MODE
	List100d6b4c::iterator listIter;
	for (listIter = m_list.begin();; listIter++) {
#else
	for (List100d6b4c::iterator listIter = m_list.begin();; listIter++) {
#endif
		if (listIter == m_list.end()) {
			return;
		}

		LegoCacheSound* sound = (*listIter).GetSound();
		if (sound == p_sound) {
			p_sound->Stop();

			delete sound;
			m_list.erase(listIter);
			return;
		}
	}
}
#include "act2actor.h"

#include "3dmanager/lego3dmanager.h"
#include "act2main_actions.h"
#include "anim/legoanim.h"
#include "legoact2.h"
#include "legobuildingmanager.h"
#include "legocachesoundmanager.h"
#include "legopathcontroller.h"
#include "legopathedgecontainer.h"
#include "legoplantmanager


add r0, r6, #0
	bl FX_SinFx64c
	str r0, [sp, #8]
	add r0, r6, #0
	add r7, r1, #0
	bl FX_CosFx64c
	str r0, [sp, #0xc]
	add r6, r1, #0
	ldr r0, [sp, #8]
	add r1, r7, #0
	bl _f_lltof
	ldr r1, _02260778 ; =0x4F800000
	bl _fdiv
	add r7, r0, #0
	ldr r0, [sp, #0xc]
	add r1, r6, #0
	bl _f_lltof
	ldr r1, _02260778 ; =0x4F800000
	bl _fdiv
	add r6, r0, #0
	ldr r1, [sp, #4]
	add r0, r7, #0
	bl _fdiv
	add r7, r0, #0
	ldr r0, [sp]
	add r1, r7, #0
	str r6, [sp, #0x10]
	bl _fmul
	str r0, [sp, #0x14]
	add r0, r4, #0
	add r1, r7, #0
	bl _fmul
	mov r2, #0x19
	str r0, [sp, #0x18]
	mov r0, #0
	lsl r2, r2, #4
	str r0, [sp, #0x1c]
	add r0, r5, r2
	add r2, #0x10
	add r1, sp, #0x10
	add r2, r5, r2
	bl ov92_02263108
	mov r1, #0x15
	lsl r1, r1, #4
	add r0, r5, r1
	add r1, #0x40
	add r1, r5, r1
	bl ov92_022632E8
	mov r1, #0x1a
	lsl r1, r1, #4
	add r0, r5, r1
	sub r1, #0x10
	add r1, r5, r1
	bl ov92_022630F8
	mov r1, #0x15
	lsl r1, r1, #4
	add r0, r5, r1
	add r1, #0x60
	add r1, r5, r1
	bl ov92_02263824
	add sp, #0x20
	mov r0, #1
	pop {r3, r4, r5, r6, r7, pc}
_0226076E:
	mov r0, #0
	add sp, #0x20
	pop {r3, r4, r5, r6, r7, pc}
	.balign 4, 0
_02260774: .word 0x45800000
_02260778: .word 0x4F800000
	thumb_func_end ov92_02260628

	thumb_func_start ov92_0226077C
ov92_0226077C: ; 0x0226077C
	mov r3, #0
_0226077E:
	add r2, r0, #0
	add r2, #0xbc
	ldr r2, [r2]
	cmp r1, r2
	bne _0226078C
	add r0, r3, #0
	bx lr
_0226078C:
	add r3, r3, #1
	add r0, r0, #4
	cmp r3, #4
	blt _0226077E
	mov r0, #0xff
	bx lr
	thumb_func_end ov92_02260


33333" fill-rule="evenodd" d="M4,10a6,6 0 1,0 12,0a6,6 0 1,0 -12,0 M9,7a1,1 0 1,0 2,0a1,1 0 1,0 -2,0 M9,10a1,1 0 1,1 2,0l0,3a1,1 0 1,1 -2,0"/%3E %3C/svg%3E\'); background-color: rgba(255, 255, 255, 0.5); width: 24px; height: 24px; box-sizing: border-box; border-radius: 12px;',"ctrl-attrib.mapboxgl-compact":"min-height: 20px; padding: 0; margin: 10px; position: relative; background-color: #fff; border-radius: 3px 12px 12px 3px;","ctrl-bottom-right > .mapboxgl-ctrl-attrib.mapboxgl-compact::after":"bottom: 0; right: 0","ctrl-bottom-left > .mapboxgl-ctrl-attrib.mapboxgl-compact::after":"bottom: 0; left: 0","ctrl-bottom-left .mapboxgl-ctrl":"margin: 0 0 10px 10px; float: left;","ctrl-bottom-right .mapboxgl-ctrl":"margin: 0 10px 10px 0; float: right;","ctrl-attrib":"color: rgba(0, 0, 0, 0.75); text-decoration: none; font-size: 12px","ctrl-attrib a":"color: rgba(0, 0, 0, 0.75); text-decoration: none; font-size: 12px","ctrl-attrib a:hover":"color: inherit; text-decoration: underline;","ctrl-attrib .mapbox-improve-map":"font-weight: bold; margin-left: 2px;","attrib-empty":"display: none;","ctrl-logo":'display:block; width: 21px; height: 21px; background-image: url(\'data:image/svg+xml;charset=utf-8,%3C?xml version="1.0" encoding="utf-8"?%3E %3Csvg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 21 21" style="enable-background:new 0 0 21 21;" xml:space="preserve"%3E%3Cg transform="translate(0,0.01)"%3E%3Cpath d="m 10.5,1.24 c -5.11,0 -9.25,4.15 -9.25,9.25 0,5.1 4.15,9.25 9.25,9.25 5.1,0 9.25,-4.15 9.25,-9.25 0,-5.11 -4.14,-9.25 -9.25,-9.25 z m 4.39,11.53 c -1.93,1.93 -4.78,2.31 -6.7,2.31 -0.7,0 -1.41,-0.05 -2.1,-0.16 0,0 -1.02,-5.64 2.14,-8.81 0.83,-0.83 1.95,-1.28 3.13,-1.28 1.27,0 2.49,0.51 3.39,1.42 1.84,1.84 1.89,4.75 0.14,6.52 z" style="opacity:0.9;fill:%23ffffff;enable-background:new" class="st0"/%3E%3Cpath d="M 10.5,-0.01 C 4.7,-0.01 0,4.7 0,10.49 c 0,5.79 4.7,10.5 10.5,10.5 5.8,0 10.5,-4.7 10.5,-10.5 C 20.99,4.7 16.3,-0.01 10.5,-0.01 Z m 0,19.75 c -5.11,0 -9.25,-4.15 -9.25,-9.25 0,-5.1 4.14


mponent): void {

    const LAST: number = drawingArea.getShape().coordinates.length - 1;
    const deltaX: number = drawingArea.getShape().coordinates[TEMP].x - drawingArea.getShape().coordinates[LAST].x;
    const deltaY: number = drawingArea.getShape().coordinates[TEMP].y - drawingArea.getShape().coordinates[LAST].y;

    if (this.isShiftDown) {

      let angle: number = Math.atan2(deltaY, deltaX);
      if (angle < 0) {
        angle += ANGLES_TO_RAD.ANGLE_360;
      }
      angle = ANGLES_TO_RAD.ANGLE_360 - angle;
      angle = this.calculateDesiredAngle(angle);

      switch (angle) {

        case (ANGLES_TO_RAD.ANGLE_0 ):
        case (ANGLES_TO_RAD.ANGLE_180):
          drawingArea.getShape().coordinates[TEMP] = {x: this.lastMousePosition.x, y: drawingArea.getShape().coordinates[LAST].y};
          break;

        case (ANGLES_TO_RAD.ANGLE_90):
        case (ANGLES_TO_RAD.ANGLE_270):
          drawingArea.getShape().coordinates[TEMP] = {x: drawingArea.getShape().coordinates[LAST].x, y: this.lastMousePosition.y};
          break;

        case (ANGLES_TO_RAD.ANGLE_135):
        case (ANGLES_TO_RAD.ANGLE_315):
          drawingArea.getShape().coordinates[TEMP] = {x: this.lastMousePosition.x, y: this.lastMousePosition.y - deltaY + deltaX};
          break;

        case (ANGLES_TO_RAD.ANGLE_225):
        case (ANGLES_TO_RAD.ANGLE_45):
          drawingArea.getShape().coordinates[TEMP] = {x: this.lastMousePosition.x, y: this.lastMousePosition.y - deltaY - deltaX};
          break;

      }

    } else {
      drawingArea.getShape().coordinates[TEMP] = this.lastMousePosition;
    }

  }

  // To desactivate the line to see something
  // tslint:disable-next-line: cyclomatic-complexity
  calculateDesiredAngle(angle: number): number {

    const HALF_ANGLE_45_TO_RAD: number = ANGLES_TO_RAD.ANGLE_45 / 2;

    if ((angle > ANGLES_TO_RAD.ANGLE_0) && (angle < HALF_ANGLE_45_TO_RAD)) {
      return ANGLES_TO_RAD.ANGLE_0;
    } else if ((angle >= HALF_ANGLE_45_TO_RAD) && (angle < ANGLES_TO_RAD.ANGLE_45 + HALF_ANGLE_45_TO_RAD)) {
      return ANGLES_TO_RAD.ANGLE_45;
    } else if ((angle >= ANGLES_TO_RAD.ANGLE_90 - HALF_ANGLE_45_TO_RAD) && (angle < ANGLES_TO_RAD.ANGLE_90 + HALF_ANGLE_45_TO_RAD)) {
      return ANGLES_TO_RAD.ANGLE_90;
    } else if ((angle >= ANGLES_TO_RAD.ANGLE_135 - HALF_ANGLE_45_TO_RAD) && (angle < ANGLES_TO_RAD.ANGLE_135 + HALF_ANGLE_45_TO_RAD)) {
      return ANGLES_TO_RAD.ANGLE_135;
    } else if ((angle >= ANGLES_TO_RAD.ANGLE_180 - HALF_ANGLE_45_TO_RAD) && (angle < ANGLES_TO_RAD.ANGLE_180 + HALF_ANGLE_45_TO_RAD)) {
      return ANGLES_TO_RAD.ANGLE_180;
    } else if ((angle >= ANGLES_TO_RAD.ANGLE_225 - HALF_ANGLE_45_TO_RAD) && (angle < ANGLES_TO_RAD.ANGLE_225 + HALF_ANGLE_45_TO_RAD)) {
      return ANGLES_TO_RAD.ANGLE_225;
    } else if ((angle >= ANGLES_TO_RAD.ANGLE_270 - HALF_ANGLE_


}
		if (rects.size() == 0) {
			if (depth > 1 && isEmpty(bi1)) {
				// how did we possibly get here? We picked this spot because the
				// two shapes intersected somewhere in this rectangle, but one
				// shape
				// didn't render ANYTHING in this rectangle? Fishy business.
				throw new MachineErrorException();
			} else if (depth > 1) {
				draw(shapeB, at, bi2, false);
				if (isEmpty(bi2))
					throw new MachineErrorException();
			}
			return false;
		}

		for (int a = 0; a < rects.size(); a++) {
			Rectangle2D r = rects.get(a);
			try {
				if (isIntersectionObserved(shapeA, shapeB, bi1, bi2, r,
						depth + 1))
					return true;
			} catch (MachineErrorException e) {
				// we asked for too severe a degree of accuracy, but the odds
				// are we did find something:
				return true;
			}
		}

		return false;
	}

	protected static boolean getTheoreticalIntersection(Shape shapeA,
			Shape shapeB) {

		if (shapeA instanceof Line2D) {
			Line2D la = (Line2D) shapeA;
			if (shapeB instanceof Line2D) {
				Line2D lb = (Line2D) shapeB;
				return Intersections.lineLine(la.getX1(), la.getY1(),
						la.getX2(), la.getY2(), lb.getX1(), lb.getY1(),
						lb.getX2(), lb.getY2());
			} else if (shapeB instanceof QuadCurve2D) {
				QuadCurve2D qb = (QuadCurve2D) shapeB;
				return Intersections.lineQuad(la.getX1(), la.getY1(),
						la.getX2(), la.getY2(), qb.getX1(), qb.getY1(),
						qb.getCtrlX(), qb.getCtrlY(), qb.getX2(), qb.getY2());
			} else if (shapeB instanceof CubicCurve2D) {
				CubicCurve2D cb = (CubicCurve2D) shapeB;
				return Intersections.lineCubic(la.getX1(), la.getY1(),
						la.getX2(), la.getY2(), cb.getX1(), cb.getY1(),
						cb.getCtrlX1(), cb.getCtrlY1(), cb.getCtrlX2(),
						cb.getCtrlY2(), cb.getX2(), cb.getY2());
			} else {
				throw new RuntimeException();
			}
		} else if (shapeA instanceof QuadCurve2D) {
			QuadCurve2D qa = (QuadCurve2D) shapeA;
			if (shapeB instanceof Line2D) {
				Line2D lb = (Line2D) shapeB;
				return Intersections.lineQuad(lb.getX1(), lb.getY1(),
						lb.getX2(), lb.getY2(), qa.getX1(), qa.getY1(),
						qa.getCtrlX(), qa.getCtrlY(), qa.getX2(), qa.getY2());
			} else if (shapeB instanceof QuadCurve2D) {
				QuadCurve2D qb = (QuadCurve2D) shapeB;
				return Intersections.quadQuad(qa.getX1(), qa.getY1(),
						qa.getCtrlX(), qa.getCtrlY(), qa.getX2(), qa.getY2(),
						qb.getX1(), qb.getY1(), qb.getCtrlX(), qb.getCtrlY(),
						qb.getX2(), qb.getY2());
			} else if (shapeB instanceof CubicCurve2D) {
				Cubic


overage", "Steps to Goal"]
    col_widths = [max(len(h), 12) for h in headers]

    # Header row
    header_row = " | ".join(f"{h:<{w}}" for h, w in zip(headers, col_widths))
    table_lines.append(header_row)
    table_lines.append("-" * len(header_row))

    # Data rows
    for alg_name, results in results_dict.items():
        final_reward = results.get('final_reward', 'N/A')
        success_rate = results.get('success_rate', 'N/A')
        coverage = results.get('coverage', 'N/A')
        steps_to_goal = results.get('steps_to_goal', 'N/A')

        # Format values
        if isinstance(final_reward, (int, float)):
            final_reward = f"{final_reward:.3f}"
        if isinstance(success_rate, (int, float)):
            success_rate = f"{success_rate:.3f}"
        if isinstance(coverage, (int, float)):
            coverage = f"{coverage:.3f}"
        if isinstance(steps_to_goal, (int, float)):
            steps_to_goal = f"{steps_to_goal:.1f}"

        row_data = [alg_name, final_reward, success_rate, coverage, steps_to_goal]
        row = " | ".join(f"{d:<{w}}" for d, w in zip(row_data, col_widths))
        table_lines.append(row)

    return "\n".join(table_lines)


 into the iterable at the specified index.
  ///
  /// Takes the specified elements and inserts them into the iterable at the
  /// position [index].
  ///
  /// If [index] is less than zero, a [RangeError] is thrown.
  ///
  /// If iteration of this iterable is exausted before the position [index]
  /// is reached, a [RangeError] is thrown.
  Iterable<T> insert9(
    int index,
    T v1,
    T v2,
    T v3,
    T v4,
    T v5,
    T v6,
    T v7,
    T v8,
    T v9,
  ) sync* {
    if (index == 0) {
      yield* prepend9(v1, v2, v3, v4, v5, v6, v7, v8, v9);
      return;
    }
    if (index < 0) {
      throw RangeError.index(
        index,
        this,
        'index',
        'Parameter "index" must be greater than zero.',
      );
    }

    final iterator = this.iterator;
    var i = 0;

    while (iterator.moveNext()) {
      if (i == index) {
        yield v1;
        yield v2;
        yield v3;
        yield v4;
        yield v5;
        yield v6;
        yield v7;
        yield v8;
        yield v9;
      }
      yield iterator.current;
      i++;
    }

    if (index >= i) {
      throw RangeError.index(index, this, null, null, i);
    }
  }
}
import 'dart:async';

extension ToStreamExtension<T> on Iterable<T> {
  /// Converts the iterable to a [Stream].
  ///
  /// Wraps the iterable in a [Stream] that emits all the values in this iterable. If
  /// iteration is paused, the stream's events will be paused and vice versa. If an
  /// error is thrown during iteration, the stream will emit the error and then close.
  ///
  /// If [isBroadcast] is set to true, the stream will be a broadcast stream. Otherwise,
  /// the stream will be a single-subscription stream. (Default is false.)
  ///
  /// If a [delay] is provided, the amount of time specified by [delay] will be waited before
  /// each element of this iterable is sent to the stream, including the first.
  ///
  /// (If [delay] is omitted, this is identical to calling `Stream.fromIterable(iterable)`.)
  Stream<T> toStream({bool isBroadcast = false, Duration? delay}) {
    if (delay == null) {
      final stream = Stream.fromIterable(this);
      if (isBroadcast) return stream.asBroadcastStream();
      return stream;
    }

    final controller = StreamController<T>();

    unawaited(() async {
      final iterator = this.iterator;
      while (iterator.moveNext()) {
        try {
          await Future<void>.delayed(delay);
          controller.sink.add(iterator.current);
        } catch (e) {
          controller.sink.addError(e);
        }
      }
      controller.close();
    }());

    if (isBroadcast) return controller.stream.asBroadcastStream();
    return controller.stream;
  }
}
import 'package:darq/src/utility/equality_comparer.dart';
import 'package:darq/src/utility/grouping.dart';

extension GroupSelectValueExtension<T> on Iterable<T> {
  /// Groups the elements in the iterable by a key, maps the elements to
  /// a new value, and maps the groups to a new element.
  ///
  /// After applying the [groupSelectValue] method to an iterable, the resulting
  /// iterable will be a series of groups of elements. Each group will consist
  /// of all elements in the source it


.cwd();
    let targetSize = flags.size ? flags.size * 1000 : undefined;
    await main(path, targetSize, flags.width);
  }
}

export = Maloha;
import Color from 'color';
import { ColorGroupWithContrast, MediumTheme, Theme, ThemeCore } from './types';

const palette = {
  white: '#c0c0c0',
  black: '#202020',
  red: '#cc1111',
  green: 'green',
  orange: 'orange',
};

function generateColorGroupWithContrast(
  main: string,
  contrastMain: string,
  darkMode: boolean
): ColorGroupWithContrast {
  const contrast = 0.75;

  const increaseContrast = (
    color: string,
    value: number,
    darkMode: boolean
  ) => {
    if (Color(main).saturationv() < 80) {
      return (darkMode
        ? Color(color).darken(value)
        : Color(color).lighten(value)
      ).toString();
    } else {
      return (value < 0
        ? Color(color).lighten(-value).saturate(value)
        : Color(color).lighten(value)
      ).toString();
    }
  };

  return {
    main: main,
    weak: Color(main).mix(Color(contrastMain), 0.4).toString(),
    strong: increaseContrast(main, contrast, darkMode),
    light: Color(main).lighten(contrast).toString(),
    dark: Color(main).darken(contrast).toString(),

    contrast: {
      main: contrastMain,
      weak: Color(contrastMain).mix(Color(main), 0.4).toString(),
      strong: increaseContrast(contrastMain, -contrast, Color(main).isDark()),
      light: Color(contrastMain).lighten(contrast).toString(),
      dark: Color(contrastMain).darken(contrast).toString(),
    },
  };
}

function generateMediumTheme(main: string, contrastMain: string): MediumTheme {
  return {
    ...generateColorGroupWithContrast(main, contrastMain, Color(main).isDark()),
    divider: {
      main: Color(main).mix(Color(contrastMain), 0.2).toString(),
    },
    success: {
      main: Color(palette.green).mix(Color(main), 0.2).toString(),
      contrast: {
        main: Color(palette.white).toString(),
      },
    },
    error: generateColorGroupWithContrast(
      '#990000',
      '#eee',
      Color(main).isDark()
    ),
    warning: {
      main: Color(palette.orange).mix(Color(main), 0.2).toString(),
      contrast: {
        main: Color(palette.black).toString(),
      },
    },
  };
}

export function generateTheme(
  active: keyof ThemeCore,
  theme: {
    clickable: { main: string; contrast: { main: string } };
  }
): Theme {
  return {
    get active() {
      return this[active];
    },
    light: generateMediumTheme(palette.white, palette.black),
    dark: generateMediumTheme(palette.black, palette.white),
    clickable: generateMediumTheme(
      theme.clickable.main,
      theme.clickable.contrast.main
    ),
    accent: generateMediumTheme(
      Color(theme.clickable.main).hue(180).toString(),
      theme.clickable.contrast.main
    ),
  };
}
//! !! DO NOT IMPORT from ".ENV"
import { format } from "util";
import * as cluster from "cluster";
import process from "process";
import { grey, blueBright, red } from "chalk";
import assertMod, { fail, ok, strictEqual, deepStrictEqual, notDeepStrictEqual, throws, doesNotThrow, ifError, rejects, does


his
    override fun toArray(): FloatArray = floatArrayOf(x, y, z, alpha)
    override fun clamp(): XYZ = clamp3(x, y, z, alpha, ::copy)
}

/** Create the transform matrix to adapt [srcWp] to this color space */
internal fun XYZColorSpace.chromaticAdaptationMatrix(
    srcWp: xyY,
    xyzToLms: Matrix = CAT02_XYZ_TO_LMS,
    lmsToXyz: Matrix = CAT02_LMS_TO_XYZ,
): Matrix {
    val dstWp = this.whitePoint.chromaticity
    val src = xyzToLms.dot(srcWp.X, srcWp.Y, srcWp.Z)
    val dst = xyzToLms.dot(dstWp.X, dstWp.Y, dstWp.Z)
    return lmsToXyz.dotDiagonal(dst.l / src.l, dst.m / src.m, dst.s / src.s).dot(xyzToLms)
}
package com.github.ajalt.mordant.terminal.terminalinterface.ffm

import com.github.ajalt.mordant.rendering.Size
import com.github.ajalt.mordant.terminal.TimeoutException
import com.github.ajalt.mordant.terminal.terminalinterface.TerminalInterfaceWindows
import java.lang.foreign.*

private object WinLayouts {
    val HANDLE: AddressLayout = Layouts.POINTER
    val WORD: ValueLayout.OfShort = ValueLayout.JAVA_SHORT
    val DWORD: ValueLayout.OfInt = Layouts.INT
    val LPDWORD: AddressLayout = Layouts.POINTER
    val CHAR: ValueLayout.OfByte = ValueLayout.JAVA_BYTE
    val WCHAR: ValueLayout.OfChar = ValueLayout.JAVA_CHAR
}

@Suppress("FunctionName", "ClassName", "unused", "PropertyName")
private class WinKernel32Library {

    class COORD(override val segment: MemorySegment) : StructAccessor {
        object Layout : StructLayout() {
            val X by shortField()
            val Y by shortField()
        }

        constructor(arena: Arena) : this(arena.allocate(Layout.layout))

        val X by Layout.X
        val Y by Layout.Y
    }

    class SMALL_RECT(override val segment: MemorySegment) : StructAccessor {
        object Layout : StructLayout() {
            val Left by shortField()
            val Top by shortField()
            val Right by shortField()
            val Bottom by shortField()
        }

        constructor(arena: Arena) : this(arena.allocate(Layout.layout))

        val left by Layout.Left
        val top by Layout.Top
        val right by Layout.Right
        val bottom by Layout.Bottom
    }

    class CONSOLE_SCREEN_BUFFER_INFO(override val segment: MemorySegment) : StructAccessor {
        object Layout : StructLayout() {
            val dwSize by structField(COORD.Layout, ::COORD)
            val dwCursorPosition by structField(COORD.Layout, ::COORD)
            val wAttributes by wordField()
            val srWindow by structField(SMALL_RECT.Layout, ::SMALL_RECT)
            val dwMaximumWindowSize by structField(COORD.Layout, ::COORD)
        }

        constructor(arena: Arena) : this(arena.allocate(Layout.layout))

        val dwSize by Layout.dwSize
        val dwCursorPosition by Layout.dwCursorPosition
        val wAttributes by Layout.wAttributes
        val srWindow by Layout.sr


::vector< float_t > & _VC_phi ,
        std::vector< float_t > & _TC_psi) {
    typedef typename point_t::type_t    T;

    _VC_phi.clear();  _VC_phi.resize( cage_vertices.size() , 0.0 );
    _TC_psi.clear();  _TC_psi.resize( cage_triangles.size() , 0.0 );

    // iterate over the triangles:
    for( unsigned int t = 0 ; t < cage_triangles.size() ; ++t ) {
        std::vector<int_t> const & tri = cage_triangles[t];
        point_t tri_verts[3] = {cage_vertices[tri[0]] , cage_vertices[tri[1]] , cage_vertices[tri[2]]};
        T psi;  T phi[3];

        computePhiAndPsiForOneTriangle( eta , tri_verts , phi , psi );

        _TC_psi[t] = psi;
        for( unsigned int v = 0 ; v < 3 ; ++v ) _VC_phi[ tri[v] ] += phi[v];
    }
}

}

}

#endif // GC_H


    fun loadMvDetail(mvid: String?, type: Int, result: RequestCallBack<VideoInfoBean>?) {
        val observable = if (type == 2) {
            mvid?.let { NeteaseApiServiceImpl.getMvDetailInfo(it) }
        } else {
            mvid?.let { NeteaseApiServiceImpl.getVideoDetailInfo(it) }
        }
        ApiManager.request(observable, result)
    }

    /**
     *
     * 加载最新mv
     */
    fun loadRecentMv(limit: Int = 30, result: RequestCallBack<MvInfo>?) {
        val observable = NeteaseApiServiceImpl.getNewestMv(limit)
        ApiManager.request(observable, result)
    }

    /**
     *
     * 加载排行榜mv
     */
    fun loadMv(offset: Int, result: RequestCallBack<MvInfo>?) {
        val observable = NeteaseApiServiceImpl.getTopMv(50, offset)
        ApiManager.request(observable, result)
    }

    /**
     *
     * 加载推荐mv
     */
    fun loadPersonalizedMv(result: RequestCallBack<MvInfo>?) {
        val observable = NeteaseApiServiceImpl.personalizedMv()
        ApiManager.request(observable, result)
    }

    /**
     * 获取相似mv
     */
    fun loadSimilarMv(mvid: String?, type: Int, result: RequestCallBack<MutableList<VideoInfoBean>>?) {
        val observable = if (type == 2) {
            mvid?.let { NeteaseApiServiceImpl.getSimilarMv(it) }
        } else {
            mvid?.let { NeteaseApiServiceImpl.getRelatedVideoList(it) }
        }
        observable?.let {
            ApiManager.request(it, result)
        }
    }

    /**
     *获取mv数据
     */
    fun loadMvComment(mvid: String?, type: String, offset: Int = 0, result: RequestCallBack<MvComment>?) {
        val observable = mvid?.let { NeteaseApiServiceImpl.getMvComment(it, type, offset) }
                ?: return
        ApiManager.request(observable, result)
    }

    /**
     *搜索mv数据
     */
    fun searchMv(key: String, offset: Int, result: RequestCallBack<SearchInfo>?) {
        val observable = NeteaseApiServiceImpl.searchMoreInfo(key, 30, offset, 1004)
        ApiManager.request(observable, result)
    }

    fun loadBaiduMv(songId: String?, result: RequestCallBack<MvInfoBean>?) {
        val observable = BaiduApiServiceImpl.getMvInfo(songId)
        ApiManager.request(observable, result)
    }
}package com.cyl.musiclake.ui.music.playlist.edit

import android.widget.CheckBox
import com.chad.library.adapter.base.BaseQuickAdapter
import com.chad.library.adapter.base.module.DraggableModule
import com.chad.library.adapter.base.viewholder.BaseViewHolder
import com.cyl.musiclake.R
import com.cyl.musiclake.bean.Playlist
import com.cyl.musiclake.utils.ConvertUtils

/**
 * 作者：yonglong
 * 邮箱：643872807@qq.com
 * 版本：2.5
 */
class PlaylistEditAdapter(list: MutableList<Playlist>) : BaseQuickAdapter<Playlist, BaseViewHolder>(R.layout.item_playlist_edit, list), DraggableModule {
    /**
     * 选中列表
     */
    var checkedMap = mutableMapOf<String, Playlist>()

    override fun convert(holder: BaseViewHolder, item: Playlist) {
        holder.setText(R.id.tv_name, ConvertUtils.getTitle(item.name))


# Copyright (c) 2024 Jintao Li.
# Computational and Interpretation Group (CIG),
# University of Science and Technology of China (USTC).
# All rights reserved.
"""
Display axis
============================================================

.. image:: ../../_static/cigvis/3Dvispy/13.png
    :alt: image
    :align: center

"""

# sphinx_gallery_thumbnail_path = '_static/cigvis/3Dvispy/13.png'

import numpy as np
import cigvis
from pathlib import Path
root = Path(__file__).resolve().parent.parent.parent

seisp = root / 'data/co2/sx.dat'
ni, nx, nt = 192, 192, 240
sx = np.fromfile(seisp, np.float32).reshape(ni, nx, nt)

nodes1 = cigvis.create_slices(sx, pos=[[0, 191], [0, 191], [0, 239]])
# Add a north pointer via passing north_direction, if axis_pos is 'auto', axis will change when rotating
nodes1 += cigvis.create_axis(sx.shape, 'box', axis_pos='auto', north_direction=[0, 1])

nodes2 = cigvis.create_slices(sx, pos=[[0, 191], [0, 191], [0, 239]])
# Use intervals and starts to control the tick labels, and set axis_labels to show the axis labels
nodes2 += cigvis.create_axis(sx.shape, 'axis', axis_pos='auto', intervals=[0.025, 0.025, 0.004], starts=[10, 10, 3], axis_labels=['Inline/km', 'Crossline/km', 'Time/s'])

nodes3 = cigvis.create_slices(sx, pos=[[0, 191], [0, 191], [0, 239]])
# if want to show the axis in the specific position, set axis_pos, and the axis will be fixed
# there are some other parameters to control the axis, such as tick_nums, ticks_font_size, labels_font_size, ticks_length
nodes3 += cigvis.create_axis(sx.shape, 'axis', axis_pos=[0, 0, 1], tick_nums=4, ticks_font_size=26, labels_font_size=30, ticks_length=6)

nodes4 = cigvis.create_slices(sx, pos=[[0, 191], [0, 191], [0, 239]])
# More controls, see cigvis/vispynodes/axis3d/Axis3D class
# for example, axis color, axis line width, ticks color, rotation the axis label
nodes4 += cigvis.create_axis(sx.shape, 'axis', axis_pos=[3, 3, 1], color='blue', ticks_color='red', rotation=[50, -40, -100])

cigvis.plot3D([nodes1, nodes2, nodes3, nodes4],
              xyz_axis=False,
              grid=(2, 2),
              share=True,
              size=(900, 800),
              savename='example.png')


手披风",
[28778] = "恐惧深渊束带",
[28779] = "无尽深渊束带",
[28780] = "食魂者的裹手",
[28781] = "卡拉波护符",
[28782] = "水晶脉冲法杖",
[28783] = "艾瑞达湮灭魔杖",
[28784] = "阴魂军旗碎片",
[28785] = "电容器",
[28786] = "阿匹克斯的聚焦水晶",
[28787] = "歼灭者机械臂",
[28788] = "保卫者的战袍",
[28789] = "玛瑟里顿之眼",
[28790] = "纳鲁圣光卫士指环",
[28791] = "反抗之戒",
[28792] = "阿达尔的防御徽记",
[28793] = "赤红怒火指环",
[28794] = "戈隆领主之斧",
[28795] = "刀塔作战护腕",
[28796] = "暗影之邪恶面具",
[28797] = "食人魔法师的野蛮披风",
[28798] = "保卫者的徽章",
[28799] = "神圣灵感腰带",
[28800] = "纳鲁之锤",
[28801] = "莫加尔的战盔",
[28802] = "血喉魔剑",
[28803] = "自然呼吸兜帽",
[28804] = "古加尔的项圈",
[28805] = "高阶督军的链甲护胸",
[28806] = "高阶督军的链甲手套",
[28807] = "高阶督军的链甲头盔",
[28808] = "高阶督军的链甲护腿",
[28809] = "高阶督军的链甲护肩",
[28810] = "风剪长靴",
[28811] = "高阶督军的龙皮手套",
[28812] = "高阶督军的龙皮头盔",
[28813] = "高阶督军的龙皮护腿",
[28814] = "高阶督军的龙皮护肩",
[28815] = "高阶督军的龙皮外套",
[28816] = "QATest +400 Spell Dmg Ring",
[28817] = "高阶督军的鬼纹手套",
[28818] = "高阶督军的鬼纹头巾",
[28819] = "高阶督军的鬼纹护腿",
[28820] = "高阶督军的鬼纹衬肩",
[28821] = "高阶督军的鬼纹长袍",
[28822] = "格鲁尔之牙",
[28823] = "格鲁尔之眼"


--- === plugins.core.razer.changeapplications ===
---
--- Allows you to change the Razer application if set to manual.

local require                       = require

--local log                           = require "hs.logger".new "changeapplications"

local application                   = require "hs.application"
local image                         = require "hs.image"

local i18n                          = require "cp.i18n"

local imageFromPath                 = image.imageFromPath
local launchOrFocusByBundleID       = application.launchOrFocusByBundleID

local mod = {}

local plugin = {
    id              = "core.razer.changeapplications",
    group           = "core",
    dependencies    = {
        ["core.action.manager"]         = "actionmanager",
        ["core.application.manager"]    = "applicationmanager",
        ["core.razer.manager"]          = "razerManager",
    }
}

function plugin.init(deps, env)
    --------------------------------------------------------------------------------
    -- Razer Icon:
    --------------------------------------------------------------------------------
    local razerIcon = imageFromPath(env:pathToAbsolute("/../prefs/images/razerIcon.png"))

    local actionmanager         = deps.actionmanager
    local applicationmanager    = deps.applicationmanager
    local razerManager          = deps.razerManager

    local supportedDevices      = razerManager.supportedDevices

    mod.handlers = {}

    for _, deviceName in pairs(supportedDevices) do
        local deviceID = deviceName:lower():gsub("%s+", "")
        mod.handlers[deviceName] = actionmanager.addHandler("global_" .. deviceID .. "_applications", "global")
            :onChoices(function(choices)
                local applications = applicationmanager.getApplications()

                applications["All Applications"] = {
                    displayName = "All Applications",
                }

                -- Add User Added Applications from Razer Preferences:
                local items = razerManager.items()
                for _, device in pairs(items) do


terhub/jupyterhub/blob/main/Dockerfile))用于使用容器技术部署hub.

我们要实现上面的部署方案需要额外安装对应的依赖.

这里我已经基于官方镜像构造了镜像[hsz1273327/jupyterhub-for-standalone](https://hub.docker.com/repository/docker/hsz1273327/jupyterhub-for-standalone/general).其构造dockerfile如下:

```dockerfile
FROM --platform=$TARGETPLATFORM jupyterhub/jupyterhub:4.0.1 as base
RUN pip install jupyterhub-nativeauthenticator
RUN pip install dockerspawner
COPY jupyterhub_config.py /srv/jupyterhub/jupyterhub_config.py
CMD ["jupyterhub", "-f", "/srv/jupyterhub/jupyterhub_config.py"]
```

其中最关键的就是`jupyterhub_config.py`文件,如果要自行设置建议充分参考[api文档](https://jupyterhub-dockerspawner.readthedocs.io/en/latest/api/index.html),[源码](https://github.com/jupyterhub/dockerspawner/blob/main/dockerspawner/dockerspawner.py)以及[docker-py源码](https://github.com/docker/docker-py).

我这边直接使用[hsz1273327/jupyterhub-for-standalone](https://hub.docker.com/r/hsz1273327/jupyterhub-for-standalone)项目.它完全通过环境变量进行设置,功能覆盖了大多数使用场景,一般来说相当够用.

### 原生的用户管理

小团队内部使用自然没道理用外部的账号进行验证,因此我们安装`jupyterhub-nativeauthenticator`模块.这个模块的作用是提供一个本地的账户系统.

这部分的设置可以查看上面以`AUTH`开头的环境变量说明

#### 账户系统的工作流

`jupyterhub-nativeauthenticator`模块提供的账户系统注册流程包含两步:

1. 注册账号,这一步仅是创建一个用户,这个用户如果不是管理员用户默认并不能进入系统中使用jupyterhub提供的服务.
2. 验证账户,这一步需要有一个管理员账户来执行,在jupyterhub的`/hub/authorize`页面中验证已经注册的用户.非管理员用户只有被验证过才可以进入jupyterhub使用它提供的服务.

`jupyterhub-nativeauthenticator`模块提


 true for a valid json-like object', () => {
      expect(VALIDATE('application/foo+json', { foo: 1 })).toBe(true);
    });

    it('should return true for a valid string object', () => {
      expect(VALIDATE('text/plain', 'foo')).toBe(true);
    });

    it('should return true for a valid array of strings object', () => {
      expect(VALIDATE('text/plain', ['foo', 'bar'])).toBe(true);
    });

    it('should return false for a json type with string data', () => {
      expect(VALIDATE('application/foo+json', 'bar')).toBe(false);
    });

    it('should return false for a string type with json data', () => {
      expect(VALIDATE('foo/bar', { foo: 1 })).toBe(false);
    });
  });
});
/**
 * TSTable - Class for dynamically generating JQuery tables in TypeScript
 */

/**
 *
 */
export interface JTTDParms {
    celltype?: string;
    settings?: JQuery.PlainObject;
    content?: JQuery<HTMLElement> | string;
}
export type JTElem = JQuery<HTMLElement> | string | JQuery.PlainObject;
export type JTRowItems = Array<JTElem>;

export interface JTTableParms {
    class?: string;
    caption?: string;
    head?: Array<JTRowItems>;
    body?: Array<JTRowItems>;
    foot?: Array<JTRowItems>;
}
/**
 * Determines if a parameter is a plain string
 * x Item to test
 */
function isString(x: any): x is string {
    return typeof x === 'string';
}

function isTDParms(x: any): x is JTTDParms {
    return x.content !== undefined;
}

export interface JTRowParms {
    class?: string;
    celltype?: string;
    row?: JTRowItems;
}

/**
 * Determines the type of a parameter for a new row so that you
 * don't have to pass in the class or other attributes if you only
 * want to create a simple row
 * parms
 */
// function isRowParms(parms: JTRowParms | JTRowItems): parms is JTRowParms {
//     return true;
// }

export class JTRow {
    public celltype: string;
    public row: JTRowItems;
    public rowClass: string;
    public attrset: JQuery.PlainObject;
    constructor(parms?: JTRowParms | JTRowItems) {
        this.celltype = 'td';
        this.row = [];
        if (parms !== null && parms !== undefined) {
            if (Array.isArray(parms)) {
                this.row = parms as JTRowItems;
            } else {
                if (parms.celltype !== undefined) {
                    this.celltype = parms.celltype;
                }
                if (parms.row !== undefined) {
                    this.row = parms.row;
                }
                if (parms.class !== undefined) {
                    this.rowClass = parms.class;
                }
            }
        }
    }
    public setCellType(celltype: string): JTRow {
        this.celltype = celltype;
        return this;
    }
    public attr(attrset: JQuery.PlainObject): JTRow {
        this.attrset = attrset;
        return this;
    }
    /**
     * Adds a new element to the row.  This returns the row so you can chain
     * elem Element to be added (string | JQuery<HTMLElement>)
     */
    public add(elem: JTElem): JTRow {
        if (elem !== null && elem !== undefined) {
            this.row.push(elem);
        }
        return this;
    }
    /**
     * Generates the dom object from this Row.  Note that if the row is empty
     * we don't generate anything at all
     */
    public generate(): JQuery<HTMLElement> {
        // If the row is empty, we toss it out
        if (this.row.lengt


### Documentation Links

* [User Manual](https://opensmarthouse.org/zwavedatabase/447/reference/50359-manual-w-parameters.pdf)

---

Did you spot an error in the above definition or want to improve the content?
You can [contribute to the database here](https://opensmarthouse.org/zwavedatabase/447).
# EnOcean BLE Binding

This binding adds support for the
[EnOcean BLE PTM215B](https://www.enocean.com/de/produkte/enocean_module_24ghz_ble/ptm-215b/) rocker.

**Currently, it does not work with the
[BlueZ Binding](https://www.openhab.org/addons/bindings/bluetooth.bluez)**.
The recommended / tested Bluetooth bridge binding is the
[BlueGiga Binding](https://www.openhab.org/addons/bindings/bluetooth.bluegiga).

## Supported Things

Only a single thing type is added by this extension:

| Thing Type ID   | Description               |
| --------------- | ------------------------- |
| ptm215b | The EnOcean PTM 215B Rocker |

These rockers are battery-less, the necessary energy for the BLE transmission is generated by the button click itself
and completely depleted after 3 attempts of a "fire & forget" (unidirectional) BLE transmission.
This means, the rockers are only "on" during the button click, so there is no possibility for openHAB to actively
retrieve the online status. Therefore, initial online status will always be "UNKNOWN" until the rocker is used.

## Discovery

As any other Bluetooth device, EnOcean BLE rockers are discovered automatically by the corresponding bridge. It's
necessary to click any button of the rocker up to 15 times in quick succession to get it discovered.

## Thing Configuration

There is only a single configuration parameter `address`, which corresponds to the Bluetooth address of the device
(in format "XX:XX:XX:XX:XX:XX"). Normally, the address is printed on the back of the rocker.

## Channels

An EnOcean PTM 215B Rocker has the following channels:

| Channel ID                | Item Type                | Description                    |
| ------------------------- | ------------------------ | ------------------------------ |
| rocker1                   | system.rawrocker         | In case of a dual rocker, the first rocker. In case of a single rocker, usually this channel has to be used. Anyhow, it depends from the implementation of the manufacturer of the rocker, so it could be that events are coming in on the second rocker channel. |
| rocker2                   | system.rawrocker         | In case of a dual rocker, the second rocker. |

## Example

demo.things:

```java
Bridge bluetooth:bluegiga:bluegiga0 "Bluegiga Adapter" [ port="/dev/ttyBLUEGIGA", discovery=false ] {
    Thing ptm215b rocker_livingroom "Rocker Living Room" [ address = "E2:15:00:00:53:F9" ]
    Thing ptm215b rocker_kitchen "Rocker Kitchen" [ address = "E2:15:00:00:53:98" ]
}
```

demo.items:

```java
Dimmer Light_LivingRoom  { channel="milight:rgbLed:milight2:4:ledbrightness", channel="bluetooth:ptm215b:bluegiga0:rocker_livingroom:rocker1" [profile="rawrocker-to-on-off"], channel="bluetooth:ptm215b:bluegiga0:rocker_kitchen:rocker1" [profile="rawrocker-to-on-off"] }  // We have a combined kitchen / livingroom, so we control the living room lights with switches from the living room and from the kitchen
Switch Light_Kitchen    { channel="hue:group:1:kitchen-bulbs:switch", channel="bluetooth:ptm215b:bluegiga0:rocker_kitchen:rocker2" [profile="rawrocker-to-on-off"] }
```
---
layout: documentation
title: ZMNHLA - ZWave
---

{% include base.html %}

# ZMNHLA Flush PWM thermostat
This describes the Z-Wave device *ZMNHLA*, manufactured by *[Goap](http://ww


break {
    flex-direction: column;
    gap: var(--base);
  }
}

.content {
  width: 50%;
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: flex-start;
  gap: var(--base);

  @include mid-break {
    width: 100%;
    gap: calc(var(--base) / 2);
  }
}

.categories {
  @extend %label;
}

.title {
  margin: 0;
}

.warning {
  margin-bottom: calc(var(--base) * 1.5);
}

.description {
  margin: 0;
}

.media {
  width: 50%;

  @include mid-break {
    width: 100%;
  }
}

.mediaWrapper {
  text-decoration: none;
  display: block;
  position: relative;
  aspect-ratio: 5 / 4;
  margin-bottom: calc(var(--base) / 2);
  width: calc(100% + calc(var(--gutter-h) / 2));

  @include mid-break {
    margin-left: calc(var(--gutter-h) * -1);
    width: calc(100% + var(--gutter-h) * 2);
  }
}

.image {
  object-fit: cover;
}

.placeholder {
  background-color: var(--theme-elevation-50);
  width: 100%;
  height: 100%;
  display: flex;
  align-items: center;
  justify-content: center;
}

.caption {
  color: var(--theme-elevation-500);
}

.addToCartButton {
  margin-top: calc(var(--base) / 2);
}
@import '../../_css/common';

// this is to make up for the space taken by the fixed header, since the scroll method does not accept an offset parameter
.scrollRef {
  position: absolute;
  left: 0;
  top: calc(var(--base) * -5);
  @include mid-break {
    top:  calc(var(--base) * -2);
  }
}

.introContent {
  position: relative;
  margin-bottom: calc(var(--base) * 2);

  @include mid-break {
    margin-bottom: var(--base);
  }
}

.resultCountWrapper {
  display: flex;
  margin-bottom: calc(var(--base) * 2);

  @include mid-break {
    margin-bottom: var(--base);
  }
}

.pageRange {
  margin-bottom: var(--base);

  @include mid-break {
    margin-bottom: var(--base);
  }
}

.list {
  position: relative;
}

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  width: 100%;
  gap: var(--base) 40px;

  @include mid-break {
    grid-template-columns: repeat(6, 1fr);
    gap: calc(var(--base) / 2) var(--base);
  }
}

.column {
  grid-column-end: span 4;

  @include mid-break {
    grid-column-end: span 6;
  }

  @include small-break {
    grid-column-end: span 6;
  }
}

.pagination {
  margin-top: calc(var(--base) * 2);

  @include mid-break {
    margin-top: var(--base);
  }
}
@import '../../_css/type.scss';

.button {
  border: none;
  cursor: pointer;
  display: inline-flex;
  justify-content: center;
  background-color: transparent;
  text-decoration: none;
  display: inline-flex;
  padding: 12px 24px;
  font-family


type_rot_israndom, ID_action_lib_pc_type_rot_random_min, ID_action_lib_pc_type_rot_random_max }), capwid);
					if (idVar(global::ptype_edit, rot_extend) > 0)
					{
						global::axis_edit = sn;
						tab_template_editor_particles_value(self, /*"particleeditortyperotationy"*/ STR(3613), idVar(global::ptype_edit, rot).Value(sn), idVar(global::ptype_edit, rot_israndom).Value(sn), idVar(global::ptype_edit, rot_random_min).Value(sn), idVar(global::ptype_edit, rot_random_max).Value(sn), 1.0 / 5.0, -no_limit, no_limit, ArrType::From({ IntType(0), IntType(0), IntType(360) }), IntType(0), ArrType::From({ idInt(sVar(tab), tbx_type_yrot), idInt(sVar(tab), tbx_type_yrot_random) }), ArrType::From({ ID_action_lib_pc_type_rot, ID_action_lib_pc_type_rot_israndom, ID_action_lib_pc_type_rot_random_min, ID_action_lib_pc_type_rot_random_max }), capwid);
						global::axis_edit = ud;
						tab_template_editor_particles_value(self, /*"particleeditortyperotationz"*/ STR(3614), idVar(global::ptype_edit, rot).Value(ud), idVar(global::ptype_edit, rot_israndom).Value(ud), idVar(global::ptype_edit, rot_random_min).Value(ud), idVar(global::ptype_edit, rot_random_max).Value(ud), 1.0 / 5.0, -no_limit, no_limit, ArrType::From({ IntType(0), IntType(0), IntType(360) }), IntType(0), ArrType::From({ idInt(sVar(tab), tbx_type_zrot), idInt(sVar(tab), tbx_type_zrot_random) }), ArrType::From({ ID_action_lib_pc_type_rot, ID_action_lib_pc_type_rot_israndom, ID_action_lib_pc_type_rot_random_min, ID_action_lib_pc_type_rot_random_max }), capwid);
					}
					tab_collapse_end(self);
				}
				tab_control_switch(self);
				if (draw_button_collapse(self, /*"particleeditortyperotationspeed"*/ STR(3617), !idBool(global::ptype_edit, rot_spd_collapse), null_, true, /*"particleeditortyperotationspeed"*/ STR(3617)))
					idBool(global::ptype_edit, rot_spd_collapse) = !idBool(global::ptype_edit, rot_spd_collapse);
				tab_next(self);
				if (!idBool(global::ptype_edit, rot_spd_collapse))
				{
					tab_collapse_start(self);
					capwid = ((idVar(global::ptype_edit, rot_spd_extend) > 0) ? text_caption_width(self, { /*"particleeditortyperotationspeedx"*/ STR(3618), /*"particleeditortyperotationspeedy"*/ STR(3619), /*"particleeditortyperotationspeedz"*/ STR(3620), /*"particleeditortyperotationspeedxadd"*/ STR(3621), /*"particleeditortyperotationspeedyadd"*/ STR(3622), /*"particleeditortyperotationspeedzadd"*/ STR(3623), /*"particleeditortyperotationspeedxmul"*/ STR(3624), /*"particleeditortyperotationspeedymul"*/ STR(3625), /*"particleeditortyperotationspeedz


   assert code == 0, f"Could not patch interpreter: {output}"

            write_agent_config(cont, activemq_container)

            cont.exec_run("chown test-user:test-user /etc/signalfx/agent.yaml")

            _, output = cont.exec_run(
                [
                    "/bin/sh",
                    "-c",
                    "exec /opt/signalfx-agent/bin/signalfx-agent > /opt/signalfx-agent/signalfx-agent.log",
                ],
                detach=True,
                stream=True,
                user="test-user",
            )

            try:
                assert is_agent_running_as_non_root(cont, user="test-user"), f"agent is not running as test-user"
                assert wait_for(
                    p(has_datapoint, backend, metric_name="cpu.utilization"), timeout_seconds=10
                ), "Python metadata datapoint didn't come through"
                assert wait_for(
                    p(has_datapoint, backend, metric_name="gauge.amq.queue.QueueSize")
                ), "Didn't get activemq queue size datapoint"
                code, output = cont.exec_run("/opt/signalfx-agent/bin/agent-status", user="test-user")
                assert code == 0, f"failed to execute agent-status:\n{output.decode('utf-8')}"
            finally:
                print("Agent log:")
                _, output = cont.exec_run("cat /opt/signalfx-agent/signalfx-agent.log")
                print_lines(output)


s
   * @return Promise<BigNumber>
   */
  async getBalance (minimumConfirmation: number = 0, includeWatchOnly: boolean = false): Promise<BigNumber> {
    return await this.client.call('getbalance', ['*', minimumConfirmation, includeWatchOnly], 'bignumber')
  }

  /**
   * Get list of UTXOs in wallet.
   *
   * @param {number} minimumConfirmation default = 1, to filter
   * @param {number} maximumConfirmation default = 9999999, to filter
   * @param {ListUnspentOptions} [options]
   * @param {string[]} [options.addresses] to filter
   * @param {boolean} [options.includeUnsafe=true] default = true, include outputs that are not safe to spend
   * @param {ListUnspentQueryOptions} [options.queryOptions]
   * @param {number} [options.queryOptions.minimumAmount] default = 0, minimum value of each UTXO
   * @param {number} [options.queryOptions.maximumAmount] default is 'unlimited', maximum value of each UTXO
   * @param {number} [options.queryOptions.maximumCount] default is 'unlimited', maximum number of UTXOs
   * @param {number} [options.queryOptions.minimumSumAmount] default is 'unlimited', minimum sum valie of all UTXOs
   * @param {string} [options.queryOptions.tokenId] default is 'all', filter by token
   * @return {Promise<UTXO[]>}
   */
  async listUnspent (
    minimumConfirmation = 1,
    maximumConfirmation = 9999999,
    options: ListUnspentOptions = {}
  ): Promise<UTXO[]> {
    const { addresses = [], includeUnsafe = true, queryOptions = {} } = options

    return await this.client.call(
      'listunspent',
      [
        minimumConfirmation, maximumConfirmation,
        addresses, includeUnsafe, queryOptions
      ],
      { amount: 'bignumber' }
    )
  }

  /**
   * Create a new wallet
   *
   * @param {string} walletName
   * @param {boolean} disablePrivateKeys
   * @param {CreateWalletOptions} [options]
   * @param {boolean} [options.blank]
   * @param {string} [options.passphrase]
   * @param {boolean} [options.avoidReuse]
   * @return {Promise<CreateWalletResult>}
   */
  async createWallet (
    walletName: string,
    disablePrivateKeys = false,
    options: CreateWalletOptions = {}
  ): Promise<CreateWalletResult> {
    const { blank = false, passphrase = '', avoidReuse = false } = options

    return await this.client.call(
      'createwallet',
      [walletName, disablePrivateKeys, blank, passphrase, avoidReuse],
      'number'
    )
  }

  /**
   * Return object containing various wallet state info
   *
   * @return {Promise<WalletInfo>}
   */
  async getWalletInfo (): Promise<WalletInfo> {
    return await this.client.call('getwalletinfo', [], {
      balance: 'bignumber',
      unconfirmed_balance: 'bignumber',
      immature_balance: 'bignumber',
      paytxfee: 'bignumber'
    })
  }

  /**
   * Change the state of the given wallet flag for a wallet
   *
   * @param {WalletFlag} flag to change. eg: avoid_reuse
   * @param {boolean} value optional, default = true
   * @return {Promise<WalletFlagResult>}
   */
  async setWalletFlag (flag: WalletFlag, value: boolean = true): Promise<WalletFlagResult> {
    return await this.client.call('setwalletflag', [flag, value], 'number')


JSON.stringify(obj));
  }

  static collectEnvVarNames(composeEntity: object): Array<string> {

    let names = Utils
                .parseList(Utils.collectStringProperties(composeEntity))
                .filter((e,i,self) => self.findIndex(_e => _e == e) === i);

    return names
  }

  static splitIntoColumns(maxColCount: number, minColSize: number, arr: Array<any>): Array<Array<any>> {

    let colCount = maxColCount;
    let totalSize = arr.length;

    let colSize = Utils.calcColumns(colCount, totalSize);

    if (colSize.main < minColSize) {

      colCount = Math.ceil(totalSize / minColSize);
      colSize = Utils.calcColumns(colCount, totalSize);
    }

    let columns = [];
    let i = 0;

    for (let j = 0; j < colCount - 1; j++) {

      let col = [];
      columns.push(col);

      for (let k = 0; k < colSize.main; k++) {

        col.push(arr[i++]);
      }
    }

    let col = [];
    columns.push(col);

    for (let k = 0; k < colSize.last; k++) {

      col.push(arr[i++]);
    }

    return columns;
  }

  private static calcColumns(colCount: number, totalSize: number) {

    let mainColSize;
    let lastColSize;

    if (colCount == 1) {

      mainColSize = 0;
      lastColSize = totalSize;

    } else {

      mainColSize = Math.round(totalSize / colCount);
      lastColSize = totalSize - mainColSize * (colCount - 1)
    }

    return {
      main: mainColSize,
      last: lastColSize
    };
  }

  private static parseList(assignments: Array<string>): Array<string> {

    let list: Array<string> = [];

    for (const a of assignments) {

      let names = Utils.parseAssignmentExpression(a);

      if (names) list = list.concat(names);
    }

    return list;
  }

  private static collectStringProperties(service: Object|Array<any>, props: Array<string> = []): Array<string> {

    for (let key in service) {

      let value = service[key];

      if (Utils.isObjectLiteral(value) || value instanceof Array) {

        Utils.collectStringProperties(value, props);

      } else if (typeof value == 'string') {

        props.push(service[key]);
      }
    }

    return props;
  }

  private static isObjectLiteral(value: any): boolean {
    return Object.prototype.toString.call( value ) === '[object Object]';
  }

  private static parseAssignmentExpression(str: string): Array<string> {

    let arr = str.match(/\$\{\w+\}/g);

    if (!arr) return null;

    return arr.map(e => e.match(/\${(\w+)}/)[1]);
  }

  private static checksum(s: string): string {

    var chk = 0x12345678;
    var len = s.length;

    for (var i = 0; i < len; i++) {
      chk += (s.charCodeAt(i) * (i + 1));
    }

    return (chk & 0xffffffff).toString(16);
  }

}// tslint:disable:no-magic-numbers
import {
  Collection,
  MessageEmbed,
  MessageReaction,
  TextChannel,
  User
} from "discord.js";
import moment, { duration } from "moment";
import { FoxClient } from "..";
import { FoxGuild, FoxMessage } from "../extensions";
import { Giveaways } from "../Mongo";
import Giveaway from "./Giveaway";

export default class GiveawayStore extends Collection<any, any> {
  public client: FoxClient;


},
		}
		expectedAlg3 := &materializedAlgorithm{
			cost: newAlgCost(1, 3),
			inputPlacement: map[string][]placement{
				graph.Left: []placement{
					&publicPlacement{partyCodes: []string{"party1", "party2"}},
				},
				graph.Right: []placement{
					&sharePlacement{partyCodes: []string{"party1", "party2"}},
				},
			},
			outputPlacement: map[string][]placement{
				graph.Out: []placement{
					&sharePlacement{partyCodes: []string{"party1", "party2"}},
				},
			},
		}
		expectedAlg4 := &materializedAlgorithm{
			cost: newAlgCost(0, 2),
			inputPlacement: map[string][]placement{
				graph.Left: []placement{
					&publicPlacement{partyCodes: []string{"party1", "party2"}},
				},
				graph.Right: []placement{
					&privatePlacement{partyCode: "party1"},
				},
			},
			outputPlacement: map[string][]placement{
				graph.Out: []placement{
					&privatePlacement{partyCode: "party1"},
				},
			},
		}
		r.Equal(4, len(algs))
		r.Equal(expectedAlg1, algs[0])
		r.Equal(expectedAlg2, algs[1])
		r.Equal(expectedAlg3, algs[2])
		r.Equal(expectedAlg4, algs[3])
	}
}

func TestCreateBinaryAlgNoComm(t *testing.T) {
	r := require.New(t)
	{
		inputs := createBinaryInputOutput()
		in := inputs[0]
		in[graph.Left][0].SetLevelForParty("party1", ccl.Encrypt)
		in[graph.Left][0].SetLevelForParty("party2", ccl.Encrypt)
		in[graph.Right][0].SetLevelForParty("party1", ccl.Encrypt)
		in[graph.Right][0].SetLevelForParty("party2", ccl.Encrypt)
		out := inputs[1]
		out[graph.Out][0].SetLevelForParty("party1", ccl.Encrypt)
		out[graph.Out][0].SetLevelForParty("party2", ccl.Encrypt)
		algs, err := createBinaryAlgNoComm(in, out, []string{"party1", "party2"})
		r.Nil(err)
		expectedAlg := &materializedAlgorithm{
			cost: newAlgCost(0, 3),
			inputPlacement: map[string][]placement{
				graph.Left: []placement{
					&sharePlacement{partyCodes: []string{"party1", "party2"}},
				},
				graph.Right: []placement{
					&sharePlacement{partyCodes: []string{"party1", "party2"}},
				},
			},
			outputPlacement: map[string][]placement{
				graph.Out: []placement{
					&sharePlacement{partyCodes: []string{"party1", "party2"}},
				},
			},
		}
		r.Equal(1, len(algs))
		r.Equal(expectedAlg, algs[0])
	}
}
// Copyright 2025 Ant Group Co., Ltd.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the


com/PP-OCRv2/lite/ch_ppocr_mobile_v2.0_cls_slim_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/PP-OCRv2/lite/ch_PP-OCRv2_rec_slim_opt.nb)|v2.10|

如果直接使用上述表格中的模型进行部署，可略过下述步骤，直接阅读 [2.2节](#2.2与手机联调)。

如果要部署的模型不在上述表格中，则需要按照如下步骤获得优化后的模型。

- 步骤1：参考[文档](https://www.paddlepaddle.org.cn/lite/v2.10/user_guides/opt/opt_python.html)安装paddlelite，用于转换paddle inference model为paddlelite运行所需的nb模型
```
pip install paddlelite==2.10  # paddlelite版本要与预测库版本一致
```
安装完后，如下指令可以查看帮助信息
```
paddle_lite_opt
```

paddle_lite_opt 参数介绍：
|选项|说明|
|---|---|
|--model_dir|待优化的PaddlePaddle模型（非combined形式）的路径|
|--model_file|待优化的PaddlePaddle模型（combined形式）的网络结构文件路径|
|--param_file|待优化的PaddlePaddle模型（combined形式）的权重文件路径|
|--optimize_out_type|输出模型类型，目前支持两种类型：protobuf和naive_buffer，其中naive_buffer是一种更轻量级的序列化/反序列化实现。若您需要在mobile端执行模型预测，请将此选项设置为naive_buffer。默认为protobuf|
|--optimize_out|优化模型的输出路径|
|--valid_targets|指定模型可执行的backend，默认为arm。目前可支持x86、arm、opencl、npu、xpu，可以同时指定多个backend(以空格分隔)，Model Optimize Tool将会自动选择最佳方式。如果需要支持华为NPU（Kirin 810/990 Soc搭载的达芬奇架构NPU），应当设置为npu, arm|
|--record_tailoring_info|当使用 根据模型裁剪库文件 功能时，则设置该选项为true，以记录优化后模型含有的kernel和OP信息，默认为false|

`--model_dir`适用于待优化的模型是非combined方式，PaddleOCR的inference模型是combined方式，即模型结构和模型参数使用单独一个文件存储。

- 步骤2：使用paddle_lite_opt将inference模型转换成移动端模型格式。

下面以PaddleOCR的超轻量中文模型为例，介绍使用编译好的opt文件完成inference模型到Paddle-Lite优化模型的转换。

```
# 【推荐】 下载 PP-OCRv3版本的中英文 inference模型
wget  https://paddleocr.bj.bcebos.com/PP-OCRv3/chinese/ch_PP-OCRv3_det_slim_infer


/* SPDX-License-Identifier: GPL-2.0-only */
/*
 * CQHCI crypto engine (inline encryption) support
 *
 * Copyright 2020 Google LLC
 */

#ifndef LINUX_MMC_CQHCI_CRYPTO_H
#define LINUX_MMC_CQHCI_CRYPTO_H

#include <linux/mmc/host.h>

#include "cqhci.h"

#ifdef CONFIG_MMC_CRYPTO

int cqhci_crypto_init(struct cqhci_host *host);

/*
 * Returns the crypto bits that should be set in bits 64-127 of the
 * task descriptor.
 */
static inline u64 cqhci_crypto_prep_task_desc(struct mmc_request *mrq)
{
	if (!mrq->crypto_ctx)
		return 0;

	/* We set max_dun_bytes_supported=4, so all DUNs should be 32-bit. */
	WARN_ON_ONCE(mrq->crypto_ctx->bc_dun[0] > U32_MAX);

	return CQHCI_CRYPTO_ENABLE_BIT |
	       CQHCI_CRYPTO_KEYSLOT(mrq->crypto_key_slot) |
	       mrq->crypto_ctx->bc_dun[0];
}

#else /* CONFIG_MMC_CRYPTO */

static inline int cqhci_crypto_init(struct cqhci_host *host)
{
	return 0;
}

static inline u64 cqhci_crypto_prep_task_desc(struct mmc_request *mrq)
{
	return 0;
}

#endif /* !CONFIG_MMC_CRYPTO */

#endif /* LINUX_MMC_CQHCI_CRYPTO_H */


arclha_new	rs.b	100
arczip_new	rs.b	100
arclzx_new	rs.b	100
pattern_new	rs.b	70
startup_new	rs.b	120
fkeys_new	rs.b	120*10
xfd_new		rs.b	1
fontname_new	rs.b	20+1
listfontname_new rs.b 	20+1
early_new	rs.b	1
prefix_new	rs.b	1
autosort_new	rs.b	1
favorites_new	rs.b	1
tooltips_new	rs.b 	1
savestate_new	rs.b 	1
altbuttons_new  rs.b   1

samplecyber_new	rs.b	1
mpegaqua_new	rs.b	1
mpegadiv_new	rs.b	1
medmode_new	rs.b	1
medrate_new	rs	1
medratepot_new	rs	1
sidmode_new     rs.b    1
residmode_new   rs.b    1
xmaplay_new     rs.b    1
medfastmemplay_new rs.b  1
mhiEnable_new   rs.b 1
residfilter_new rs.b    1
residboost_new  rs.b    1
midimode_new    rs.b    1
alarmpot_new	rs.l	1
alarm_new	rs	1
vbtimer_new	rs.b	1
Xscopechanged	rs.b	1		* scopea muutettu
contonerr_laskuri rs.b 1		* kuinka monta virheellist lataus
;cybercalibration_new rs.b 1		* yrityst
;calibrationfile_new rs.b 100
;newcalibrationfile rs.b	1
ps3mamigus_new    rs.b   1
scopesize_new     rs.b   1

mhiLib_new      rs.b MHILIB_SIZE

prefs_exit	rs.b	1		* Prefs exit-flaggi

slider4oldheight rs	1
slider1old	rs	1		* previous VertPot value to detect changes
slider4old	rs	1		* previous VertPot value to detect changes
mainvolume	rs	1		* p-nenvoimakkuus
mixirate	rs.l	1		* miksaustaajuus S3M:lle
textchecksum	rs	1
priority	rs.l	1		* ohjelman prioriteetti
tfmxmixingrate	rs	1		* rate 1-22
s3mmode1	rs.b	1		* prioriteetti / killeri
s3mmode2	rs.b	1	* surround,stereo,mono,real surround,14-bit
s3mmode3	rs.b	1		* Volume boost
stereofactor	rs.b	1		* stereofactor
xfd		rs.b	1		* ~0: kytetn xfdmaster.libb
ps3mb		rs.b	1

QUADMODE_QUADRASCOPE = 0
QUADMODE_HIPPOSCOPE = 1
QUADMODE_FREQANALYZER = 2
QUADMODE_PATTERNSCOPE = 3
QUADMODE_FQUADRASCOPE = 4
QUADMODE_PATTERNSCOPEXL = 5

* Store the original window height to switch between
* large and normal height mode
quadWindowHeightOriginal	rs.w	1

* Timeout mode: 0=all modules, $ff=only thos with no end-detection
timeoutmode	rs.b	1
filterstatus	rs.b	1		* filtterin
modulefilterstate rs.b	1		* ..
ptmix		rs.b	1		* 0: normi ptreplay, 1:mixireplay
xpkid		rs.b	1		* 0: ei xpktunnistusta, 1:joo
							* seems to be that 0 enables xpkid here
fade		rs.b	1		* 0: ei feidausta
boxsize		rs	1		* montako nime


\
                if node_interval in sv_dict and not sv_dict[node_interval].is_null() and not sv_dict[node_interval].is_patch
        ]

        for variant_call in new_var_list:
            variant_call.variant_id = svpoplib.variant.version_id_name(variant_call.variant_id, variant_id_set)
            variant_id_set.add(variant_call.variant_id)

        variant_call_list.extend(new_var_list)

        # Write dot file
        if dot_dirname is not None:
            dot_filename = os.path.join(dot_dirname, f'lgsv_graph_{query_id}.dot.gz')

            with pavlib.io.PlainOrGzFile(dot_filename, 'wt') as out_file:
                pavlib.lgsv.util.dot_graph_writer(
                    out_file, df_align, chain_set, optimal_interval_list, sv_dict, graph_name=f'"{query_id}"', forcelabels=True
                )

    # Return list
    return variant_call_list


rdering::MaybeConcurrent => {
          stream.this.maybe_sync(luse_ev);
        }
      }
    }
    match thst.ldef.t.causal_cmp(&stream.this.t) {
      PCausalOrdering::Before |
      PCausalOrdering::Equal => {}
      PCausalOrdering::After => {
        panic!("causal violation");
      }
      PCausalOrdering::MaybeConcurrent => {
        stream.this.maybe_sync(&mut thst.ldef);
      }
    }
    stream.this._push_sync_mut(self.thst.clone());
    TGpuThunkRefMut{
      val:    self.val,
      _mrk:   PhantomData,
    }
  }
}
<reponame>dongsub-joung/Rust_basic
fn main()
{
    println!("Hellow, world!");
}
use crate::segment::Segment;
use amethyst::ui::UiText;
use chrono::Local;
use uuid::Uuid;

#[derive(Default)]
pub struct Date {
    id: String,
}

impl Segment for Date {
    type Item = UiText;

    fn new() -> Self {
        Date {
            id: Uuid::new_v4().to_string(),
        }
    }

    fn update(&mut self, t: &mut UiText) {
        t.text = Local::now().format(" %T  %a %e %b W%V").to_string();
    }

    fn id(&self) -> &str {
        &self.id
    }
}
<gh_stars>1-10
use parameterized::parameterized;
use rdftk_core::model::graph::{GraphFactoryRef, GraphRef};
use rdftk_core::simple::graph::graph_factory as simple_graph_factory;
use rdftk_core::simple::indexed::graph_factory as indexed_graph_factory;
use rdftk_core::simple::PROVIDER_ID;
use rdftk_iri::{IRIRef, IRI};
use std::str::FromStr;

pub fn tony_benn_graph(graph_factory: GraphFactoryRef) -> GraphRef {
    let mappings = graph_factory.mapping_factory().empty();

    {
        let mut mut_mappings = mappings.borrow_mut();
        mut_mappings.include_rdf();
        mut_mappings.insert(
            "dc",
            IRIRef::from(IRI::from_str("http://purl.org/dc/elements/1.1/").unwrap()),
        );
        mut_mappings.insert(
            "foaf",
            IRIRef::from(IRI::from_str("http://xmlns.com/foaf/0.1/").unwrap()),
        );
    }

    let graph = graph_factory.with_mappings(mappings);

    {
        let mut ref_graph = graph.borrow_mut();

        let st_factory = ref_graph.statement_factory();
        let lit_factory = ref_graph.literal_factory();

        let subject_iri =
            IRIRef::from(IRI::from_str("http://en.wikipedia.org/wiki/Tony_Benn").unwrap());

        ref_graph.insert(
            st_factory
                .statement(
                    st_factory.named_subject(subject_iri.clone()),
                    IRIRef::from(IRI::from_str("http://purl.org/dc/elements/1.1/title").unwrap()),
                    st_factory.literal_object(lit_factory.literal("Tony Benn")),
                )
                .unwrap(),
        );
        ref_graph.insert(
            st_factory
                .statement(
                    st_factory.named_subject(subject_iri.clone()),
                    IRIRef::from(
                        IRI::from_str("http://purl.org/dc/elements/1.1/publisher").unwrap(),
                    ),
                    st_factory.literal_object


-feedback.no-icon {
	padding: 0.5em;
}

.buddypress-wrap .bp-feedback.small:before {
	line-height: inherit;
}

.buddypress-wrap a[data-bp-close] span:before,
.buddypress-wrap button[data-bp-close] span:before {
	font-size: 32px;
}

.buddypress-wrap a[data-bp-close],
.buddypress-wrap button[data-bp-close] {
	border: 0;
	position: absolute;
	top: 10px;
	left: 10px;
	width: 32px;
}

.buddypress-wrap .bp-feedback.no-icon a[data-bp-close],
.buddypress-wrap .bp-feedback.no-icon button[data-bp-close] {
	top: -6px;
	left: 6px;
}

.buddypress-wrap button[data-bp-close]:hover {
	background-color: transparent;
}

.buddypress-wrap .bp-feedback p {
	margin: 0;
}

.buddypress-wrap .bp-feedback .bp-icon {
	font-size: 20px;
	padding: 0 2px;
}

.buddypress-wrap .bp-feedback.info .bp-icon,
.buddypress-wrap .bp-feedback.help .bp-icon,
.buddypress-wrap .bp-feedback.error .bp-icon,
.buddypress-wrap .bp-feedback.warning .bp-icon,
.buddypress-wrap .bp-feedback.loading .bp-icon,
.buddypress-wrap .bp-feedback.success .bp-icon,
.buddypress-wrap .bp-feedback.updated .bp-icon,
.buddypress-wrap .bp-feedback.bp-sitewide-notice .bp-icon {
	display: flex;
	align-items: center;
	align-self: stretch;
}

.buddypress-wrap .bp-feedback.info .bp-icon,
.buddypress-wrap .bp-feedback.help .bp-icon {
	background-color: #0b80a4;
}

.buddypress-wrap .bp-feedback.info .bp-icon:before,
.buddypress-wrap .bp-feedback.help .bp-icon:before {
	content: "\f348";
}

.buddypress-wrap .bp-feedback.error .bp-icon,
.buddypress-wrap .bp-feedback.warning .bp-icon {
	background-color: #d33;
}

.buddypress-wrap .bp-feedback.error .bp-icon:before,
.buddypress-wrap .bp-feedback.warning .bp-icon:before {
	content: "\f534";
}

.buddypress-wrap .bp-feedback.loading .bp-icon {
	background-color: #ffd087;
}

.buddypress-wrap .bp-feedback.loading .bp-icon:before {
	content: "\f469";
}

.buddypress-wrap .bp-feedback.success .bp-icon,
.buddypress-wrap .bp-feedback.updated .bp-icon {
	background-color: #8a2;
}

.buddypress-wrap .bp-feedback.success .bp-icon:before,
.buddypress-wrap .bp-feedback.updated .bp-icon:before {
	content: "\f147";
}

.buddypress-wrap .bp-feedback.help .bp-icon:before {
	content: "\f468";
}

.buddypress-wrap #pass-strength-result {
	background-color: #eee;
	border-color: #ddd;
	border-style: solid;
	border-width: 1px;
	display: none;
	font-weight: 700;
	margin: 10px 0 10px 0;
	padding: 0.5e


t2.id))
		return ok([state, context]);
	if(t1 instanceof TUnit && t2 instanceof TUnit)
		return ok([state, context]);
	if(t1 instanceof TFun && t2 instanceof TFun)
		return subtype(state, context, t2.left, t1.left)
			.then(([st1, c1]) => subtype(st1, c1, t1.right.apply(c1), t2.right.apply(c1)));
	if(t1 instanceof TForall) {
		const [st1, id] = state.fresh();
		return subtype(
			st1,
			context.add(cmarker(id), cexists(id)),
			t1.type.subst(t1.tvar, texists(id)),
			t2
		).then(([st2, c1]) => ok([st2, c1.dropFrom(cmarker(id))]));
	}
	if(t2 instanceof TForall)
		return subtype(
			state,
			context.add(cforall(t2.tvar)),
			t1,
			t2.type
		).then(([st1, c1]) => ok([st1, c1.dropFrom(cforall(t2.tvar))]));
	if(t1 instanceof TExists && !t2.free().contains(t1.id))
		return instantiateL(state, context, t1.id, t2);
	if(t2 instanceof TExists && !t1.free().contains(t2.id))
		return instantiateR(state, context, t1, t2.id);

	return err('Subtype failed on ' + t1 + ' and ' + t2 + ' with ' + context);
};

const solve = (context: Context, tvar: TypeId, type: Type): InferResult<Context> => {
	if(!type.isMono())
		return err(`Cannot solve with a polytype: ${tvar} = ${type}`);
	const [left, right] = context.split(cexists(tvar));
	if(type.isWellformed(left))
		return ok(Context.join(left, cexistssolved(tvar, type), right));
	return err(`Ill-formed type in solve: ${type}`);
};

const instantiateL = (state: InferState, context: Context, tv: TypeId, type: Type)
	:	InferResult<[InferState, Context]> => {

	if(!context.isWellformed())
		return err(`Ill-formed context in instantiateL: ${context}`);
	if(!texists(tv).isWellformed(context))
		return err(`Ill-formed type in instantiateL: ${texists(tv)} with ${context}`);
	if(!type.isWellformed(context))
		return err(`Ill-formed type in instantiateL: ${type} with ${context}`);

	return solve(context, tv, type)
		.then(c => ok([state, c]))
		.onErr(_ => {
			if(type instanceof TExists)
				return context.isOrdered(tv, type.id)?
					solve(context, type.id, texists(tv)).map(c => [state, c]):
					solve(context, tv, texists(type.id)).map(c => [state, c]);
			if(type instanceof TFun) {
				const [st1, alpha1] = state.fresh();
				const [st2, alpha2] = st1.fresh();
				return instantiateR(
					st2,
					context.insertAt(cexists(tv), [
						cexists(alpha2),
						cexists(alpha1),
						cexistssolved(tv, tfun(texists(alpha1), texists(alpha2))),
					]),
					type.left,
					alpha1
				).then(([st3, c1]) => instantiateL(st3, c1, alpha2, type.right.apply(c1)));
			}
			if(type instanceof TForall) {
				const [st1, beta] = state.fresh();
				return instantiateL(
					st1,
					context.add(cforall(beta


letMap;
        if (!coordSys) {

            coordSys = new MapCoordSys(leafletMap, api);
        }

        coordSys.setMapOffset(leafletMapModel.__mapOffset || [0, 0]);
        leafletMapModel.coordinateSystem = coordSys;
    });

    ecModel.eachSeries(function (seriesModel) {
        if (!seriesModel.get('coordinateSystem') || seriesModel.get('coordinateSystem') === 'leaflet') {
            if (!coordSys) {
                var leafletMap = echarts.leafletMap;
                coordSys = new MapCoordSys(leafletMap, api);
            }
            seriesModel.coordinateSystem = coordSys;
            seriesModel.animation = seriesModel.animation === true;
        }
    })
}

export default MapCoordSys;import { CesiumZondy } from '../core/Base';

import BaseLayer from '../layer/BaseLayer';

/**
 * @author 三维基础平台研发中心·冯桂英
 * @class module:客户端可视化.LabelLayer
 * @category  LabelLayer
 * @classdesc LabelLayer注记图层管理类
 * @description 注记图层管理类,处理注记相关操作
 * @param options.viewer 场景视图
 */
export default class LabelLayer extends BaseLayer {
    constructor(optionsParam) {
        const options = optionsParam;
        super(options);
    }

    /**
     * 添加文字标签
     * @function module:客户端可视化.LabelLayer.prototype.appendLabel
     * @param {Number} lon 经度
     * @param {Number} lat 纬度
     * @param {Number} height 高程
     * @param {String} lText 标签内容
     * @param {Object} optionsParam 参数
     * @param {String} [optionsParam.font='14pt monospace'] 字体
     * @param {Color}  [optionsParam.fillColor =Cesium.Color.WHITE ] 字体的填充色
     * @param {Color}  [optionsParam.outlineColor =Cesium.Color.WHITE ] 字体的填充色
     * @param {LabelStyle} [optionsParam.style = Cesium.LabelStyle.FILL_AND_OUTLINE ] 样式
     * @param {Number} [optionsParam.outlineWidth =1 ] 外边线宽度
     * @param {Number} [optionsParam.heightReference =Cesium.HeightReference.NONE ] 外边线宽度
     * @param {VerticalOrigin} [optionsParam.verticalOrigin = Cesium.VerticalOrigin.CENTER] 标签位置 Cesium.VerticalOrigin.Cesium.VerticalOrigin.LEFT Cesium.VerticalOrigin.RIGHT
     * @param {HorizontalOrigin} [optionsParam.horizontalOrigin = Cesium.HorizontalOrigin.CENTER] 标签位置 Cesium.HorizontalOrigin.Cesium.HorizontalOrigin.LEFT Cesium.HorizontalOrigin.RIGHT
     * @param {String} [optionsParam.description] 属性描述
     * @returns {Entity} 标签对象 移除通过removeEntity(entity)
     * @example
     *  let labelLayer = new LabelLayer({viewer:viewer});
     *  let label = labelLayer.appendLabel(114.2, 31, 200, '这是一个标签', {
     *      font:'14pt 楷体',
     *      style:Cesium.LabelStyle.FILL_AND_OUTLINE,
     *      verticalOrigin:Cesium.VerticalOrigin.BOTTOM,
     *      pixelOffset:new Cesium.Cartesian2(0, -9)});
     */
    appendLabel(lon, lat, height, lText, optionsParam) {
        const options = Cesium.defaultValue(optionsParam, Cesium.defaultValue.EMPTY_OBJECT);
        const lFont = Cesium.defaultValue(options.font, '14pt monospace');
        const lFillColor = Cesium.defaultV


 dx = this.x - x;
        double dy = this.y - y;
        return dx * dx + dy * dy;
    }

    public float getX() {
        return x;
    }

    public float getY() {
        return y;
    }

    public float[] getHsv() {
        return hsv;
    }

    public float[] getHsvWithLightness(float lightness) {
        if (hsvClone == null)
            hsvClone = hsv.clone();
        hsvClone[0] = hsv[0];
        hsvClone[1] = hsv[1];
        hsvClone[2] = lightness;
        return hsvClone;
    }

    public void set(float x, float y, float[] hsv) {
        this.x = x;
        this.y = y;
        this.hsv[0] = hsv[0];
        this.hsv[1] = hsv[1];
        this.hsv[2] = hsv[2];
        this.color = Color.HSVToColor(this.hsv);
    }

    public int getColor() {
        return color;
    }
}package dump.b.a.slider;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.util.AttributeSet;

import dump.b.a.ColorPickerView;
import dump.b.a.Utils;
import dump.b.a.builder.PaintBuilder;

public class LightnessSlider extends AbsCustomSlider {
    private int color;
    private Paint barPaint = PaintBuilder.newPaint().build();
    private Paint solid = PaintBuilder.newPaint().build();
    private Paint clearingStroke = PaintBuilder.newPaint().color(0xffffffff).xPerMode(PorterDuff.Mode.CLEAR).build();

    private ColorPickerView colorPicker;

    public LightnessSlider(Context context) {
        super(context);
    }

    public LightnessSlider(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public LightnessSlider(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @Override
    protected void drawBar(Canvas barCanvas) {
        int width = barCanvas.getWidth();
        int height = barCanvas.getHeight();

        float[] hsv = new float[3];
        Color.colorToHSV(color, hsv);
        int l = Math.max(2, width / 256);
        for (int x = 0; x <= width; x += l) {
            hsv[2] = (float) x / (width - 1);
            barPaint.setColor(Color.HSVToColor(hsv));
            barCanvas.drawRect(x, 0, x + l, height, barPaint);
        }
    }

    @Override
    protected void onValueChanged(float value) {
        if (colorPicker != null)
            colorPicker.setLightness(value);
    }

    @Override
    protected void drawHandle(Canvas canvas, float x, float y) {
        solid.setColor(Utils.colorAtLightness(color, value));
        canvas.drawCircle(x, y, handleRadius, clearingStroke);
        canvas.drawCircle(x, y, handleRadius * 0.75f, solid);
    }

    public void setColorPicker(ColorPickerView colorPicker) {
        this.colorPicker = colorPicker;
    }

    public void setColor(int color) {
        this.color = color;
        this.value = Utils.lightnessOfColor(color);
        if (bar != null) {
            updateBar();
            invalidate();
        }
    }
}/*
Copyright 2009 David Revell

This file is part of SwiFTP.

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

SwiFTP 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 PARTICULA


ameList( type );

			if ( list != null )
				return list.GetRandomName();

			return "";
		}

		private static Dictionary<string, NameList> m_Table;

		static NameList()
		{
			m_Table = new Dictionary<string, NameList>( StringComparer.OrdinalIgnoreCase );

			string filePath = Path.Combine( Core.BaseDirectory, "Data/names.xml" );

			if ( !File.Exists( filePath ) )
				return;

			try
			{
				Load( filePath );
			}
			catch ( Exception e )
			{
				Console.WriteLine( "Warning: Exception caught loading name lists:" );
				Console.WriteLine( e );
			}
		}

		private static void Load( string filePath )
		{
			XmlDocument doc = new XmlDocument();
			doc.Load( filePath );

			XmlElement root = doc["names"];

			foreach ( XmlElement element in root.GetElementsByTagName( "namelist" ) )
			{
				string type = element.GetAttribute( "type" );

				if ( String.IsNullOrEmpty( type ) )
					continue;

				try
				{
					NameList list = new NameList( type, element );

					m_Table[type] = list;
				}
				catch
				{
				}
			}
		}
	}
}


yName;
        /// <summary>
        /// List of identifiers issued to this resource by an external identity provider.
        /// </summary>
        public readonly ImmutableArray<Outputs.GetGroupExternalIdResult> ExternalIds;
        public readonly string GroupId;
        /// <summary>
        /// The provider-assigned unique ID for this managed resource.
        /// </summary>
        public readonly string Id;
        public readonly string IdentityStoreId;
        public readonly string Region;

        [OutputConstructor]
        private GetGroupResult(
            Outputs.GetGroupAlternateIdentifierResult? alternateIdentifier,

            string description,

            string displayName,

            ImmutableArray<Outputs.GetGroupExternalIdResult> externalIds,

            string groupId,

            string id,

            string identityStoreId,

            string region)
        {
            AlternateIdentifier = alternateIdentifier;
            Description = description;
            DisplayName = displayName;
            ExternalIds = externalIds;
            GroupId = groupId;
            Id = id;
            IdentityStoreId = identityStoreId;
            Region = region;
        }
    }
}


信息，请参阅“no-toplevel-property-access” tslint 规则）。保持此枚举与上面的
 * `InjectFlags` 枚举同步。
 *
 */
export const enum InternalInjectFlags {
  /**
   * Check self and check parent injector if needed
   *
   * 检查自我并在需要时检查父注入器
   *
   */
  Default = 0b0000,

  /**
   * Specifies that an injector should retrieve a dependency from any injector until reaching the
   * host element of the current component. \(Only used with Element Injector\)
   *
   * 指定注入器应该从任何注入器检索依赖项，直到到达当前组件的宿主元素。（仅与 Element Injector
   * 一起使用）
   *
   */
  Host = 0b0001,

  /**
   * Don't ascend to ancestors of the node requesting injection.
   *
   * 不要上升到请求注入的节点的祖先。
   *
   */
  Self = 0b0010,

  /**
   * Skip the node that is requesting injection.
   *
   * 跳过正在请求注入的节点。
   *
   */
  SkipSelf = 0b0100,

  /**
   * Inject `defaultValue` instead if token not found.
   *
   * 如果找不到标记，则注入 `defaultValue`。
   *
   */
  Optional = 0b1000,

  /**
   * This token is being injected into a pipe.
   *
   * 此标记正在被注入管道。
   *
   * This flag is intentionally not in the public facing `InjectFlags` because it is only added by
   * the compiler and is not a developer applicable flag.
   *
   * 此标志故意不在面向公众的 `InjectFlags` 中，因为它只是由编译器添加，并且不是开发人员适用的标志。
   *
   */
  ForPipe = 0b10000,
}

/**
 * Type of the options argument to `inject`.
 *
 * 要 `inject` 选项参数的类型。
 *
 * @publicApi
 */
export interface InjectOptions {
  /**
   * Use optional injection, and return `null` if the requested token is not found.
   *
   * 使用可选注入，如果未找到请求的令牌，则返回 `null`。
   *
   */
  optional?: boolean;

  /**
   * Start injection at the parent of the current injector.
   *
   * 在当前注入器的父级开始注入。
   *
   */
  skipSelf?: boolean;

  /**
   * Only query the current injector for the token, and don't fall back to the parent injector if
   * it's not found.
   *
   * 只查询当前注入器的令牌，如果找不到则不要回退到父注入器。
   *
   */
  self?: boolean;

  /**
   * Stop injection at the host component's injector. Only relevant when injecting from an element
   * injector, and a no-op for environment injectors.
   *
   * 在宿主组件的注入器处停止注入。仅在从元素注入器注入时相关，并且对环境注入器无操作。
   *
   */
  host?: boolean;
}
{

  type CoffeeCup = {
    shots: number;
    hasMilk?: boolean;
    sugar?: boolean;
  };

  interface CoffeeMaker {
    makeCoffee(shots: number): CoffeeCup;
  }

  abstract class CoffeeMachine implements CoffeeMaker {
    private static BEANS


}
/*gap between btn*/
.weui-btn + .weui-btn {
  margin-top: 15px;
}
.weui-btn.weui-btn_inline + .weui-btn.weui-btn_inline {
  margin-top: auto;
  margin-left: 15px;
}
.weui-btn-area {
  margin: 1.17647059em 15px 0.3em;
}
.weui-btn-area_inline {
  display: -webkit-box;
  display: -ms-flexbox;
  display: flex;
}
.weui-btn-area_inline .weui-btn {
  margin-top: auto;
  margin-right: 15px;
  width: 100%;
  -webkit-box-flex: 1;
      -ms-flex: 1;
          flex: 1;
}
.weui-btn-area_inline .weui-btn:last-child {
  margin-right: 0;
}
button.weui-btn,
input.weui-btn {
  width: 100%;
  border-width: 0;
  outline: 0;
  -webkit-appearance: none;
}
button.weui-btn:focus,
input.weui-btn:focus {
  outline: 0;
}
button.weui-btn_inline,
input.weui-btn_inline,
button.weui-btn_mini,
input.weui-btn_mini {
  width: auto;
}
button.weui-btn_plain-primary,
input.weui-btn_plain-primary,
button.weui-btn_plain-default,
input.weui-btn_plain-default {
  border-width: 1px;
  background-color: transparent;
}
.weui-btn_mini {
  display: inline-block;
  padding: 0 1.32em;
  line-height: 2.3;
  font-size: 13px;
}
/*gap between btn*/
.weui-btn + .weui-btn {
  margin-top: 15px;
}
.weui-btn.weui-btn_inline + .weui-btn.weui-btn_inline {
  margin-top: auto;
  margin-left: 15px;
}
.weui-btn-area {
  margin: 1.17647059em 15px 0.3em;
}
.weui-btn-area_inline {
  display: -webkit-box;
  display: -ms-flexbox;
  display: flex;
}
.weui-btn-area_inline .weui-btn {
  margin-top: auto;
  margin-right: 15px;
  width: 100%;
  -webkit-box-flex: 1;
      -ms-flex: 1;
          flex: 1;
}
.weui-btn-area_inline .weui-btn:last-child {
  margin-right: 0;
}
.weui-msg {
  padding-top: 36px;
  text-align: center;
}
.weui-msg__icon-area {
  margin-bottom: 30px;
}
.weui-msg__text-area {
  margin-bottom: 25px;
  padding: 0 20px;
}
.weui-msg__text-area a {
  color: #586C94;
}
.weui-msg__title {


import json
from cealn.action import StructuredMessageConfig

from cealn.rule import Rule
from cealn.attribute import FileAttribute, GlobalProviderAttribute
from cealn.label import LabelPath
from ..providers import YarnToolchain, NodeToolchain, YarnWorkspace as YarnWorkspaceProvider

class YarnWorkspace(Rule):
    package_json = FileAttribute()

    yarn_toolchain = GlobalProviderAttribute(YarnToolchain, host=True)
    node_toolchain = GlobalProviderAttribute(NodeToolchain, host=True)

    async def analyze(self):
        root_package_json_contents = await self.build_file_contents(self.package_json, encoding="utf-8")

        root_package_json = json.loads(root_package_json_contents)

        workspace_root = self.package_json.parent
        package_skeleton = self.new_depmap()
        package_skeleton["package.json"] = self.package_json
        package_skeleton["yarn.lock"] = workspace_root / "yarn.lock"
        package_skeleton[".yarnrc.yml"] = workspace_root / ".yarnrc.yml"

        packages_to_process = list(LabelPath(member) for member in root_package_json["workspaces"])
        while packages_to_process:
            package_path = packages_to_process.pop()

            package_json_label = workspace_root / package_path / "package.json"
            package_skeleton[package_path / "package.json"] = package_json_label

            package_json = json.loads(await self.build_file_contents(package_json_label, encoding="utf-8"))
            if "workspaces" in package_json:
                packages_to_process.extend(package_path / member for member in package_json["workspaces"])

        package_skeleton = package_skeleton.build()

        install = self.run(
            self.yarn_toolchain.yarn,
            "install",
            "--immutable",
            "--json",
            input=package_skeleton,
            id="install",
            mnemonic="YarnInstall",
            progress_message=str(self.package_json),
            structured_messages=_YARN_INSTALL_STRUCTURED_MESSAGE_CONFIG,
        )

        files = self.new_depmap()
        files.merge(package_skeleton)
        files.merge(install.files)
        files = files.build()

        return [YarnWorkspaceProvider(files=files)]

_YARN_INSTALL_STRUCTURED_MESSAGE_CONFIG = StructuredMessageConfig()
_YARN_INSTALL_STRUCTURED_MESSAGE_CONFIG.level_map["$.[?($.type=='error')]"] = "error"
_YARN_INSTALL_STRUCTURED_MESSAGE_CONFIG.level_map["$.[?($.type=='warning')]"] = "warn"


>
    /// Creates a new 17-dimensional coproduct with the specified value on the fourteenth position.
    /// </summary>
    public Coproduct17(T14 fourteenthValue)
        : this(14, fourteenthValue)
    {
    }

    /// <summary>
    /// Creates a new 17-dimensional coproduct with the specified value on the fifteenth position.
    /// </summary>
    public Coproduct17(T15 fifteenthValue)
        : this(15, fifteenthValue)
    {
    }

    /// <summary>
    /// Creates a new 17-dimensional coproduct with the specified value on the sixteenth position.
    /// </summary>
    public Coproduct17(T16 sixteenthValue)
        : this(16, sixteenthValue)
    {
    }

    /// <summary>
    /// Creates a new 17-dimensional coproduct with the specified value on the seventeenth position.
    /// </summary>
    public Coproduct17(T17 seventeenthValue)
        : this(17, seventeenthValue)
    {
    }

    /// <summary>
    /// Creates a new 17-dimensional coproduct based on the specified source.
    /// </summary>
    public Coproduct17(ICoproduct17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> source)
        : this(source.CoproductDiscriminator, source.CoproductValue)
    {
    }

    /// <summary>
    /// Creates a new 17-dimensional coproduct.
    /// </summary>
    /// <param name="discriminator">Discriminator of the value from interval [1, arity].</param>
    /// <param name="value">Value of the coproduct on the position defined by the discriminator.</param>
    protected Coproduct17(int discriminator, object value)
        : base(17, discriminator, value)
    {
    }

    public bool IsFirst
    {
        get { return CoproductDiscriminator == 1; }
    }
    public bool IsSecond
    {
        get { return CoproductDiscriminator == 2; }
    }
    public bool IsThird
    {
        get { return CoproductDiscriminator == 3; }
    }
    public bool IsFourth
    {
        get { return CoproductDiscriminator == 4; }
    }
    public bool IsFifth
    {
        get { return CoproductDiscriminator == 5; }
    }
    public bool IsSixth
    {
        get { return CoproductDiscriminator == 6; }
    }
    public bool IsSeventh
    {
        get { return CoproductDiscriminator == 7; }
    }
    public bool IsEighth
    {
        get { return CoproductDiscriminator == 8; }
    }
    public bool IsNinth
    {
        get { return CoproductDiscriminator == 9; }
    }
    public bool IsTenth
    {
        get { return CoproductDiscriminator == 10; }
    }
    public bool IsEleventh
    {
        get { return CoproductDiscriminator == 11; }
    }
    public bool IsTwelfth
    {
        get { return CoproductDiscriminator == 12; }
    }
    public bool IsThirteenth
    {
        get { return CoproductDiscriminator == 13; }
    }
    public bool IsFourteenth
    {
        get { return CoproductDiscriminator == 14; }
    }
    public bool IsFifteenth
    {
        get { return CoproductDiscriminator == 15; }
    }


m::GETFIELD as OpABC => {

        let dst_index = args.a as uint;
        let slot_refr = vm.slots.load(args.b as uint).clone();

        let refr = match slot_refr {
            Obj(sobj) => sobj,
            _ => panic!("GETFIELD Failed!")
        };

        let offset = args.c as uint;
        let dst = refr.fields[offset].clone();

        vm.slots.store(dst_index, dst);

        vm.fetch_next()
    },

    // -------------------- Closure -------------------

    vm::UCLO as OpAD => {

        let start_slot = args.a as uint;
        let end_slot = args.d as uint;
        let fnew_slot_index = end_slot + 1;

        let new_freevars = vm.slots[start_slot..end_slot+1].to_vec();

        match vm.slots.load(fnew_slot_index) {
            Func(func) => {vm.slots.store(fnew_slot_index, SCC(Closure{func:func,
                                                                       freevar:new_freevars}));
                          }
            SCC(clos) =>  {let mut new_clos = clos.clone();
                           new_clos.freevar.push_all(vm.slots[start_slot..end_slot+1]);
                           vm.slots.store(fnew_slot_index, SCC( new_clos.clone()));
                          }
            _ => panic!("Not Func type on FNEW slot")
        };

        vm.fetch_next()
    },

    //    OP      A       D
    //GETFREEVAR  dst     idx

    vm::GETFREEVAR as OpAD => {

        let idx = args.d as uint;
        let dst_idx = args.a as uint;

        let freevar = match vm.slots.load(1u) {
                        SCC(clos) => clos.freevar[idx].clone(),
                        _ => panic!("Not Closure in Slot")
                      };

        vm.slots.store(dst_idx, freevar);

        vm.fetch_next()
    },

    // --------------- Run-Time Behavior ------------

    vm::DROP as OpAD => {

        for i in range(args.a as int, 1 + args.d as int) {
            vm.slots.store(i, Nil);
        }

        vm.fetch_next()
    },

    // Currently very very slow
    vm::TRANC as OpAD => {

        for i in range(args.d as uint, vm.slots.slot.len() ) {
            vm.slots.store(i, Nil);
        }

        vm.fetch_next()
    },

    _ as Instr => {
        error!("skipping instruction: {}", args);
        vm.fetch_next()
    }
}

pub use self::sigmoid::sigmoid;
mod sigmoid;

pub use self::softmax::softmax;
mod softmax;

pub use self::relu::relu;
mod relu;
extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    unsafe {
        println!("La valeur absolue de -3 selon le langage C : {}", abs(-3));
    }
}
//! DNS relay

use std::io;

use futures::{self, Future};

use crate::{
    config::Config,
    context::{Context, SharedContext},
    relay::udprelay::dns::run as run_udp,
};

/// DNS Relay server running under local environment.
pub fn run(config: Config) -> impl Future<Item = (), Error = io::Error> + Send {
    futures::lazy(move || run_udp(SharedContext::new(Context::new_dns(config))))
}
#[derive(Serialize)]
pub struct Picture {
    pub src : String
}use std::sync::{Arc, Mutex};
use {Context, InnerContext, ContextError};
use futures::{Future, Poll, Async};
use futures::task::{self, Task};

pub struct WithCancel {
    parent: Context,


 and defining edges to
        // each immediate adjacent vertex. The resulting pattern looks like 3 spokes coming out of the original UM or LM vertex.
        veh_edges = new int[][]
        { {0, 13}, {0, 14}, {0, 15},
          {1, 4}, {1, 5}, {1, 12},
          {2, 6}, {2, 13}, {2, 18},
          {3, 7}, {3, 14}, {3, 19},
          {4, 10}, {4, 18}, {4, 1},
          {5, 11}, {5, 19}, {5, 1},
          {6, 2}, {6, 15}, {6, 10},
          {7, 11}, {7, 15}, {7, 3},
          {8, 9}, {8, 13}, {8, 16},
          {9, 14}, {9, 8}, {9, 17},
          {10, 4}, {10,6}, {10, 11},
          {11, 10}, {11, 7}, {11, 5},
          {12, 1}, {12, 16}, {12, 17},
          {13, 0}, {13, 2}, {13, 8},
          {14, 3}, {14, 0}, {14, 9},
          {15, 0}, {15, 7}, {15, 6},
          {16, 18}, {16, 8}, {16, 12},
          {17, 9}, {17, 12}, {17, 19},
          {18, 4}, {18, 2}, {18, 16},
          {19, 3}, {19, 5}, {19, 17}
        };

        // The order of the vertices in each of the triangles is significant. The points should follow
        // a path counter clock wise about the triangle's normal vector. The position normal side of
        // the triangle is the visable side.

        veh_triangles = new int[][]
        {
          {0, 14, 9}, {0, 9, 8}, {0, 8, 13}, // First pentagon using vertices 0, 8, 9, 13, 14
          {13, 15, 0}, {13, 6, 15}, {13, 2, 6}, // Second pentagon using vertices 0, 2, 6, 13, 15
          {2, 13, 8}, {2, 8, 16}, {2, 16, 18}, // Third pentagon using vertices 2, 8, 13, 16, 18
          {18, 6, 2}, {18, 10 ,6}, {18, 4, 10}, // Fourth pentagon using vertices 2, 4, 6, 10, 18
          {4, 18, 16}, {4, 16, 12}, {4, 12, 1}, // Fifth pentagon using 1, 4, 12, 16, 18
          {1, 10, 4}, {1, 11, 10}, {1, 5, 11}, // Sixth pentagon using vertices 1, 4, 5, 10, 11
          {5, 1, 12}, {5, 12, 17}, {5, 17, 19}, // Seventh pentagon using vertices 1, 5, 12, 17, 19
          {19, 11, 5}, {19, 7, 11}, {19, 3, 7}, // Eight pentagon using vertices 3, 4, 7, 11, 19
          {3, 19, 17}, {3, 17, 9}, {3, 9, 14}, // Ninth pentagon using vertices 3, 9, 14, 17, 19
          {14, 7, 3}, {14, 15, 7}, {14, 0, 15}, // Tenth pentagon using vertices 0, 3, 7, 14, 15
          {15, 6, 10}, {15, 10, 11}, {15, 11, 7}, // Top pentagon (perpendicular above to xy plane)
          {12, 16, 8}, {12, 8, 9}, {12, 9, 17} // Bottom pentagon (perpendicular below to xy plane)
        };

        // Create the normals for the triangles
        veh_unit_normals_body = new double[veh_triangles.length][3];
        double v1[] = {0.0, 0.0, 0.0};
        double v2[] = {0.0, 0.0, 0.0};
        for (int i=0; i < veh_unit_normals_body.length