\d+,\s*(100|0*\d{1,2})%,\s*(100|0*\d{1,2})%(,\s*0?\.?\d+)?\))/gi

export function getNameColor(word: string): VSColor | null {
  if (names.indexOf(word) == -1) return null
  let c = new Color(word)
  return { red: c.red() / 255, green: c.green() / 255, blue: c.blue() / 255, alpha: 1 }
}

export function findColorHex(document: TextDocument): ColorInformation[] {
  colorHex.lastIndex = 0
  return findColors(document, colorHex)
}

export function findColorFunctions(document: TextDocument): ColorInformation[] {
  colorFunctions.lastIndex = 0
  return findColors(document, colorFunctions)
}

export function findHwb(document: TextDocument): ColorInformation[] {
  colorHwb.lastIndex = 0
  return findColors(document, colorHwb)
}

function findColors(document: TextDocument, regex: RegExp): ColorInformation[] {
  let text = document.getText()
  let match = regex.exec(text)
  let result: ColorInformation[] = []
  while (match !== null) {
    const start = match.index
    try {
      const c = new Color(match[0].toLowerCase())
      result.push({
        color: { red: c.red() / 255, green: c.green() / 255, blue: c.blue() / 255, alpha: c.alpha() },
        range: Range.create(document.positionAt(start), document.positionAt(start + match[0].length))
      })
    } catch (e) {
      // noop
      console.error(e.stack)
    }
    match = regex.exec(text)
  }
  return result
}
export class DaySchema {

  public name: string;

  public start: number;

  public active: boolean;

  public startsWithVaccinate: boolean;

  constructor(
    name: string, start: number, active: boolean, startsWithVaccinate: boolean) {
    this.name = name;
    this.start = start;
    this.active = active;
    this.startsWithVaccinate = startsWithVaccinate;
  }
}
export class UpdateQueue {
    protected execPrev: Promise<void> = Promise.resolve();

    /**
     * Adds a function to the queue
     * @param func The function to be executed
     * @returns A function to cancel the update
     */
    public add(func: (...args: any[]) => any): () => void {
        let canceled = false;
        this.execPrev = this.execPrev.then(async () => {
            if (canceled) return;
            func();
            await new Promise(res => setTimeout(res, 2)); // Insert an update cycle
        });

        return () => {
            canceled = true;
        };
    }
}

/**
 * A queue that can be used to make sure not all updates are dispatched at once
 */
export const updateQueue = new UpdateQueue();
import {observable, action} from 'mobx';

import { Effect, EffectTargetType, EffectTarget } from 'model/effect';

export class InteractionState {
    @observable selection?: Readonly<EffectTargetType<EffectTarget>>;
    selectionPromise?: Promise<EffectTarget>;

    onSelected?: (target: EffectTarget) => void;
    onSelectionCancelled?: () => void;

    constructor() {

    }

    isSelecting(): boolean {
        return !!this.selection;
    }

    @action
    select(target: EffectTarget) {
        if (!this.selection) {
            throw new Error(`Attempt to select ${target.type}, but no selection is initialized`);
        }
        if (this.selection.type !== target.type) {
            throw new Error(`Attempt to select ${target.type},


tra	%f13, %f0, %f0, 0
	sxtra	%f8, %f8, %f8, 8

#CHECK: xgrk	%r0, %r0, %r0           # encoding: [0xb9,0xe7,0x00,0x00]
#CHECK: xgrk	%r0, %r0, %r15          # encoding: [0xb9,0xe7,0xf0,0x00]
#CHECK: xgrk	%r0, %r15, %r0          # encoding: [0xb9,0xe7,0x00,0x0f]
#CHECK: xgrk	%r15, %r0, %r0          # encoding: [0xb9,0xe7,0x00,0xf0]
#CHECK: xgrk	%r7, %r8, %r9           # encoding: [0xb9,0xe7,0x90,0x78]

	xgrk	%r0,%r0,%r0
	xgrk	%r0,%r0,%r15
	xgrk	%r0,%r15,%r0
	xgrk	%r15,%r0,%r0
	xgrk	%r7,%r8,%r9

#CHECK: xrk	%r0, %r0, %r0           # encoding: [0xb9,0xf7,0x00,0x00]
#CHECK: xrk	%r0, %r0, %r15          # encoding: [0xb9,0xf7,0xf0,0x00]
#CHECK: xrk	%r0, %r15, %r0          # encoding: [0xb9,0xf7,0x00,0x0f]
#CHECK: xrk	%r15, %r0, %r0          # encoding: [0xb9,0xf7,0x00,0xf0]
#CHECK: xrk	%r7, %r8, %r9           # encoding: [0xb9,0xf7,0x90,0x78]

	xrk	%r0,%r0,%r0
	xrk	%r0,%r0,%r15
	xrk	%r0,%r15,%r0
	xrk	%r15,%r0,%r0
	xrk	%r7,%r8,%r9


.9l-98.7 225.5zm375.1-375.1L471.9 420 604 552.1l98.7-225.5c.4-1.1.4-2.2 0-3.2-.9-2.1-3.3-3-5.3-2.1z"/><path fill="currentColor" d="M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z"/></svg>';
  static const String compress_outlined =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="1024" height="1024" preserveAspectRatio="xMidYMid meet" viewBox="0 0 1024 1024"><path fill="currentColor" d="M326 664H104c-8.8 0-16 7.2-16 16v48c0 8.8 7.2 16 16 16h174v176c0 8.8 7.2 16 16 16h48c8.8 0 16-7.2 16-16V696c0-17.7-14.3-32-32-32zm16-576h-48c-8.8 0-16 7.2-16 16v176H104c-8.8 0-16 7.2-16 16v48c0 8.8 7.2 16 16 16h222c17.7 0 32-14.3 32-32V104c0-8.8-7.2-16-16-16zm578 576H698c-17.7 0-32 14.3-32 32v224c0 8.8 7.2 16 16 16h48c8.8 0 16-7.2 16-16V744h174c8.8 0 16-7.2 16-16v-48c0-8.8-7.2-16-16-16zm0-384H746V104c0-8.8-7.2-16-16-16h-48c-8.8 0-16 7.2-16 16v224c0 17.7 14.3 32 32 32h222c8.8 0 16-7.2 16-16v-48c0-8.8-7.2-16-16-16z"/></svg>';
  static const String console_sql_outlined =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="1024" height="1024" preserveAspectRatio="xMidYMid meet" viewBox="0 0 1024 1024"><path fill="currentColor" d="M301.3 496.7c-23.8 0-40.2-10.5-41.6-26.9H205c.9 43.4 36.9 70.3 93.9 70.3 59.1 0 95-28.4 95-75.5 0-35.8-20-55.9-64.5-64.5l-29.1-5.6c-23.8-4.7-33.8-11.9-33.8-24.2 0-15 13.3-24.5 33.4-24.5 20.1 0 35.3 11.1 36.6 27h53c-.9-41.7-37.5-70.3-90.3-70.3-54.4 0-89.7 28.9-89.7 73 0 35.5 21.2 58 62.5 65.8l29.7 5.9c25.8 5.2 35.6 11.9 35.6 24.4.1 14.7-14.5 25.1-36 25.1z"/><path fill="currentColor" d="M928 140H96c-17.7 0-32 14.3-32 32v496c0 17.7 1


if get_config("ue4ssCross") ~= "msvc-wine" then
    includes("proxy_generator")
end

add_requires("imgui v1.92.1", { debug = is_mode_debug(), configs = { win32 = true, dx11 = true, opengl3 = true, glfw_opengl3 = true , runtimes = get_mode_runtimes()} } )
add_requires("ImGuiTextEdit v1.2.0", { debug = is_mode_debug(), configs = {runtimes = get_mode_runtimes()} })
add_requires("IconFontCppHeaders v1.0", { debug = is_mode_debug(), configs = {runtimes = get_mode_runtimes()}})
add_requires("glfw 3.3.9", { debug = is_mode_debug() , configs = {runtimes = get_mode_runtimes()}})
add_requires("opengl", { debug = is_mode_debug(), configs = {runtimes = get_mode_runtimes()} })
add_requires("glaze v2.9.5", { debug = is_mode_debug(), configs = {runtimes = get_mode_runtimes()} })
add_requires("fmt 11.2.0", { debug = is_mode_debug(), configs = {runtimes = get_mode_runtimes()} })

option("ue4ssBetaIsStarted")
    set_default(true)
    set_showmenu(true)
    -- Sets the possible options to only be true or false.
    set_values(true, false)

    set_description("Have beta releases started for the current major version")

option("ue4ssIsBeta")
    set_default(true)
    set_showmenu(true)
    -- Sets the possible options to only be true or false.
    set_values(true, false)

    set_description("Is this a beta release")

option("versionCheck")
    set_default(true)
    set_showmenu(true)
    -- Sets the possible options to only be true or false.
    set_values(true, false)

    set_description("Will xmake check the installed MSVC and Rust versions on configuration step")

local projectName = "UE4SS"

local function parse_version_string(str)
    local matches = {}
    for match in str:gmatch("(%d+)") do
        table.insert(matches, match)
    end

    return {
        ["major"] = matches[1],
        ["minor"] = matches[2],
        ["hotfix"] = matches[3],
        ["prerelease"] = matches[4],
        ["beta"] = matches[5]
    }
end

target(projectName)
    set_kind("shared")
    set_languages("cxx23")
    set_exceptions("cxx")
    set_default(true)
    add_rules("ue4ss.defines.exports")
    add_rules("ue4ss.check.minimum.version")
    add_options("ue4ssBetaIsStarted", "ue4ssIsBeta", "allowAllVersions", "ue4ssInput")
    add_includedirs("include", { public = true })
    add_includedirs("generated_include", { public = true })
    add_headerfiles("include/**.hpp")
    add_headerfiles("generated_include/*.hpp")

    add_files("src/**.cpp")

    add_deps(
        "File", "DynamicOutput", "Unreal",
        "SingleP


})
			.catch((err) => {
				setIsLoading(false);
				setError('Ошибка при загрузке постов. Попробуйте позже.');
			});
	}, []);

	if (isLoading) {
		return <Loader />;
	}

	if (error) {
		return <Alert severity="error">{error}</Alert>; // Показать ошибку, если она есть
	}

	return (

			<Typography variant="h4" className="posts-title" gutterBottom>
				Посты
			</Typography>
			<Grid container spacing={2}>
				{posts?.map(({ id, title, body }) => (
					<Grid key={id} item xs={12} sm={6} md={4} lg={3}>
						<PostCard
							id={id}
							title={title}
							description={body} // Передаем описание поста
							className="card" // Добавляем класс для карточки
						/>
					</Grid>
				))}
			</Grid>

	);
};

export default PostsList;
import React, { useRef } from 'react';
import PostItem from './PostItem';
import { TransitionGroup, CSSTransition } from 'react-transition-group';

const PostList = ({ posts, title, remove }) => {
    const nodeRefs = useRef(new Map());

    if (!posts.length) {
        return
Посты не найдены
;
    }

    return (

{title}

            <TransitionGroup>
                {posts.map((post, index) => {
                    if (!nodeRefs.current.has(post.id)) {
                        nodeRefs.current.set(post.id, React.createRef());
                    }

                    return (
                        <CSSTransition
                            key={post.id}
                            timeout={500}
                            classNames="post"
                            nodeRef={nodeRefs.current.get(post.id)}
                        >

                                <PostItem remove={remove} number={index + 1} post={post} />

                        </CSSTransition>
                    );
                })}
            </TransitionGroup>

    );
};

export default PostList;
import React, {useEffect, useState} from 'react';
import { useParams } from 'react-router-dom';
import { useFetching } from '../hooks/useFetching';
import PostService from "../API/PostService";
import Loader from "../components/UI/Loader/Loader";

const PostIdPage = () => {
    const params = useParams()
    const [post, setPost] = useState({});
    const [comments, setComments] = useState([]);
    const [fetchPostById, isLoading, error] = useFetching(async (id) => {
        const response = await PostService.getById(id)
        setPost(response.data);
    })
    const [fetchComments, isComLoading, comError] = useFetching(async (id) => {
        const response = await PostService.getCommentsByPostId(id)
        setComments(response.data);
    })

    useEffect(() => {
        fetchPostById(params.id)
        fetchComments(params.id)
    }, [])

    return (

Вы открыли страницу поста c ID = {params.id}

            {isLoading
                ? <Loader/>
                :
{post.id}. {post.title}


Players != 1) {
		pSetPiece_2 = (char *)DiabLoad("Levels\\L4Data\\Vile1.DUN", NULL, 'STPC');
		setloadflag_2 = 1;
	}
}

void DRLG_FreeL4SP()
{
	MemFreeDbg(pSetPiece_2);
}

void DRLG_L4SetSPRoom(int rx1, int ry1)
{
	int rw, rh, i, j;
	unsigned char *sp;

	rw = (unsigned char)pSetPiece_2[0];
	rh = (unsigned char)pSetPiece_2[2];

	setpc_x = rx1;
	setpc_y = ry1;
	setpc_w = rw;
	setpc_h = rh;

	sp = (unsigned char *)&pSetPiece_2[4];

	for(j = 0; j < rh; j++) {
		for(i = 0; i < rw; i++) {
			if(*sp != 0) {
				dungeon[i + rx1][j + ry1] = *sp;
				dflags[i + rx1][j + ry1] |= 0x80;
			} else {
				dungeon[i + rx1][j + ry1] = 6;
			}
			sp += 2;
		}
	}
}

static void L4makeDmt()
{
	int i, j, val, dmtx, dmty;

	for(j = 0, dmty = 1; dmty <= 77; j++, dmty += 2) {
		for(i = 0, dmtx = 1; dmtx <= 77; i++, dmtx += 2) {
			val = L4dungeon[dmtx+1][dmty+1];
			val = 2 * val + L4dungeon[dmtx][dmty+1];
			val = 2 * val + L4dungeon[dmtx+1][dmty];
			val = 2 * val + L4dungeon[dmtx][dmty];
			dungeon[i][j] = L4ConvTbl[val];
		}
	}
}

static int L4HWallOk(int i, int j)
{
	int x;
	BOOL wallok;

	for(x = 1; dungeon[i + x][j] == 6; x++) {
		if(dflags[i + x][j] != 0) {
			break;
		}
		if(dungeon[i + x][j - 1] != 6) {
			break;
		}
		if(dungeon[i + x][j + 1] != 6) {
			break;
		}
	}

	wallok = FALSE;

	if(dungeon[i + x][j] == 10) {
		wallok = TRUE;
	}
	if(dungeon[i + x][j] == 12) {
		wallok = TRUE;
	}
	if(dungeon[i + x][j] == 13) {
		wallok = TRUE;
	}
	if(dungeon[i + x][j] == 15) {
		wallok = TRUE;
	}
	if(dungeon[i + x][j] == 16) {
		wallok = TRUE;
	}
	if(dungeon[i + x][j] == 21) {
		wallok = TRUE;
	}
	if(dungeon[i + x][j] == 22) {
		wallok = TRUE;
	}
	if(x <= 3) {
		wallok = FALSE;
	}

	if(wallok) {
		return x;
	} else {
		return -1;
	}
}

static int L4VWallOk(int i, int j)
{
	int y;
	BOOL wallok;

	for(y = 1; dungeon[i][j + y] ==


880000; } /* Constant */
code span.co { color: #60a0b0; font-style: italic; } /* Comment */
code span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } /* CommentVar */
code span.do { color: #ba2121; font-style: italic; } /* Documentation */
code span.dt { color: #902000; } /* DataType */
code span.dv { color: #40a070; } /* DecVal */
code span.er { color: #ff0000; font-weight: bold; } /* Error */
code span.ex { } /* Extension */
code span.fl { color: #40a070; } /* Float */
code span.fu { color: #06287e; } /* Function */
code span.im { } /* Import */
code span.in { color: #60a0b0; font-weight: bold; font-style: italic; } /* Information */
code span.kw { color: #007020; font-weight: bold; } /* Keyword */
code span.op { color: #666666; } /* Operator */
code span.ot { color: #007020; } /* Other */
code span.pp { color: #bc7a00; } /* Preprocessor */
code span.sc { color: #4070a0; } /* SpecialChar */
code span.ss { color: #bb6688; } /* SpecialString */
code span.st { color: #4070a0; } /* String */
code span.va { color: #19177c; } /* Variable */
code span.vs { color: #4070a0; } /* VerbatimString */
code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } /* Warning */
</style>

<link rel="stylesheet" href="css/book.css" type="text/css" />
<link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.14.0/css/all.css" type="text/css" />

Mixed Models with R

Introduction

Overview

Goals

Prerequisites

Data and Exercises

Key packages

Mixed Models

<li class="chapter" data-level="" data-path="random_inter


 numeric;
  symbols: "\F20" "\F21" "\F22" "\F23" "\F24" "\F25" "\F26" "\F27" "\F28" "\F29";
}

@counter-style lower-alpha {
  system: alphabetic;
  symbols: a b c d e f g h i j k l m n o p q r s t u v w x y z;
}

@counter-style lower-latin {
  system: extends lower-alpha;
}

@counter-style upper-alpha {
  system: alphabetic;
  symbols: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z;
}

@counter-style upper-latin {
  system: extends upper-alpha;
}

@counter-style cjk-earthly-branch {
  system: alphabetic;
  symbols: "\5B50" "\4E11" "\5BC5" "\536F" "\8FB0" "\5DF3" "\5348" "\672A" "\7533" "\9149" "\620C" "\4EA5";
  suffix: "、";
}

@counter-style cjk-heavenly-stem {
  system: alphabetic;
  symbols: "\7532" "\4E59" "\4E19" "\4E01" "\620A" "\5DF1" "\5E9A" "\8F9B" "\58EC" "\7678";
  suffix: "、";
}

@counter-style lower-greek {
  system: alphabetic;
  symbols: "\3B1" "\3B2" "\3B3" "\3B4" "\3B5" "\3B6" "\3B7" "\3B8" "\3B9" "\3BA" "\3BB" "\3BC" "\3BD" "\3BE" "\3BF" "\3C0" "\3C1" "\3C3" "\3C4" "\3C5" "\3C6" "\3C7" "\3C8" "\3C9";
}

@counter-style hiragana {
  system: alphabetic;
  symbols: "\3042" "\3044" "\3046" "\3048" "\304A" "\304B" "\304D" "\304F" "\3051" "\3053" "\3055" "\3057" "\3059" "\305B" "\305D" "\305F" "\3061" "\3064" "\3066" "\3068" "\306A" "\306B" "\306C" "\306D" "\306E" "\306F" "\3072" "\3075" "\3078" "\307B" "\307E" "\307F" "\3080" "\3081" "\3082" "\3084" "\3086" "\3088" "\3089" "\308A" "\308B" "\308C" "\308D" "\308F" "\3090" "\3091" "\3092" "\3093";
  suffix: "、";
}

@counter-style hiragana-iroha {
  system: alphabetic;
  symbols: "\3044" "\308D" "\306F" "\306B" "\307B" "\3078" "\3068" "\3061" "\308A" "\306C" "\308B" "\3092" "\308F" "\304B" "\3088" "\305F" "\308C" "\305D" "\3064" "\306D" "\306A" "\3089" "\3080" "\3046" "\3090" "\306E" "\304A" "\304F" "\3084" "\307E" "\3051" "\3075" "\3053" "\3048" "\3066" "\3042" "\3055" "\304D" "\3086" "\3081" "\307F" "\3057" "\3091" "\3072" "\3082" "\305B" "\3059";
  suffix: "、";
}

@counter-style katakana {
  system: alphabetic;
  s


lo.geometry =
        {x = posX - (bigbtndist * 3), y = bigbtnrowY, an = 5, w = 25, h = 25}
    lo.style = osc_styles.bb_bigButton3

    if (osc_param.display_aspect < 1) then lo.geometry.x = 150 end

    lo = add_layout("pl_next")
    lo.geometry =
        {x = posX + (bigbtndist * 3), y = bigbtnrowY, an = 5, w = 25, h = 25}
    lo.style = osc_styles.bb_bigButton3

    if (osc_param.display_aspect < 1) then lo.geometry.x = osc_geo.w - 150 end

    -- 快捷按钮

    lo = add_layout("cy_audio")
    lo.geometry =
        {x = posX - pos_offsetX + 40, y = bigbtnrowY, an = 5, w = 70, h = 25}
    lo.style = osc_styles.bb_Atracks

    if (osc_param.display_aspect < 1) then lo.geometry.x = 40 end

    lo = add_layout("cy_sub")
    lo.geometry =
        {x = posX - pos_offsetX + (50 * 2) + osc_geo.p, y = bigbtnrowY, an = 5, w = 70, h = 25}
    lo.style = osc_styles.bb_Stracks

    lo = add_layout("tog_fs")
    lo.geometry =
        {x = posX + pos_offsetX - 25, y = bigbtnrowY, an = 5, w = 25, h = 25}
    lo.style = osc_styles.bb_fs

    lo = add_layout("volume")
    lo.geometry =
        {x = posX + pos_offsetX - (30 * 2) - osc_geo.p, y = bigbtnrowY, an = 4, w = 25, h = 25}
    lo.style = osc_styles.bb_volume

    if (osc_param.display_aspect < 1) then lo.geometry.x = osc_geo.w - 40 end

    -- 联动内置的stats.lua

    lo = add_layout("lua_stats")
    lo.geometry =
        {x = posX + pos_offsetX - (45 * 2) - osc_geo.p, y = bigbtnrowY + 2, an = 5, w = 25, h = 25}
    lo.style = osc_styles.bb_lua_stats

    if (osc_param.display_aspect < 1) then lo.geometry.x = osc_geo.w - 60 end

    --
    -- 进度条
    --

    lo = add_layout("seekbar")
    lo.geometry =
        {x = posX, y = posY + pos_offsetY - 22, an = 2, w = pos_offsetX * 2, h = 20}
    lo.style = osc_styles.bb_seekbar
    lo.slider.gap = 2
    lo.slider.tooltip_style = osc_styles.bb_seektime
    lo.slider.tooltip_an = 5
    lo.slider.stype = user_opts["seekbarstyle"]
    lo.slider.rtype = user_opts["seekrangestyle"]

    --
    -- 时间码和缓存
    --

    local bottomrowY = posY + pos_offsetY - 5

    lo = add_layout("tc_left")
    lo.geometry =
        {x = posX - pos_offsetX, y = bottomrowY, an = 4, w = 80, h = 18}
    lo.style = osc_styles.bb_timecodes

    lo = add_layout("tc_right")
    lo.geometry =
        {x = posX + pos_offsetX, y = bottomrowY, an = 6, w = 80, h = 18}
    lo.style = osc_styles.bb_timecodes

    lo = add_layout("cache")
    lo.geometry =
        {x = posX - pos_offsetX, y = bottomrowY - pos_offsetY + 18, an = 4, w = 110, h


"<<C:1>>", 0)
SAS(SI_GAMEPAD_VOICECHAT_GUILD_CHANNEL_NAME, "<<C:1>> - <<2>>", 0)
SAS(SI_GAMEPAD_VOICECHAT_HISTORY_TIP_CHANNEL, "Canal", 0)
SAS(SI_GAMEPAD_VOICECHAT_HISTORY_TIP_LAST_HEARD, "Escuchado por última vez", 0)
SAS(SI_GAMEPAD_VOICECHAT_HISTORY_TITLE, "Historial de hablantes", 0)
SAS(SI_GAMEPAD_VOICECHAT_KEYBIND_DISABLE_MIC, "Silenciar micrófono", 1)
SAS(SI_GAMEPAD_VOICECHAT_KEYBIND_ENABLE_MIC, "Activar micrófono", 0)
SAS(SI_GAMEPAD_VOICECHAT_KEYBIND_HIDE_FROM_HUD_CHAT, "Ocultar de la interfaz de chat", 0)
SAS(SI_GAMEPAD_VOICECHAT_KEYBIND_JOIN_CHANNEL, "Unirse al canal", 0)
SAS(SI_GAMEPAD_VOICECHAT_KEYBIND_LEAVE_CHANNEL, "Abandonar canal", 0)
SAS(SI_GAMEPAD_VOICECHAT_KEYBIND_PARTICIPANT_OPTIONS, "Lista de participantes", 0)
SAS(SI_GAMEPAD_VOICECHAT_KEYBIND_SEND_TO_HUD_CHAT, "Enviar a la interfaz de chat", 0)
SAS(SI_GAMEPAD_VOICECHAT_KEYBIND_VIEW_PARTICIPANTS, "Ver participantes", 0)
SAS(SI_GAMEPAD_VOICECHAT_KEYBIND_VIEW_TRANSCRIPT, "Ver transcripción", 0)
SAS(SI_GAMEPAD_VOICECHAT_PARTICIPANTS_GUILD_HEADER, "<<C:1>> - <<2>>", 1)
SAS(SI_GAMEPAD_VOICECHAT_PARTICIPANTS_HEADER, "Participantes", 1)
SAS(SI_GAMEPAD_VOICECHAT_PARTICIPANTS_REPUTATION_RESTRICTION_PS4, "La reputación que tienes en la PlayStation™Network te impide hablar en este canal. Mejórala para acabar con esta restricción.", 2)
SAS(SI_GAMEPAD_VOICECHAT_PARTICIPANTS_REPUTATION_RESTRICTION_XB1, "La reputación que tienes en la red Xbox te impide hablar en este canal. Mejórala para acabar con esta restricción.", 1)
SAS(SI_GAMEPAD_VOICECHAT_PARTICIPANT_OPTIONS_TITLE, "Participantes", 0)
SAS(SI_GAMEPAD_VOICECHAT_ROOM_NAME, "Todos los miembros de <<1>>", 0)
SAS(SI_GAMEPAD_VOICECHAT_ROOM_NAME_OFFICERS, "Oficiales", 0)
SAS(SI_GAMEPAD_VOICECHAT_TRANSCRIPT_HEADER, "Transcripción del chat de voz", 0)
SAS(SI_GAMEPAD_VOICECHAT_UNAVAILABLE, "El chat de voz no está disponible. Esto podría deberse a un mantenimiento del servidor o un problema de configuración. Visita |cffffff<<1>>|r para obtener más ayuda.", 0)
SAS(SI_GAMEPAD_WORLD_MAP_CHOOSE_ACTIVE_QUEST, "Elegir misión activa", 0)


ions
│   ├── ide-core/              # IDE core services
│   ├── build-service/         # Build pipeline
│   ├── flash-service/         # Flash service
│   └── logging-service/       # Logging service
├── 📱 apps/                   # Applications
│   ├── desktop/               # Desktop app (main)
│   │   ├── src-tauri/         # Tauri backend
│   │   └── ui/                # React frontend
│   └── web/                   # Web version (planned)
├── 🔌 plugins/                # Example plugins
│   ├── boards/                # Board plugins
│   ├── drivers/               # Driver plugins
│   └── tools/                 # Tool plugins
├── 📚 templates/              # Project templates
├── 🧪 tests/                  # Test code
├── 📖 docs/                   # Documentation
└── 🔧 scripts/                # Build scripts
```

### Core Architecture

#### Rust Backend Architecture

```
┌─────────────────┐
│   Tauri App     │ ← Application entry point
├─────────────────┤
│   IDE Core      │ ← Core service coordination
├─────────────────┤
│  Plugin System  │ ← Plugin loading and management
├─────────────────┤
│   Services      │ ← Specialized services
│  Build|Flash|Log│
├─────────────────┤
│   Plugin API    │ ← Plugin interface definitions
└─────────────────┘
```

#### Frontend Architecture

```
┌─────────────────┐
│   React App     │ ← Main application
├─────────────────┤
│   Context API   │ ← State management
├─────────────────┤
│   Components    │ ← UI components
│  Editor|Sidebar │
├─────────────────┤
│  Tauri Bridge   │ ← Backend communication
└─────────────────┘
```

## 🔄 Development Workflow

### 1. Feature Development Workflow

1. **Create Branch**
   ```bash
   git checkout -b feature/your-feature-name
   ```

2. **Develop Feature**
   - Write code
   - Add tests
   - Update documentation

3. **Test & Verify**
   ```bash
   # Run tests
   cargo test --workspace

   # Check code formatting
   cargo fmt --check

   # Run Clippy checks
   cargo clippy --workspace -- -D warnings

   # Frontend tests
   cd apps/desktop/ui
   npm test
   ```

4. **Commit Code**
   ```bash
   git add .
   git commit -m "feat: add your feature description"
   git push origin feature/your-feature-name
   ```

5. **Create PR**
   - Create Pull Request on GitHub
   - Describe changes
   - Wait for code review

### 2. Bug Fix Workflow

1. **Create Branch**
   ```bash
   git checkout -b fix/issue-number-description
   ```

2. **Fix Bug**
   - Reproduce issue
   - Write test cases
   - Fix problem
   - Verify fix

3. **Test & Submit** (same as feature development)

## 📝 Code Standards

### Rust Code Standards

1. **Formatting**
   ```bash
   cargo fmt
   ```

2. **Clippy Checks**
   ```bash
   cargo clippy -- -D warnings
   ```

3. **Naming Conventions**
   ```rust
   // Structs and enums use PascalCase
   struct PluginManager;
   enum BuildStatus;

   // Functions and variables use snake_case
   fn load_plugin() -> Result<()>;
   let plugin_count = 0;

   // Constants use SCREAMING_SNAKE_CASE
   const MAX_PLUGINS: usize = 100;
   ```

4. **Error Handling**
   ```rust
   // Pref


her in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/

#ifndef OPENCV_ALL_HPP
#define OPENCV_ALL_HPP

// File that defines what modules where included during the build of OpenCV
// These are purely the defines of the correct HAVE_OPENCV_modulename values
#include "opencv2/opencv_modules.hpp"

// Then the list of defines is checked to include the correct headers
// Core library is always included --> without no OpenCV functionality available
#include "opencv2/core.hpp"

// Then the optional modules are checked
#ifdef HAVE_OPENCV_CALIB3D
#include "opencv2/calib3d.hpp"
#endif
#ifdef HAVE_OPENCV_FEATURES2D
#include "opencv2/features2d.hpp"
#endif
#ifdef HAVE_OPENCV_DNN
#include "opencv2/dnn.hpp"
#endif
#ifdef HAVE_OPENCV_FLANN
#include "opencv2/flann.hpp"
#endif
#ifdef HAVE_OPENCV_HIGHGUI
#include "opencv2/highgui.hpp"
#endif
#ifdef HAVE_OPENCV_IMGCODECS
#include "opencv2/imgcodecs.hpp"
#endif
#ifdef HAVE_OPENCV_IMGPROC
#include "opencv2/imgproc.hpp"
#endif
#ifdef HAVE_OPENCV_ML
#include "opencv2/ml.hpp"
#endif
#ifdef HAVE_OPENCV_OBJDETECT
#include "opencv2/objdetect.hpp"
#endif
#ifdef HAVE_OPENCV_PHOTO
#include "opencv2/photo.hpp"
#endif
#ifdef HAVE_OPENCV_SHAPE
#include "opencv2/shape.hpp"
#endif
#ifdef HAVE_OPENCV_STITCHING
#include "opencv2/stitching.hpp"
#endif
#ifdef HAVE_OPENCV_SUPERRES
#include "opencv2/superres.hpp"
#endif
#ifdef HAVE_OPENCV_VIDEO
#include "opencv2/video.hpp"
#endif
#ifdef HAVE_OPENCV_VIDEOIO
#include "opencv2/videoio.hpp"
#endif
#ifdef HAVE_OPENCV_VIDEOSTAB
#include "opencv2/videostab.hpp"
#endif
#ifdef HAVE_OPENCV_VIZ
#include "opencv2/viz.hpp"
#endif

// Finally CUDA specific entries are checked and added
#ifdef HAVE_OPENCV_CUDAARITHM
#include "opencv2/cudaarithm.hpp"
#endif
#ifdef HAVE_OPENCV_CUDABGSEGM
#include "opencv2/cudabgsegm.hpp"
#endif
#ifdef HAVE_OPENCV_CUDACODEC
#include "opencv2/cudacodec.hpp"
#endif
#ifdef HAVE_OPENCV_CUDAFEATURES2D
#include "opencv2/cudafeatures2d.hpp"
#endif
#ifdef HAVE_OPENCV_CUDAFILTERS
#include "opencv2/cudafilters.hpp"
#endif
#ifdef HAVE_OPENCV_CUDAIMGPROC
#include "opencv2/cudaimgproc.hpp"
#endif
#ifdef HAVE_OPENCV_CUDAOBJDETECT
#include "opencv2/cudaobjdetect.hpp"
#endif
#ifdef HAVE_OPENCV_CUDAOPTFLOW
#include "opencv2/cudaoptflow.hpp"
#endif
#ifdef HAVE_OPENCV_CUDASTEREO
#include "opencv2/cudastereo.hpp"
#endif
#ifdef HAVE_OPENCV_CUDAWARPING
#include "opencv2/cudawarping.hpp"
#endif

#endif
/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                          License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
// Copyright (C) 2013,


 difference, we can't know the actual sum
	sumDiff := *got[0].Metric[0].Histogram.SampleSum - *want[0].Metric[0].Histogram.SampleSum
	if sumDiff > 0.01 { // we leave room for 10 milliseconds
		t.Errorf("sample sum diff was greater than expected: %v", sumDiff)
	}

	// add difference to our estimate and make sure everything else matches
	*want[0].Metric[0].Histogram.SampleSum += sumDiff

	opts := []cmp.Option{
		cmpopts.IgnoreUnexported(dto.MetricFamily{}, dto.Metric{}, dto.Histogram{}, dto.Bucket{}),
		cmpopts.IgnoreFields(dto.Histogram{}, "CreatedTimestamp"),
	}
	diff := cmp.Diff(want, got, opts...)
	if diff != "" {
		t.Errorf("Expected and actual metrics are different:\n%s", diff)
	}
}

func TestLabeledTimer(t *testing.T) {
	is := is.New(t)

	testCases := []struct {
		name        string
		observe     func(m metrics.LabeledTimer)
		wantCounts  map[string]uint64
		wantSums    map[string]float64
		wantBuckets map[string]map[float64]uint64
	}{{
		name:    "no observed timers",
		observe: func(m metrics.LabeledTimer) {},
	}, {
		name:       "only labels observed",
		observe:    func(m metrics.LabeledTimer) { m.WithValues("val1") },
		wantCounts: map[string]uint64{"val1": 0},
		wantSums:   map[string]float64{"val1": 0},
	}, {
		name: "one observed",
		observe: func(m metrics.LabeledTimer) {
			m1 := m.WithValues("val1")
			m1.Update(time.Millisecond * 2500)
		},
		wantCounts:  map[string]uint64{"val1": 1},
		wantSums:    map[string]float64{"val1": 2.5},
		wantBuckets: map[string]map[float64]uint64{"val1": {2.5: 1, 5: 1, 10: 1}},
	}, {
		name: "10 observed",
		observe: func(m metrics.LabeledTimer) {
			for i := 1; i <= 10; i++ {
				m1 := m.WithValues(fmt.Sprintf("val%d", i))
				m1.Update(time.Millisecond * 250 * time.Duration(i))
			}
		},
		wantCounts: map[string]uint64{
			"val1": 1, "val2": 1, "val3": 1, "val4": 1, "val5": 1, "val6": 1, "val7": 1, "val8": 1, "val9": 1, "val10": 1,
		},
		wantSums: map[string]float64{
			"val1": 0.25, "val2": 0.5, "val3": 0.75, "val4": 1, "val5": 1.25, "val6": 1.5, "val7": 1.75, "val8": 2, "val9": 2.25, "val10": 2.5,
		},
		wantBuckets: map[string]map[float64]uint64{
			"val1":  {0.25: 1, 0.5: 1, 1: 1, 2.5: 1, 5: 1, 10: 1},
			"val2":  {0.5: 1, 1: 1, 2.5: 1, 5: 1, 10: 1},
			"val3":  {1: 1, 2.5: 1, 5: 1, 10: 1},
			"val4":  {1: 1, 2.5: 1, 5: 1, 10: 1},
			"val5":  {2.5: 1, 5: 1, 10: 1},
			"val6":  {2.5: 1, 5: 1, 10: 1},
			"val7":  {2.5: 1, 5: 1, 10: 1},
			"val8":  {2.5: 1, 5: 1, 10: 1},
			"val9":  {2.5: 1, 5: 1, 10: 1},
			"val10": {2.5: 1, 5: 1, 10: 1},
		},
	}}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			re


y-side-nav-search>div.switch-menus>div.version-switch {
    display: inline-block;
    padding: .2em
}

.wy-side-nav-search>div.switch-menus>div.language-switch select,
.wy-side-nav-search>div.switch-menus>div.version-switch select {
    display: inline-block;
    margin-right: -2rem;
    padding-right: 2rem;
    max-width: 240px;
    text-align-last: center;
    background: none;
    border: none;
    border-radius: 0;
    box-shadow: none;
    font-family: Lato, proxima-nova, Helvetica Neue, Arial, sans-serif;
    font-size: 1em;
    font-weight: 400;
    color: hsla(0, 0%, 100%, .3);
    cursor: pointer;
    appearance: none;
    -webkit-appearance: none;
    -moz-appearance: none
}

.wy-side-nav-search>div.switch-menus>div.language-switch select:active,
.wy-side-nav-search>div.switch-menus>div.language-switch select:focus,
.wy-side-nav-search>div.switch-menus>div.language-switch select:hover,
.wy-side-nav-search>div.switch-menus>div.version-switch select:active,
.wy-side-nav-search>div.switch-menus>div.version-switch select:focus,
.wy-side-nav-search>div.switch-menus>div.version-switch select:hover {
    background: hsla(0, 0%, 100%, .1);
    color: hsla(0, 0%, 100%, .5)
}

.wy-side-nav-search>div.switch-menus>div.language-switch select option,
.wy-side-nav-search>div.switch-menus>div.version-switch select option {
    color: #000
}

.wy-side-nav-search>div.switch-menus>div.language-switch:has(>select):after,
.wy-side-nav-search>div.switch-menus>div.version-switch:has(>select):after {
    display: inline-block;
    width: 1.5em;
    height: 100%;
    padding: .1em;
    content: "\f0d7";
    font-size: 1em;
    line-height: 1.2em;
    font-family: FontAwesome;
    text-align: center;
    pointer-events: none;
    box-sizing: border-box
}

.wy-nav .wy-menu-vertical header {
    color: #2980b9
}

.wy-nav .wy-menu-vertical a {
    color: #b3b3b3
}

.wy-nav .wy-menu-vertical a:hover {
    background-color: #2980b9;
    color: #fff
}

[data-menu-wrap] {
    -webkit-transition: all .2s ease-in;
    -moz-transition: all .2s ease-in;
    transition: all .2s ease-in;
    position: absolute;
    opacity: 1;
    width: 100%;
    opacity: 0
}

[data-menu-wrap].move-center {
    left: 0;
    right: auto;
    opacity: 1
}

[data-menu-wrap].move-left {
    right: auto;
    left: -100%;
    opacity: 0
}

[data-menu-wrap].move-right {
    right: -100%;
    left: auto;
    opacity: 0
}

.wy-body-for-nav {
    /* background: #fcfcfc */
}

.wy-grid-for-nav {
    /* position:absolute; */
    position


FancyAnimation = disableFancyAnimation == null;

  @override
  void ngAfterViewInit() {
    _isInitialized = true;
    if (indeterminate) _tryFancyAnimation();
  }

  @override
  void ngOnDestroy() {
    _primaryAnimation?.cancel();
    _secondaryAnimation?.cancel();
    _primaryAnimation = null;
    _secondaryAnimation = null;
    _primaryIndicator = null;
    _secondaryIndicator = null;
  }

  /// Sets up 'fancy' animation using the animation API.
  void _tryFancyAnimation() {
    if (!indeterminate ||
        !_useFancyAnimation ||
        !_isInitialized ||
        !supportsAnimationApi) return;

    final width = _element.getBoundingClientRect().width;
    if (width == 0) {
      // Fall back to the non-optimized animation if the host element does not
      // yet have a width. The non-optimized animation will automatically adjust
      // when the host element width changes.

      // To avoid 'expression has changed after it was checked'.
      scheduleMicrotask(() {
        _useFancyAnimation = false;
        _changeDetector.markForCheck();
      });
      return;
    }

    final primaryKeyframes = [
      const {'transform': 'translateX(0px) scaleX(0)'},
      const {'transform': 'translateX(0px) scaleX(0.5)', 'offset': 0.25},
      {
        'transform': 'translateX(${0.25 * width}px) scaleX(0.75)',
        'offset': 0.5
      },
      {'transform': 'translateX(${width}px) scaleX(0)', 'offset': 0.75},
      {'transform': 'translateX(${width}px) scaleX(0)'},
    ];
    final secondaryKeyframes = [
      const {'transform': 'translateX(0px) scaleX(0)'},
      const {'transform': 'translateX(0px) scaleX(0)', 'offset': 0.6},
      const {'transform': 'translateX(0px) scaleX(0.6)', 'offset': 0.8},
      {'transform': 'translateX(${width}px) scaleX(0.1)'},
    ];
    _primaryAnimation =
        _primaryIndicator.animate(primaryKeyframes, _indeterminateTiming);
    _secondaryAnimation =
        _secondaryIndicator.animate(secondaryKeyframes, _indeterminateTiming);
  }
}
// Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'dart:async';
import 'dart:html';

import 'package:angular/angular.dart';
import 'package:intl/intl.dart';
import 'package:angular_components/focus/focus.dart';
import 'package:angular_components/interfaces/has_disabled.dart';
import 'package:angular_components/material_button/material_button.dart';
import 'package:angular_components/material_spinner/material_spinner.dart';

/// A component for the two buttons horizontally next to each other, like
/// yes/no, save/cancel, agree/not agree, etc.
///
/// Text on the buttons can be changed, they can also be raised.
/// The 'yes' button can be optionally highlighted.
///
/// Basic text customization can be provided with directives like
/// [MaterialSaveCancelButtonsDirective] that replaces yes/no with save/cancel.
///
/// To display buttons in reversed order add a `reverse` attribute.
@Component(
  selector: 'material-yes-no-buttons',
  directives: [
    AutoFocusDirective,
    MaterialButtonComponent,
    MaterialSpinnerComponent,
    NgClass,
    NgIf,
  ],
  providers: [ExistingProvider(HasDisabled, MaterialYesNoButtonsComponent)],
  templateUrl: 'material_yes_no_buttons.html',
  styleUrls: ['material_yes_


LE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

using System;
using System.Collections.Generic;
using EventFlow.Aggregates;
using EventFlow.Core;
using EventFlow.EventStores;

namespace EventFlow.MetadataProviders
{
    /// <summary>
    /// Adds key <c>guid</c> with a new <c>Guid</c> for every event (used for testing)
    /// </summary>
    public class AddGuidMetadataProvider : IMetadataProvider
    {
        public IEnumerable<KeyValuePair<string, string>> ProvideMetadata<TAggregate, TIdentity>(
            TIdentity id,
            IAggregateEvent aggregateEvent,
            IMetadata metadata)
            where TAggregate : IAggregateRoot<TIdentity>
            where TIdentity : IIdentity
        {
            yield return new KeyValuePair<string, string>("guid", Guid.NewGuid().ToString());
        }
    }
}


VList: wire.TLVList{
						wire.NewTLVBE(wire.LocateTLVTagsInfoSigData, "profile-result"),
					},
				},
			},
			mockParams: mockParams{
				profileManagerParams: profileManagerParams{
					setProfileParams: setProfileParams{
						{
							screenName: state.NewIdentScreenName("test-user"),
							body:       "profile-result",
						},
					},
				},
			},
		},
		{
			name:        "set away message during sign on flow",
			userSession: newTestSession("user_screen_name"),
			inBody: wire.SNAC_0x02_0x04_LocateSetInfo{
				TLVRestBlock: wire.TLVRestBlock{
					TLVList: wire.TLVList{
						wire.NewTLVBE(wire.LocateTLVTagsInfoUnavailableData, "this is my away message!"),
					},
				},
			},
			mockParams: mockParams{
				buddyBroadcasterParams: buddyBroadcasterParams{
					broadcastBuddyArrivedParams: broadcastBuddyArrivedParams{},
				},
			},
		},
		{
			name:        "set away message after sign on flow",
			userSession: newTestSession("user_screen_name", sessOptSignonComplete),
			inBody: wire.SNAC_0x02_0x04_LocateSetInfo{
				TLVRestBlock: wire.TLVRestBlock{
					TLVList: wire.TLVList{
						wire.NewTLVBE(wire.LocateTLVTagsInfoUnavailableData, "this is my away message!"),
					},
				},
			},
			mockParams: mockParams{
				buddyBroadcasterParams: buddyBroadcasterParams{
					broadcastBuddyArrivedParams: broadcastBuddyArrivedParams{
						{
							screenName: state.DisplayScreenName("user_screen_name"),
						},
					},
				},
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			profileManager := newMockProfileManager(t)
			for _, params := range tt.mockParams.setProfileParams {
				profileManager.EXPECT().
					SetProfile(matchContext(), params.screenName, params.body).
					Return(nil)
			}
			buddyUpdateBroadcaster := newMockbuddyBroadcaster(t)
			for _, params := range tt.mockParams.broadcastBuddyArrivedParams {
				buddyUpdateBroadcaster.EXPECT().
					BroadcastBuddyArrived(mock.Anything, state.NewIdentScreenName(params.screenName.String()), mock.MatchedBy(func(userInfo wire.TLVUserInfo) bool {
						return userInfo.ScreenName == params.screenName.String()
					})).
					Return(params.err)
			}
			svc := NewLocateService(nil, nil, profileManager, nil, nil)
			svc.buddyBroadcaster = buddyUpdateBroadcaster
			assert.Equal(t, tt.wantErr, svc.SetInfo(context.Background(), tt.userSession, tt.inBody))
		})
	}
}

func TestLocateService_SetInfo_SetCaps(t *testing.T) {
	svc := NewLocateService(nil, nil, nil, nil, nil)

	sess := newTestSession("screen-name")
	inBody := wire.SNAC_0x02_0x04_LocateSetInfo{
		TLVRestBlock: wire.TLVRestBlock{
			TLVList: wire.TLVList{
				wire.NewTLVBE(wire.LocateTLVTagsInfoCapabilities, []byte{
					// chat: "748F2420-6287-11D1-8222-444553540000"
					0x74, 0x8f, 0x24, 0x20, 0x62, 0x87, 0x11, 0xd1, 0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00,


	public void EndGame()
	{
		if ( !Playing ) return;

		Playing = false;
		Sandbox.Services.Stats.SetValue( "highscore", Score );
		Sandbox.Services.Stats.Increment( "games_played", 1 );
	}

	public void AddBall( GameObject ball )
	{
		Balls.Add( ball );
	}

	public void RemoveBall( GameObject ball )
	{
		Balls.Remove( ball );
	}

	public void AddScore( int size )
	{
		if ( size > Evolution ) Evolution = size;
		var score = 0;
		for ( int i = 0; i < size; i++ )
		{
			score += i + 1;
		}
		Score += score;
		if ( Score > HighScore ) HighScore = Score;
	}

	async void FetchLeaderboardInfo()
	{
		Leaderboard = Sandbox.Services.Leaderboards.Get( LeaderboardName );
		Leaderboard.MaxEntries = 10;
		await Leaderboard.Refresh();
		foreach ( var entry in Leaderboard.Entries )
		{
			if ( entry.SteamId == Game.SteamId )
			{
				HighScore = (long)entry.Value;
			}
		}
	}

}


&client.TaskResourceApiBatchPollOpts{
		Domain:   domainOptional,
		Workerid: optional.NewString(hostname),
		Count:    optional.NewInt32(int32(count)),
	}

	if timeout >= 0 {
		opts.Timeout = optional.NewInt32(int32(timeout.Milliseconds()))
	}

	tasks, response, err := c.conductorTaskResourceClient.BatchPoll(
		c.getBaseContext(),
		taskName,
		opts,
	)
	spentTime := time.Since(startTime)
	metrics.RecordTaskPollTime(
		taskName,
		spentTime.Seconds(),
	)
	if err != nil {
		metrics.IncrementTaskPollError(
			taskName, err,
		)
		return nil, err
	}
	if response.StatusCode == 204 {
		return nil, nil
	}
	log.Debug("Polled tasks", "count", len(tasks), "taskName", taskName)
	return tasks, nil
}

func (c *TaskRunner) executeTask(t *model.Task, executeFunction model.ExecuteTaskFunction) *model.TaskResult {
	log.Debug(
		"Executing task of type",
		"taskDefName", t.TaskDefName,
		"taskId", t.TaskId,
		"workflowId", t.WorkflowInstanceId,
	)
	startTime := time.Now()
	taskExecutionOutput, err := executeFunction(t)
	spentTime := time.Since(startTime)
	metrics.RecordTaskExecuteTime(
		t.TaskDefName, float64(spentTime.Milliseconds()),
	)
	if err != nil {
		metrics.IncrementTaskExecuteError(t.TaskDefName, err)
		log.Debug(
			"failed to execute task",
			"reason", err,
			"taskName", t.TaskDefName,
			"taskId", t.TaskId,
			"workflowId", t.WorkflowInstanceId,
		)
		if taskExecutionOutput == nil {
			return model.NewTaskResultFromTaskWithError(t, err)
		}
	}
	taskResult, err := model.GetTaskResultFromTaskExecutionOutput(t, taskExecutionOutput)
	if err != nil {
		log.Debug(
			"Failed to extract taskResult from generated object",
			"reason", err,
			"task type", t.TaskDefName,
			"taskId", t.TaskId,
			"workflowId", t.WorkflowInstanceId,
			"response", err,
		)
		return model.NewTaskResultFromTaskWithError(t, err)
	}
	log.Debug(
		"Executed task of type",
		"taskDefName", t.TaskDefName,
		"taskId", t.TaskId,
		"workflowId", t.WorkflowInstanceId,
	)
	return taskResult
}

func (c *TaskRunner) updateTaskWithRetry(taskName string, taskResult *model.TaskResult) error {
	log.Debug(
		"Updating task of type",
		"taskDefName", taskName,
		"taskId", taskResult.TaskId,
		"workflowId", taskResult.WorkflowInstanceId,
	)
	var lastError error
	for attempt := 0; attempt <= taskUpdateRetryAttemptsLimit; attempt += 1 {
		if attempt > 0 {
			// Wait for [10s, 20s, 30s] before next attempt
			amount := attempt * 10
			time.Sleep(time.Duration(amount) * time.Second)
		}
		_, err := c.updateTask(taskName, taskResult)
		if err == nil {
			log.Debug(
				"Updated task of type",
				"taskDefName", taskName,
				"taskId", taskResult.TaskId,
				"workflowId", taskResult.WorkflowInstanceId,
			)
			return nil
		}
		metrics.IncrementTaskUpdateError(taskName, err)
		lastError = err
	}
	return fmt.Errorf("failed to update task %s after %d attempts. %s", taskName, taskUpdateRetryAttemptsLimit, lastError)
}

func (c *


import arcClass, network, parameterfreeNetwork, theAlgorithm, label, CSVreader
import pprint

distanceMatrix = 'DistanceMatrix.csv'
timeMatrix = 'TimeMatrix.csv'

testingInstanceFilename = 'smallerInstanceTest.txt'

distanceData = CSVreader.CSVreader(distanceMatrix)
timeData = CSVreader.CSVreader(timeMatrix)

# Populate arcs with city data
citiesArcs = arcClass.cityArcs.createArcs(distanceData, timeData)

testNetwork = network.Network(testingInstanceFilename, citiesArcs)
testNetwork.parse()
# Print network nodes
nodes = testNetwork.getNodes()
#pprint.pprint(nodes)

paraNetwork = parameterfreeNetwork.parameterfreeNetwork(testNetwork)
interNodes = paraNetwork._getIntermediateNodes()
# Print intermediate nodes
#pprint.pprint(interNodes)
# Print all edges in parameterfree network
#pprint.pprint(paraNetwork._getEdges())

# Run the algortihm
algo = theAlgorithm.algorithm(paraNetwork)

#Finding the label with the lowest timecc
bestLabel = label.Label(paraNetwork._getDepot(), len(paraNetwork.originalNetwork.nodes))
bestLabel.time = float('inf')   #Setting the cost to infinity to compare the cost with the created labels

for l in algo:
	if (l.path[len(l.path)-1] == 3 and l.time < bestLabel.time):
		bestLabel = label

print(f"BEST LABEL: {bestLabel}")

# Network and parameterfree network verification check
"""

for edge in list(paraNetwork.edges.keys())[:20]:  # Checking first 5 edges for example
	from_node, _, to_node = edge if len(edge) == 3 else (edge[0], edge[0], edge[1])
	print(f"Distance from {from_node} to {to_node} is {paraNetwork.originalNetwork.getDistance(from_node, to_node)}")

# Verify Node ID Consistency
original_node_ids = list(paraNetwork.originalNetwork.nodes.keys())
edge_node_ids = [edge for edge in paraNetwork.edges.keys()]

# Print to compare manually or write logic to compare programmatically
print("Original Node IDs:", original_node_ids)
print("Edge Node IDs:", edge_node_ids)

# Verify Correct Data Mapping in Original Network
for node_id in original_node_ids[:5]:  # Checking first 5 nodes for example
    print(f"Node {node_id} data: {paraNetwork.originalNetwork.nodes[node_id]}")

# Test Edge Data
for edge in list(paraNetwork.edges.keys())[:5]:  # Checking first 5 edges for example
    from_node, _, to_node = edge if len(edge) == 3 else (edge[0], edge[0], edge[1])
    print(f"Edge from {from_node} to {to_node}")
    print("From Node Data:", paraNetwork.originalNetwork.nodes.get(from_node))
    print("To Node Data:", paraNetwork.originalNetwork.nodes.get(to_node))
"""


 as u64))?;
            let buf_size = (block_len + INDEX_BLOCK_LENGTH) as usize;
            self.db_file.read_exact(&mut buf[..buf_size])?;

            let mut data_ptr = 0;
            h = block_len / INDEX_BLOCK_LENGTH;
            l = 0;

            while l <= h {
                let m = (l + h) >> 1;
                let p = m * INDEX_BLOCK_LENGTH;
                let sip = get_u32(&buf[..buf_size], p);
                if ip < sip {
                    h = m - 1;
                } else {
                    let eip = get_u32(&buf[..buf_size], p + 4);
                    if ip > eip {
                        l = m + 1;
                    } else {
                        data_ptr = get_u32(&buf[..buf_size], p + 8);
                        break;
                    }
                }
            }
            if data_ptr == 0 {
                Err("not found")?;
            }

            let data_len = (data_ptr >> 24) & 0xff;
            data_ptr = data_ptr & 0x00FFFFFF;

            self.db_file.seek(SeekFrom::Start(data_ptr as u64))?;
            self.db_file.read_exact(&mut buf[0..data_len as usize])?;

            get_ip_info(
                get_u32(&buf[..data_len as usize], 0),
                &buf[4..data_len as usize],
            ).map(|i| i.to_owned())
        })
    }
}

//  cargo test --features lazy  -- --nocapture
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        let mut ip2 = Ip2Region::new(DB_PATH).unwrap();
        let ip2o = ip2.to_owned().unwrap();

        for ip in vec![
            "192.168.127.12",
            "172.16.17.32",
            "127.0.0.1",
            "10.0.0.1",
            "1.1.1.1",
        ] {
            #[cfg(feature = "lazy")]
            {
                println!("lzay__: {:?}", memory_search(ip));
                if ip2o.memory_search(ip).is_ok() {
                    assert_eq!(ip2o.memory_search(ip).unwrap(), memory_search(ip).unwrap());
                } else {
                    assert!(memory_search(ip).is_err());
                }
            }

            println!("memory: {:?}", ip2o.memory_search(ip));
            println!("binary: {:?}", ip2.binary_search(ip));
            println!("btree : {:?}", ip2.btree_search(ip));

            if ip2o.memory_search(ip).is_ok() {
                assert_eq!(
                    ip2o.memory_search(ip).unwrap().to_owned(),
                    ip2.binary_search(ip).unwrap()
                );
                assert_eq!(
                    ip2o.memory_search(ip).unwrap().to_owned(),
                    ip2.btree_search(ip).unwrap()
                );
            } else {
                assert!(ip2.binary_search(ip).is_err());
                assert!(ip2.btree_search(ip).is_err());
            }
            println!();
        }
    }
}
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless requi


ver.sin_family=AF_INET;
	server.sin_port=TINYCLR_SSL_HTONS((unsigned short)port);
	if (ip == NULL)
		server.sin_addr.S_un.S_addr=INADDR_ANY;
	else
/* Added for T3E, address-of fails on bit field (beckman@acl.lanl.gov) */
#ifndef BIT_FIELD_LIMITS
		TINYCLR_SSL_MEMCPY(&server.sin_addr.S_un.S_addr,ip,4);
#else
		TINYCLR_SSL_MEMCPY(&server.sin_addr,ip,4);
#endif

		if (type == SOCK_STREAM)
			s=TINYCLR_SSL_SOCKET(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);
		else /* type == SOCK_DGRAM */
			s=TINYCLR_SSL_SOCKET(AF_INET, SOCK_DGRAM,IPPROTO_UDP);

	if (s == INVALID_SOCKET) goto err;
#if defined SOL_SOCKET && defined SO_REUSEADDR
		{
		int j = 1;
		TINYCLR_SSL_SETSOCKOPT(s, SOL_SOCKET, SO_REUSEADDR,
			   (const char*) &j, sizeof j);
		}
#endif
	if (TINYCLR_SSL_BIND(s,(struct TINYCLR_SSL_SOCKADDR *)&server,sizeof(server)) == -1)
		{
#ifndef OPENSSL_SYS_WINDOWS
		TINYCLR_SSL_PERROR("bind");
#endif
		goto err;
		}
	/* Make it 128 for linux */
	if (type==SOCK_STREAM && TINYCLR_SSL_LISTEN(s,128) == -1) goto err;
	*sock=s;
	ret=1;
err:
	if ((ret == 0) && (s != -1))
		{
		SHUTDOWN(s);
		}
	return(ret);
	}

static int init_server(int *sock, int port, int type)
	{
	return(init_server_long(sock, port, NULL, type));
	}

static int do_accept(int acc_sock, int *sock, char **host)
	{
	int ret;
	struct hostent *h1,*h2;
	static struct TINYCLR_SSL_SOCKADDR_IN from;
	int len;
/*	struct linger ling; */

	if (!ssl_sock_init()) return(0);

#ifndef OPENSSL_SYS_WINDOWS
redoit:
#endif

	TINYCLR_SSL_MEMSET((char *)&from,0,sizeof(from));
	len=sizeof(from);
	/* Note: under VMS with SOCKETSHR the fourth parameter is currently
	 * of type (int *) whereas under other systems it is (void *) if
	 * you don't have a cast it will choke the compiler: if you do
	 * have a cast then you can either go for (int *) or (void *).
	 */
	ret=TINYCLR_SSL_ACCEPT(acc_sock,(struct TINYCLR_SSL_SOCKADDR *)&from,(int *)&len);
	if (ret == INVALID_SOCKET)
		{
#if defined(OPENSSL_SYS_WINDOWS) || (defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK))
		int i;
		i=TINYCLR_SSL_GETLASTSOCKETERROR();
		BIO_printf(bio_err,"accept error %d\n",i);
#else
		if (errno == EINTR)
			{
			/*check_timeout(); */
			goto redoit;
			}
		TINYCLR_SSL_FPRINTF(OPENSSL_TYPE__FILE_STDERR,"errno=%d ",errno);
		TINYCLR_SSL_PERROR("accept");
#endif
		return(0


using System;
using AbpElsaSample.Data;
using Serilog;
using Serilog.Events;

namespace AbpElsaSample;

public class Program
{
    public async static Task<int> Main(string[] args)
    {
        var loggerConfiguration = new LoggerConfiguration()
#if DEBUG
            .MinimumLevel.Debug()
#else
            .MinimumLevel.Information()
#endif
            .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
            .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
            .Enrich.FromLogContext()
            .WriteTo.Async(c => c.File("Logs/logs.txt"))
            .WriteTo.Async(c => c.Console());

        if (IsMigrateDatabase(args))
        {
            loggerConfiguration.MinimumLevel.Override("Volo.Abp", LogEventLevel.Warning);
            loggerConfiguration.MinimumLevel.Override("Microsoft", LogEventLevel.Warning);
            loggerConfiguration.MinimumLevel.Override("IdentityServer4.Startup", LogEventLevel.Warning);
        }

        Log.Logger = loggerConfiguration.CreateLogger();

        try
        {
            var builder = WebApplication.CreateBuilder(ar


Case B because:
	# (1) this code path (.Lhandle_exception) is triggered only if we haven't
	# yet exited the enclave when signal arrived, and
	# (2) in Case B, we exited the enclave and signal arrived while in
	# untrusted code. The two conditions cannot be true at the same time,
	# so Case B never happens here (Case B results in return_from_ocall code
	# path below).

.Lhandle_interrupted_ocall_case_c:
	# Case C. We are right-after EENTER returning from successful ocall.
	# Move %rip to .Lreturn_from_ocall_after_stack_restore and let
	# _DkHandleExternalEvent() handle the exception.
	# SGX_GPR_RDI(%rbx): don't touch successful ocall result.
	movq %rdi, SGX_GPR_RSI(%rbx) # external event for .Lreturn_from_ocall
	leaq .Lreturn_from_ocall_after_stack_restore(%rip), %rax
	movq %rax, SGX_GPR_RIP(%rbx)
	movq %rsi, SGX_GPR_RSP(%rbx)
	movq $0, %gs:SGX_PRE_OCALL_STACK
	andq $(~(RFLAGS_DF | RFLAGS_AC)), SGX_GPR_RFLAGS(%rbx)
	jmp .Leexit_exception

.Lsetup_exception_handler:
	# The thread got interrupted outside of ocall handling (see above for
	# that special case). We inject a call to _DkExceptionHandler into the
	# interrupted thread which will handle the exception on ERESUME.

	# The last instructions of _restore_sgx_context need to be atomic for
	# the code below (see _restore_sgx_context for more details). So
	# emulate this if we were interrupted there.
	leaq .Ltmp_rip_saved0(%rip), %rax
	cmpq %rax, SGX_GPR_RIP(%rbx)
	je .Lemulate_tmp_rip_saved0

	leaq .Ltmp_rip_saved1(%rip), %rax
	cmpq %rax, SGX_GPR_RIP(%rbx)
	je .Lemulate_tmp_rip_saved1

	leaq .Ltmp_rip_saved2(%rip), %rax
	cmpq %rax, SGX_GPR_RIP(%rbx)
	je .Lemulate_tmp_rip_saved2

	jmp .Lemulate_tmp_rip_end

.Lemulate_tmp_rip_saved0:
	# emulate movq SGX_CPU_CONTEXT_R15 - SGX_CPU_CONTEXT_RIP(%rsp), %r15
	movq SGX_GPR_RSP(%rbx), %rax
	movq SGX_CPU_CONTEXT_R15 - SGX_CPU_CONTEXT_RIP(%rax), %rax
	movq %rax, SGX_GPR_R15(%rbx)
.Lemulate_tmp_rip_saved1:
	# emulate movq SGX_CPU_CONTEXT_RSP - SGX_CPU_CONTEXT_RIP(%rsp), %rsp
	movq SGX_GPR_RSP(%rbx), %rax
	movq SGX_CPU_CONTEXT_RSP - SGX_CPU_CONTEXT_RIP(%rax), %rax
	movq %rax, SGX_GPR_RSP(%rbx)
.Lemulate_tmp_rip_saved2:
	# emulate jmp *%gs:SGX_TMP_RIP
	movq %gs:SGX_TMP_RIP, %rax
	movq %rax, SGX_GPR_RIP(%rbx)
.Lemulate_tmp_rip_end:

	movq SGX_GPR_RSP(%


this.prevPosY = this.posY;
        this.prevPosZ = this.posZ;

        if (this.particleAge++ >= this.particleMaxAge)
        {
            this.setDead();
        }

        this.moveEntity(this.motionX, this.motionY, this.motionZ);
        this.particleGreen = (float)((double)this.particleGreen * 0.96D);
        this.particleBlue = (float)((double)this.particleBlue * 0.9D);
        this.motionX *= 0.699999988079071D;
        this.motionY *= 0.699999988079071D;
        this.motionZ *= 0.699999988079071D;
        this.motionY -= 0.019999999552965164D;

        if (this.onGround)
        {
            this.motionX *= 0.699999988079071D;
            this.motionZ *= 0.699999988079071D;
        }
    }

    public static class Factory implements IParticleFactory
    {
        public EntityFX getEntityFX(int particleID, World worldIn, double xCoordIn, double yCoordIn, double zCoordIn, double xSpeedIn, double ySpeedIn, double zSpeedIn, int... p_178902_15_)
        {
            return new EntityCrit2FX(worldIn, xCoordIn, yCoordIn, zCoordIn, xSpeedIn, ySpeedIn, zSpeedIn);
        }
    }

    public static class MagicFactory implements IParticleFactory
    {
        public EntityFX getEntityFX(int particleID, World worldIn, double xCoordIn, double yCoordIn, double zCoordIn, double xSpeedIn, double ySpeedIn, double zSpeedIn, int... p_178902_15_)
        {
            EntityFX entityfx = new EntityCrit2FX(worldIn, xCoordIn, yCoordIn, zCoordIn, xSpeedIn, ySpeedIn, zSpeedIn);
            entityfx.setRBGColorF(entityfx.getRedColorF() * 0.3F, entityfx.getGreenColorF() * 0.8F, entityfx.getBlueColorF());
            entityfx.nextTextureIndexX();
            return entityfx;
        }
    }
}
package net.minecraft.client.particle;

import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.WorldRenderer;
import net.minecraft.client.renderer.texture.TextureManager;
import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
import net.minecraft.client.renderer.vertex.VertexFormat;
import net.minecraft.entity.Entity;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.World;

public class EntityLargeExplodeFX extends EntityFX
{
    private static final ResourceLocation EXPLOSION_TEXTURE = new ResourceLocation("textures/entity/explosion.png");
    private static final VertexFormat VERTEX_FORMAT = new VertexFormat().addElement(DefaultVertexFormats.POSITION_3F).addElement(DefaultVertexFormats.TEX_2F).addElement(DefaultVertexFormats.COLOR_4UB).addElement(DefaultVertexFormats.TEX_2S).addElement(DefaultVertexFormats.NORMAL_3B).addElement(DefaultVertexFormats.PADDING_1B);
    private int life;
    private final int lifeTime;

    /** The Rendering Engine. */
    private final TextureManager theRenderEngine;
    private final float size;

    protected EntityLargeExplodeFX(TextureManager renderEngine, World worldIn, double xCoordIn, double yCoordIn, double zCoordIn, double p_i1213_9_, double p_i1213_11_, double p_i1213_13_)


$list: set-nth($list, $i, nth($list, $j));
    $list: set-nth($list, $j, $tmp);
  }

  @return sl-to-list($list);
}

///
/// @requires sl-shuffle
/// @alias sl-shuffle
///

@function sl-randomize($list) {
  @return sl-shuffle($list);
}
///
/// Slices `$list` between `$start` and `$end`.
///
/// @ignore Documentation: http://at-import.github.io/SassyLists/documentation/#function-sl-slice
///
/// @param {List}   $list                  - list to slice
/// @param {Number} $start [1]             - start index
/// @param {Number} $end   [length[$list]] - end index
///
/// @throws List indexes $start and $end must be numbers for `sl-slice`.
/// @throws Start index has to be lesser than or equals to the end index for `sl-slice`.
/// @throws List indexes must be non-zero integers for `sl-slice`.
/// @throws Start index has to be lesser than or equal to list length for `sl-slice`.
/// @throws End index has to be lesser than or equal to list length for `sl-slice`.
///
/// @example
/// sl-slice(a b c d e, 2, 4)
/// // b c d
///
/// @example
/// sl-slice(a b c d e, 2, 2)
/// // b
///
/// @example
/// sl-slice(a b c d e, 4, 2)
/// // null
///
/// @example
/// sl-slice(a b c d e, -1, 6)
/// // null
///
/// @return {List | Null}
///

@function sl-slice($list, $start: 1, $end: length($list)) {
  @if type-of($start) != 'number' or type-of($end) != 'number' {
    @error 'List indexes #{$start} and #{$end} must be numbers for `sl-slice`.';
  }

  @if $start > $end {
    @error 'Start index is #{$start} but has to be lesser than or equals to the end index (#{$end}) for `sl-slice`.';
  }

  @if $start < 1 or $end < 1 {
    @error 'List indexes must be non-zero integers for `sl-slice`.';
  }

  @if $start > length($list) {
    @error 'Start index is #{$start} but list is only #{length($list)} items long for `sl-slice`.';
  }

  @if $end > length($list) {
    @error 'End index is #{$end} but list is only #{length($list)} items long for `sl-slice`.';
  }

  $result: ();

  @for $i from $start through $end {
    $result: append($result, nth($list, $i), list-separator($list));
  }

  @return $result;
}
///
/// Tests whether some items from `$list` pass the test implemented by `$function`.
///
/// @ignore Documentation: http://at-import.github.io/SassyLists/documentation/#function-sl-some
///
/// @param {List}    $list     - list to run test against
/// @param {String}  $function - function to run against every item from list
/// @param {ArgList} $args     - extra arguments to pass to the function
///
/// @example
/// sl-some(1 2 3, unitless)
/// // true
///
/// @example
/// sl-some(1 2 3px, unitless)
/// // true
///
/// @example
/// sl-some(1px 2px 3px, unitless)
/// // false
///
/// @return {Bool}
///

@function sl-some($list, $


w r24, CTX0
	movw r22, MB0
	rcall shabal_p
	movw r30, CTX0
	ldd r22, Z+8
	ldd r23, Z+9
	ldd r24, Z+10
	ldd r25, Z+11
	std Z+10, r22
	std Z+11, r23
	std Z+8,  r24
	std Z+9,  r25
	dec I
	brne 5b

	stack_free_large 64
	pop_range 12, 17
	ret


  border-bottom: 1px dotted #777;
}

.tooltip-content {
    opacity: 0;
    visibility: hidden;
    font: 12px Arial, Helvetica;
    text-align: center;
    border-color: #aaa #555 #555 #aaa;
    border-style: solid;
    border-width: 1px;
    padding: 15px;
    position: absolute;
    bottom: 40px;
    left: 50%;
    margin-left: -76px;
    background-color: #fff;
    transition: bottom .2s ease, opacity .2s ease;
}

.tooltip-content:after,
.tooltip-content:before {
    bottom: -15px;
    content: "";
    position: absolute;
    left: 50%;
    margin-left: -10px;
}

.tooltip-content:before {
    border-right-width: 25px;
    border-top-color: #555;
    border-top-width: 15px;
    bottom: -15px;
}

.tooltip:hover .tooltip-content{
    opacity: 1;
    visibility: visible;
    bottom: 30px;
}/*! jQuery UI - v1.11.4 - 2015-04-11
* http://jqueryui.com
* Copyright 2015 jQuery Foundation and other contributors; Licensed MIT */

.ui-widget{font-family:Verdana,Arial,sans-serif;font-size:1.1em}.ui-widget .ui-widget{font-size:1em}.ui-widget input,.ui-widget select,.ui-widget textarea,.ui-widget button{font-family:Verdana,Arial,sans-serif;font-size:1em}.ui-widget-content{border:1px solid #555;background:#000 url("images/ui-bg_loop_25_000000_21x21.png") 50% 50% repeat;color:#fff}.ui-widget-content a{color:#fff}.ui-widget-header{border:1px solid #333;background:#444 url("images/ui-bg_highlight-soft_44_444444_1x100.png") 50% 50% repeat-x;color:#fff;font-weight:bold}.ui-widget-header a{color:#fff}.ui-state-default,.ui-widget-content .ui-state-default,.ui-widget-header .ui-state-default{border:1px solid #444;background:#222 url("images/ui-bg_highlight-soft_35_222222_1x100.png") 50% 50% repeat-x;font-weight:normal;color:#eee}.ui-state-default a,.ui-state-default a:link,.ui-state-default a:visited{color:#eee;text-decoration:none}.ui-state-hover,.ui-widget-content .ui-state-hover,.ui-widget-header .ui-state-hover,.ui-state-focus,.ui-widget-content .ui-state-focus,.ui-widget-header .ui-state-focus{border:1px solid #0b93d5;background:#003147 url("images/ui-bg_highlight-soft_33_003147_1x100.png") 50% 50% repeat-x;font-weight:normal;color:#fff}.ui-state-hover a,.ui-state-hover a:hover,.ui-state-hover a:link,.ui-state-hover a:visited,.ui-state-focus a,.ui-state-focus a:hover,.ui-state-focus a:link,.ui-state-focus a:visited{color:#fff;text-decoration:none}.ui-state-active,.ui-widget-content .ui-state-active,.ui-widget-header .ui-state-active{border:1px solid #26b3f7;background:#0972a5 url("images/ui-bg_highlight-hard_20_0972a5_1x100.png") 50% 50% repeat-x;font-weight:normal;color:#fff}.ui-state-active a,.ui-state-active a:link,.ui-state-active a:visited{color:#fff;text-decoration:none}.ui-state-highlight,.ui-widget-content .ui-state-highlight,.ui-widget-header .ui-state-highlight{border


String? _responseCode;

  /// See `ApprovalRefNo` in [UPI Linking Specification](https://www.npci.org.in/sites/default/files/UPI%20Linking%20Specs_ver%201.6.pdf) (Android-only)
  String? _approvalRefNo;

  /// Status of transaction on Android / iOS
  UpiTransactionStatus? _status;

  /// See `txnRef` in [UPI Linking Specification](https://www.npci.org.in/sites/default/files/UPI%20Linking%20Specs_ver%201.6.pdf) (Android-only)
  String? _txnRef;

  /// Response string in the format specified in [UPI Linking Specification](https://www.npci.org.in/sites/default/files/UPI%20Linking%20Specs_ver%201.6.pdf) (Android-only)
  String? _rawResponse;

  /// UPI app launch exception (iOS-only)
  String? _launchError;

  /// Android platform constructor.
  ///
  /// Parses the response as per the [UPI Linking Specification](https://www.npci.org.in/sites/default/files/UPI%20Linking%20Specs_ver%201.6.pdf)
  /// to populate Android-specific attributes.
  UpiTransactionResponse.android(String responseString) {
    this._rawResponse = responseString;
    // Consider the response to be failure if success or submitted is not explicitly returned.
    this._status = UpiTransactionStatus.failure;
    List<String> fragments = responseString.split('&');
    fragments.forEach((fragment) {
      List<String> keyValuePair = fragment.split('=');
      String normalizedKey = keyValuePair.first.toLowerCase();
      String value = keyValuePair.last;
      switch (normalizedKey) {
        case 'txnid':
          this._txnId = value;
          break;
        case 'responsecode':
          this._responseCode = value;
          break;
        case 'approvalrefno':
          this._approvalRefNo = value;
          break;
        case 'status':
          if (value.toLowerCase().contains('success')) {
            this._status = UpiTransactionStatus.success;
          } else if (value.toLowerCase().contains('fail')) {
            this._status = UpiTransactionStatus.failure;
          } else if (value.toLowerCase().contains('submitted')) {
            this._status = UpiTransactionStatus.submitted;
          } else if (value.toLowerCase() == 's') {
            this._status =
                UpiTransactionStatus.success; // YuvaPay returns status=S
          } else {
            throw UnsupportedError('Unsupported UPI Transaction Status');
          }
          break;
        case 'txnref':
          this._txnRef = value;
      }
    });
  }

  /// iOS platform constructor.
  ///
  /// Populates [_status] as per the [result].
  UpiTransactionResponse.ios(bool result) {
    _status = result
        ? UpiTransactionStatus.launched
        : UpiTransactionStatus.failedToLaunch;
  }

  /// iOS platform app launch exception case constructor.
  ///
  /// Populates [_status] and [_launchError].
  UpiTransactionResponse.iosError(error) {
    _status = UpiTransactionStatus.failedToLaunch;
    _launchError = error.toString();
  }

  String toString() {
    return 'UpiTransactionResponse { txnId: $_txnId, responseCode: '
        '$_responseCode, approvalRefNo: $_approvalRefNo, status: $_status, '
        'txnRef: $_txnRef, rawResponse: $_rawResponse }';
  }

  /// Getter for [_txnId]. Leads to [UnsupportedError] on iOs.
  String? get txnId {
    if (io.Platform.isAndroid) {
      return _txnId;
    }
    throw UnsupportedError('The attribute txnId is not available on iOS


 transparent;
}

.clearlooks2 .mceTop .mceRight {
	background: #444444;
	border-color: transparent;
}

.clearlooks2 .mceMiddle {
	clip: rect(24px auto auto auto);
}

.clearlooks2 .mceMiddle .mceLeft {
	background: #f1f1f1;
	border-color: transparent;
}

.clearlooks2 .mceMiddle .mceRight {
	background: #f1f1f1;
	border-color: transparent;
}

.clearlooks2 .mceBottom {
	background: #f1f1f1;
	border-color: transparent;
}

.clearlooks2 .mceBottom .mceLeft {
	background: #f1f1f1;
	border-color: transparent;
}

.clearlooks2 .mceBottom .mceCenter {
	background: #f1f1f1;
	border-color: transparent;
}

.clearlooks2 .mceBottom .mceRight {
	background: #f1f1f1;
	border-color: transparent;
}

.clearlooks2 .mceClose,
.clearlooks2 .mceFocus .mceClose,
.clearlooks2 .mceFocus .mceClose:hover {
	background-image: none;
}
.clearlooks2 .mceClose:before {
	content: '\f158';
	font: normal 20px/1 'dashicons';
	speak: none;
	-webkit-font-smoothing: antialiased;
	-moz-osx-font-smoothing: grayscale;
	color: #999;
	padding-left: 12px;
}

/* from colors.css
.clearlooks2 {
	box-shadow: 0 5px 15px rgba(0,0,0,0.7);
}

.clearlooks2 .mceMiddle span,
.clearlooks2 .mceMiddle .mceLeft,
.clearlooks2 .mceMiddle .mceRight,
.clearlooks2 .mceBottom,
.clearlooks2 .mceBottom .mceLeft,
.clearlooks2 .mceBottom .mceCenter,
.clearlooks2 .mceBottom .mceRight {
	background-color: #fcfcfc;
}

.clearlooks2 .mceTop span,
.clearlooks2 .mceFocus .mceTop span {
	color: #222;
}

.clearlooks2 .mceClose:before {
	color: #999;
}

.clearlooks2 .mceClose:hover:before {
	color: #2ea2cc;
}
*/
/* Distraction-Free Writing mode
 * =Overlay Styles
-------------------------------------------------------------- */
.fullscreen-overlay {
	z-index: 100005;
	display: none;
	position: fixed;
	top: 0;
	bottom: 0;
	right: 0;
	left: 0;
	-webkit-filter: inherit;
	filter: inherit;
}

.wp-fullscreen-active .fullscreen-overlay,
.wp-fullscreen-active #wp-fullscreen-body {
	display: block;
}

.fullscreen-fader {
	z-index: 200000;
}

.wp-fullscreen-active .fullscreen-fader,
.wp-core-ui.wp-fullscreen-active .postbox-container {
	display: none;
}

/* =Overlay Body
-------------------------------------------------------------- */

#wp-fullscreen-body,
.mce-fullscreen {
	z-index: 100010;
}

#wp-fullscreen-body {
	display: none;
}

.wp-fullscreen-wrap {
	margin: 0;
	padding: 0;
	position: absolute;
	right: 0;
	left: 0;
	bottom: 30px;
	top: 60px;
	z-index: 100015;
}

.wp-fullscreen-wrap .wp-editor-co


 level)
}

// visitObject visits an object. If the object is a service, ingress, or pod, it
// also runs custom visitor code for them.
func (dv *DefaultVisitor) visitObject(ctx context.Context, object runtime.Object, handler ObjectHandler, visitDescendants bool, level int) error {
	ctx, span := trace.StartSpan(ctx, "visitObject")
	defer span.End()

	if object == nil {
		return errors.New("can't visit a nil object")
	}

	m, err := runtime.DefaultUnstructuredConverter.ToUnstructured(object)
	if err != nil {
		return err
	}

	u := &unstructured.Unstructured{Object: m}

	apiVersion := u.GetAPIVersion()
	kind := u.GetKind()

	objectGVK := schema.FromAPIVersionAndKind(apiVersion, kind)

	tvMap := make(map[schema.GroupVersionKind]TypedVisitor)
	for _, typedVisitor := range dv.typedVisitors {
		tvMap[typedVisitor.Supports()] = typedVisitor
	}

	tv, ok := tvMap[objectGVK]
	if ok {
		if err := tv.Visit(ctx, u, handler, dv, visitDescendants, level); err != nil {
			return err
		}
	}

	return dv.defaultHandler.Visit(ctx, u, handler, dv, visitDescendants, level)
}
/*
Copyright (c) 2019 the Octant contributors. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/

package printer

import (
	"testing"

	"github.com/stretchr/testify/assert"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func Test_printMatchLabels(t *testing.T) {
	cases := []struct {
		name        string
		matchLabels map[string]string
		expected    string
	}{
		{
			name:        "single label",
			matchLabels: map[string]string{"foo": "bar"},
			expected:    "foo:bar",
		},
		{
			name: "multiple labels",
			matchLabels: map[string]string{
				"foo": "bar",
				"bar": "foo",
			},
			expected: "bar:foo, foo:bar",
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			got := printMatchLabels(tc.matchLabels)
			assert.Equal(t, tc.expected, got)
		})
	}
}

func Test_printLabelSelectorRequirement(t *testing.T) {
	cases := []struct {
		name         string
		requirements []metav1.LabelSelectorRequirement
		expected     string
	}{
		{
			name:         "empty",
			requirements: nil,
			expected:     "",
		},
		{
			name: "in",
			requirements: []metav1.LabelSelectorRequirement{
				{
					Key:      "key",
					Operator: metav1.LabelSelectorOpIn,
					Values:   []string{"x", "y"},
				},
			},
			expected: "key in [x, y]",
		},
		{
			name: "not in",
			requirements: []metav1.LabelSelectorRequirement{
				{
					Key:      "key",
					Operator: metav1.LabelSelectorOpNotIn,
					Values:   []string{"x", "y"},
				},
			},
			expected: "key not in [x, y]",
		},
		{
			name: "exists",
			requirements: []metav1.LabelSelectorRequirement{
				{
					Key:      "key",
					Operator: metav1.LabelSelectorOpExists,
				},
			},
			expected: "key exists",
		},
		{
			name: "does not exist",
			requirements: []metav1.LabelSelectorRequirement{
				{
					Key:      "key",
					Operator: metav1.LabelSelectorOpDo


af) no-repeat 0 -1920px !important;background-size: 16px !important;}.cke_hidpi .cke_ltr .cke_button__redo_icon,.cke_ltr.cke_hidpi .cke_button__redo_icon {background: url(icons_hidpi.png?t=b47abaf) no-repeat 0 -1944px !important;background-size: 16px !important;}.cke_rtl.cke_hidpi .cke_button__undo_icon, .cke_hidpi .cke_mixed_dir_content .cke_rtl .cke_button__undo_icon {background: url(icons_hidpi.png?t=b47abaf) no-repeat 0 -1968px !important;background-size: 16px !important;}.cke_hidpi .cke_ltr .cke_button__undo_icon,.cke_ltr.cke_hidpi .cke_button__undo_icon {background: url(icons_hidpi.png?t=b47abaf) no-repeat 0 -1992px !important;background-size: 16px !important;}.cke_hidpi .cke_button__spellchecker_icon {background: url(icons_hidpi.png?t=b47abaf) no-repeat 0 -2016px !important;background-size: 16px !important;}/*
Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
*/
.cke_dialog{visibility:visible}.cke_dialog_body{z-index:1;background:#fff}.cke_dialog strong{font-weight:bold}.cke_dialog_title{font-weight:bold;font-size:12px;cursor:move;position:relative;color:#484848;border-bottom:1px solid #d1d1d1;padding:12px 19px 12px 12px;background:#f8f8f8;letter-spacing:.3px}.cke_dialog_spinner{border-radius:50%;width:12px;height:12px;overflow:hidden;text-indent:-9999em;border:2px solid rgba(102,102,102,0.2);border-left-color:rgba(102,102,102,1);-webkit-animation:dialog_spinner 1s infinite linear;animation:dialog_spinner 1s infinite linear}.cke_browser_ie8 .cke_dialog_spinner,.cke_browser_ie9 .cke_dialog_spinner{background:url(images/spinner.gif) center top no-repeat;width:16px;height:16px;border:0}@-webkit-keyframes dialog_spinner{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}100%{-webkit-transform:rotate(360deg);transform:rotate(360deg)}}@keyframes dialog_spinner{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}100%{-webkit-transform:rotate(360deg);transform:rotate(360deg)}}.cke_dialog_contents{background-color:#fff;overflow:auto;padding:15px 10px 5px 10px;margin-top:43px;border-top:1px solid #d1d1d1}.cke_dialog_contents_body{overflow:auto;padding:9px 10px 5px 10px;margin-top:22px}.cke_dialog_footer{text-align:right;position:relative;border-top:1px solid #d1d1d1;background:#f8f8f8}.cke_rtl .cke_dialog_footer{text-align:left}.cke_hc .cke_dialog_footer{outline:0;border-top:1px solid #fff}.cke_dialog .cke_resizer{margin-top:22px}.cke_dialog .cke_resizer_rtl{margin-left:5px}.cke_dialog .cke_resizer_ltr{margin-right:5px}.cke_dialog_tabs{height:33px;display:inline-block;margin:9px 0 0;position:absolute;z-index:2;left:11px}.cke_rtl .cke_dialog_tabs{left:


.ACCESS_TOKEN_KEY]);
        localStorage.setItem(this.CLINET_KEY, headers[this.CLINET_KEY]);
        localStorage.setItem(this.UID_KEY, headers[this.UID_KEY]);
    }

    /**
     * ローカルストレージ上の認証情報を削除する
     */
    public static removeAuthInfo() {
        localStorage.removeItem(this.ACCESS_TOKEN_KEY);
        localStorage.removeItem(this.CLINET_KEY);
        localStorage.removeItem(this.UID_KEY);
    }

    /** APIのURL */
    private static readonly API_URL: string = 'https://shrouded-dusk-75907.herokuapp.com/api';

    /** APIのAccessToken */
    private static readonly ACCESS_TOKEN_KEY = 'access-token';
    /** APIのclient */
    private static readonly CLINET_KEY = 'client';
    /** APIのuid */
    private static readonly UID_KEY = 'uid';

    private static printAuthInfo() {
        console.log('access-token: ' + localStorage.getItem(this.ACCESS_TOKEN_KEY));
        console.log('client: ' + localStorage.getItem(this.CLINET_KEY));
        console.log('uid: ' + localStorage.getItem(this.UID_KEY));
    }

}
import { last, makeArray } from "lib";
import { DataPoint, IPerceptron, Stage } from "./types";

/**
 * the set of data must be passed through multiple times in order to properly fit the model
 * each pass of the whole set is an epoch
 *
 * note that one run without errors does not guarantee perfect fit if changes were made during that run
 * needs a run with no errors and no changes
 * OR needs to check for errors after the mutations
 */

export class Trainer {
  /**
   * The model which is being trained.
   * Can be any type of Perceptron as long as it fits the interface.
   */
  public readonly model: IPerceptron;

  /**
   * Store the weights after each iteration.
   */
  public readonly stages: Stage[];

  /**
   * Whether the model has successfully converged.
   * Will usually be true by the time that the constructor is done,
   * but not if the max epochs was reached before convergence.
   */
  private readonly isConverged: boolean;

  /**
   * Whether or not to console.log data on each iteration.
   */
  private readonly log: boolean;

  /**
   * The computation is all done in the constructor.
   * This is a class mainly for storing and accessing the values encountered along the way
   * and separation of concerns in general.
   */
  constructor(
    model: IPerceptron,
    trainingSet: DataPoint[],
    maxEpochs: number = 10,
    log: boolean = false
  ) {
    this.model = model;
    this.stages = [];
    this.isConverged = false;
    this.log = log;

    /**
     * Loops through training data multiple times.
     *
     * Will create an infinite loop if it never converges to a good model,
     * ie. if the data is not linearly separable.
     * So it needs a maximum number of epochs.
     *
     * Note: in the future want to also consider stopping when adjustments become minimal
     */
    let i = 0;
    while (!this.isConverged && this.stages.length < maxEpochs) {
      if (this.log) console.log(`Starting epoch ${i}`);
      this.isConverged = this.epoch(trainingSet);
      if (this.log) console.log(`Is trained? ${this.isConverged}`);
      i++;
    }
  }

  /**
   * Loops through every element in the training set once.
   * Returns true if there


    -- Process Wave B copies (samples 8-12)
    for i = 1, 5 do
      local sample_index = 7 + i  -- Start after the Wave A copies
      if new_instrument.samples[sample_index] then
        local sample = new_instrument.samples[sample_index]

        -- Alternate panning
        sample.panning = (i % 2 == 0) and 0.0 or 1.0

        -- Calculate detune offset
        local detune_offset = 0
        if preferences.pakettiUnisonDetuneHardSync.value then
          detune_offset = (i % 2 == 0) and -unison_range or unison_range
        elseif preferences.pakettiUnisonDetuneFluctuation.value then
          detune_offset = math.random(-unison_range, unison_range)
        else
          local detune_step = unison_range / 2.5  -- Adjusted for 5 samples
          local sample_offset = i - 3  -- Center around sample 3
          detune_offset = math.floor(sample_offset * detune_step)
        end

        sample.fine_tune = math.max(-127, math.min(127, original_fine_tune_b + detune_offset))
        sample.loop_mode = 2

        -- Apply fractional shifting only to first 4 copies (1/5, 2/5, 3/5, 4/5)
        if i <= 4 and not skip_fractional_shifting_b then
          local fraction = fraction_values[i]
          PakettiApplyFractionalShifting(sample, wave_b_sample, fraction)
        end

        -- Rename sample
        local panning_label = sample.panning == 0 and "50L" or "50R"
        sample.name = string.format("%s (Unison %d [%d] (%s))", original_wave_b_name, i, sample.fine_tune, panning_label)
      end
    end

    -- Set volume for all samples (adjusted for 12 samples instead of 8)
    local volume = math.db2lin(-21.5)  -- Adjusted for 12 samples: -18 - 20*log10(12/8) ≈ -21.5dB
    for i = 1, #new_instrument.samples do
      if new_instrument.samples[i] then
        new_instrument.samples[i].volume = volume
      end
    end

  else
    print("DEBUG: Using standard unison mode")

    -- Create 7 additional sample slots for unison
  for i = 2, 8 do
    local success, error_msg = pcall(function()
      new_instrument:insert_sample_at(i)
    end)

    if not success then
      print("DEBUG: Failed to create sample slot", i, ":", tostring(error_msg))
      break
    end

    -- Validate sample slot exists before copying
    if #new_instrument.samples >= i and new_instrument.samples[i] and base_sample then
      new_instrument.samples[i]:copy_from(base_sample)
      new_instrument.samples[i].loop_mode = 2
      new_instrument.samples[i].interpolation_mode = preferences.pakettiLoaderInterpolation.value
      new_instrument.samples[i].oversample_enabled = preferences.pakettiLoaderOverSampling.value
      new_instrument.samples[i].autofade = preferences.pakettiLoaderAutofade.value
      print("DEBUG: Successfully created and configured sample slot", i)
    else
      print("DEBUG: Sample slot", i, "not accessible after creation")
      break
    end
  end

  -- Define the finetune and panning adjustments
  local fraction_values = {1/8, 2/8, 3/8, 4/8, 5/8, 6/8, 7/8}
  local unison_range = preferences.pakettiUnisonDetune.value or 25  -- Use preference value, default to 25 if nil
  local original_fine


== '0000000008040001000F00000000000000000000') { console.log('GRAY4'); amtDesktop.bpp = 1; obj.graymode = true; obj.lowcolor = true; } // Switch to 1 byte per pixel, 16 grays
                }
            }

            // This is a PNG screenshot of the display, load it and render it.
            if ((type == 3) && (recFileProtocol == 200)) {
                var tile = new Image();
                tile.src = 'data:image/png;base64,' + btoa(data);
                tile.onload = function () { amtDesktop.canvas.drawImage(tile, 0, 0); }
                tile.error = function () { }
            }

            recFileLastTime = time;
            if (srec_playing == 2) { readNextBlock(processBlock); }
        }

        function srec_cleanup() {
            recFile = null;
            recFilePtr = 0;
            recFileMetadata = null;
            srec_playing = 0;
            if (agentDesktop != null) { agentDesktop.Canvas.clearRect(0, 0, agentDesktop.CanvasId.width, agentDesktop.CanvasId.height); agentDesktop = null; }
            if (amtDesktop != null) { amtDesktop.canvas.clearRect(0, 0, amtDesktop.canvasid.width, amtDesktop.canvasid.height); amtDesktop = null; }
            readState = 0;
            waitTimerArgs = null;
            currentDeltaTimeTotalSec = 0;
            recFileEndTime = 0;
            agentTerminal = null;
            if (waitTimer != null) { clearTimeout(waitTimer); waitTimer = null; }
            QH('srec_deskstatus', '');
            QE('srec_PlayButton', false);
            QE('srec_PauseButton', false);
            QE('srec_RestartButton', false);
            QS('srec_progressbar').width = '0px';
            QH('srec_timespan', '00:00:00');
            QV('srec_metadatadiv', true);
            QH('srec_metadatadiv', '
' + "录音会话播放器" + '
' + "拖放.mcrec文件或单击\“打开文件... \”" + '

');
            QV('srec_DeskParent', false);
            QV('srec_TermParent', false);
            QV('srec_toggleviewmode', false);
        }

        function srec_ondrop(e) {
            haltEvent(e);

            // Check if these are files we can upload, remove all folders.
            if (e.dataTransfer == null) return;
            var files = [];
            for (var i in e.dataTransfer.files) {
                if ((e.dataTransfer.files[i].type != null) && (e.dataTransfer.files[i].size != null) && (e.dataTransfer.files[i].size != 0) && (e.dataTransfer.files[i].name.endsWith('.mcrec'))) {
                    files.push(e.dataTransfer.files[i]);
                }
            }
            if (files.length == 0) return;
            srec_cleanup();
            recFile = files[0];
            recFilePtr = 0;
            readNextBlock(processFirstBlock);
            readLastBlock(function (type, flags, time) { if (type == 3) { recFileEndTime = time; } else { recFileEndTime = 0; } });
            srec_restart();
        }

        function srec_openfile() {
            var x = '<input type=file name=files id=srec_p2fileinput style=width:100% accept=".mcrec" onchange="openfileChanged()" />';
            setDialogMode(11, "打开文件...", 3, srec_openfileEx, x);
            QE('idx_dlgOkButton'


lcxx::arg("this"), jlcxx::arg("value"));

    DEBUG_MSG("Adding fPoly methods  to provide read access to the field fPoly (" __HERE__ ")");
    // defined in /home/pgras/.julia/artifacts/a4f6424ccb8f5188e250f447149860af999a56a0/include/TGeoXtru.h:29:20
    // signature to use in the veto list: TGeoXtru::ThreadData_t::fPoly
    t.method("fPoly", [](const TGeoXtru::ThreadData_t& a) -> TGeoPolygon * { return a.fPoly; }, jlcxx::arg("this"));
    t.method("fPoly", [](TGeoXtru::ThreadData_t& a) -> TGeoPolygon * { return a.fPoly; }, jlcxx::arg("this"));
    t.method("fPoly", [](const TGeoXtru::ThreadData_t* a) -> TGeoPolygon * { return a->fPoly; }, jlcxx::arg("this"));
    t.method("fPoly", [](TGeoXtru::ThreadData_t* a) -> TGeoPolygon * { return a->fPoly; }, jlcxx::arg("this"));
    // defined in /home/pgras/.julia/artifacts/a4f6424ccb8f5188e250f447149860af999a56a0/include/TGeoXtru.h:29:20
    // signature to use in the veto list: TGeoXtru::ThreadData_t::fPoly
    // with ! suffix to veto the setter only.
    DEBUG_MSG("Adding fPoly! methods to provide write access to the field fPoly (" __HERE__ ")");
    t.method("fPoly!", [](TGeoXtru::ThreadData_t& a, TGeoPolygon * val) -> TGeoPolygon * { return a.fPoly = val; }, jlcxx::arg("this"), jlcxx::arg("value"));

    DEBUG_MSG("Adding fPoly! methods to provide write access to the field fPoly (" __HERE__ ")");
    t.method("fPoly!", [](TGeoXtru::ThreadData_t* a, TGeoPolygon * val) -> TGeoPolygon * { return a->fPoly = val; }, jlcxx::arg("this"), jlcxx::arg("value"));
  }

private:
  std::unique_ptr<jlcxx::TypeWrapper<TGeoXtru::ThreadData_t>> type_;
};
std::shared_ptr<Wrapper> newJlTGeoXtru_ThreadData_t(jlcxx::Module& module){
  return std::shared_ptr<Wrapper>(new JlTGeoXtru_ThreadData_t(module));
}
// this file was auto-generated by wrapit v1.6.0
#include "Wrapper.h"

#include "jlROOT.h"
#include "dbg_msg.h"
#include "jlcxx/functions.hpp"
#include "jlcxx/stl.hpp"

namespace jlcxx {
  template<> struct IsMirroredType<THn> : std::false_type { };
  template<> struct DefaultConstructible<THn> : std::false_type { };
template<> struct SuperType<THn> { typedef THnBase type; };
}

// Class generating the wrapper for type THn
// signature to use in the veto file: THn
struct JlTHn: public Wrapper {

  JlTHn(jlcxx::Module& jlModule): Wrapper(jlModule){
    DEBUG_MSG("Adding wrapper for type THn (" __HERE__ ")");
    // defined in /home/pgras/.julia/artifacts/a4f6424ccb8f5188e250f447149860af999a56a0/include/THn.h:30:7
    jlcxx::TypeWrapper<THn>  t = jlModule.add_type<THn>("THn",


Slider 类的实例对象 vSlider 。
    vSlider.skin = "resource/ui/vslider.png";//设置 vSlider 的皮肤。
    vSlider.min = 0;//设置 vSlider 最低位置值。
    vSlider.max = 10;//设置 vSlider 最高位置值。
    vSlider.value = 2;//设置 vSlider 当前位置值。
    vSlider.tick = 1;//设置 vSlider 刻度值。
    vSlider.x = 100;//设置 vSlider 对象的属性 x 的值，用于控制 vSlider 对象的显示位置。
    vSlider.y = 100;//设置 vSlider 对象的属性 y 的值，用于控制 vSlider 对象的显示位置。
    vSlider.changeHandler = new laya.utils.Handler(this, onChange);//设置 vSlider 位置变化处理器。
    Laya.stage.addChild(vSlider);//把 vSlider 添加到显示列表。
}
function onChange(value) {
    console.log("滑块的位置： value=" + value);
}
	 * @example import HSlider = laya.ui.HSlider;
import VSlider = laya.ui.VSlider;
import Handler = laya.utils.Handler;
class VSlider_Example {
    private vSlider: VSlider;
    constructor() {
        Laya.init(640, 800);//设置游戏画布宽高。
        Laya.stage.bgColor = "#efefef";//设置画布的背景颜色。
        Laya.loader.load(["resource/ui/vslider.png", "resource/ui/vslider$bar.png"], Handler.create(this, this.onLoadComplete));//加载资源。
    }
    private onLoadComplete(): void {
        this.vSlider = new VSlider();//创建一个 VSlider 类的实例对象 vSlider 。
        this.vSlider.skin = "resource/ui/vslider.png";//设置 vSlider 的皮肤。
        this.vSlider.min = 0;//设置 vSlider 最低位置值。
        this.vSlider.max = 10;//设置 vSlider 最高位置值。
        this.vSlider.value = 2;//设置 vSlider 当前位置值。
        this.vSlider.tick = 1;//设置 vSlider 刻度值。
        this.vSlider.x = 100;//设置 vSlider 对象的属性 x 的值，用于控制 vSlider 对象的显示位置。
        this.vSlider.y = 100;//设置 vSlider 对象的属性 y 的值，用于控制 vSlider 对象的显示位置。
        this.vSlider.changeHandler = new Handler(this, this.onChange);//设置 vSlider 位置变化处理器。
        Laya.stage.addChild(this.vSlider);//把 vSlider 添加到显示列表。
    }
    private onChange(value: number): void {
        console.log("滑块的位置： value=" + value);
    }
}
	 * @see laya.ui.Slider
	 */

	class VSlider extends laya.ui.VSlider {}

	/**
	 * 相对布局插件
	 */

	class Widget extends laya.ui.Widget {}

	/**
	 * 微信开放数据展示组件，直接实例本


282.25-.03.219-.157 1.781-1.281c.168-.117.395-.188.625-.188zm6.906 15.219 1.532 2.344H22.03l-.25.625-.687 1.593-2.125-3.25.468-.343 1.97-.344v.031c.023-.004.038-.027.062-.031a2.97 2.97 0 001.437-.625zm-13.812.031a2.85 2.85 0 001.562.719h.031l1.907.25.437.344-2.125 3.218-.687-1.593-.25-.625H7.563z"/></svg>';
  static const String chair_solid =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="32" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 32 32"><path fill="currentColor" d="M11 4v12.438c-.102.027-.223.066-.313.093-.484.149-.82.305-1.062.469a1.986 1.986 0 00-.313.25c-.078.082-.187.25-.187.25L9 17.719V20h1v8h2v-8h8v8h2v-8h1v-2.281l-.125-.219s-.11-.168-.188-.25a1.986 1.986 0 00-.312-.25c-.242-.164-.578-.32-1.063-.469-.09-.027-.21-.066-.312-.093V4h-2v1h-6V4zm2 3h2v9.031c-.758.02-1.438.04-2 .094zm4 0h2v9.125c-.563-.055-1.242-.074-2-.094z"/></svg>';
  static const String chalkboard_solid =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="32" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 32 32"><path fill="currentColor" d="M5 7v16H3v2h26v-2h-2V7zm2 2h18v14H7zm14.281 3.281L17 16.562l-3.281-3.28-.719-.688-.719.687-3 3 1.438 1.438L13 15.437l3.281 3.282.719.687.719-.687 5-5zM20 20l-1 1 1 1h4v-2z"/></svg>';
  static const String chalkboard_teacher_solid =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="32" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 32 32"><path fill="currentColor" d="M4 6v2h22v16H12v2h18v-2h-2V6H4zm4.002 3A4.016 4.016 0 004 13c0 2.199 1.804 4 4.002 4A4.014 4.014 0 0012 13c0-2.197-1.802-4-3.998-4zM14 10v2h5v-2h-5zm7 0v2h3v-2h-3zM8.002 11C9.116 11 10 11.883 10 13c0 1.12-.883 2-1.998 2C6.882 15 6 14.12 6 13c0-1.117.883-2 2.002-2zM14 14v2h10v-2H14zM4 18v8h2v-6h3v6h2v-5.342l2.064 1.092c.585.31 1.288.309 1.872 0v.002l3.53-1.867-.933-1.77-3.531 1.


  80 9E 00 28 */	lwz r4, 0x28(r30)
/* 80387118 00382D78  80 04 00 3C */	lwz r0, 0x3c(r4)
/* 8038711C 00382D7C  54 00 27 3E */	srwi r0, r0, 0x1c
/* 80387120 00382D80  28 00 00 01 */	cmplwi r0, 1
/* 80387124 00382D84  40 82 00 20 */	bne lbl_80387144
/* 80387128 00382D88  38 61 00 10 */	addi r3, r1, 0x10
/* 8038712C 00382D8C  38 A0 00 00 */	li r5, 0
/* 80387130 00382D90  48 00 61 E9 */	bl GetTextureSize__Q34nw4r3lyt6detailFPQ34nw4r3lyt8MaterialUc
/* 80387134 00382D94  C0 01 00 10 */	lfs f0, 0x10(r1)
/* 80387138 00382D98  D0 1E 00 4C */	stfs f0, 0x4c(r30)
/* 8038713C 00382D9C  C0 01 00 14 */	lfs f0, 0x14(r1)
/* 80387140 00382DA0  D0 1E 00 50 */	stfs f0, 0x50(r30)
lbl_80387144:
/* 80387144 00382DA4  80 01 00 34 */	lwz r0, 0x34(r1)
/* 80387148 00382DA8  83 E1 00 2C */	lwz r31, 0x2c(r1)
/* 8038714C 00382DAC  83 C1 00 28 */	lwz r30, 0x28(r1)
/* 80387150 00382DB0  83 A1 00 24 */	lwz r29, 0x24(r1)
/* 80387154 00382DB4  83 81 00 20 */	lwz r28, 0x20(r1)
/* 80387158 00382DB8  7C 08 03 A6 */	mtlr r0
/* 8038715C 00382DBC  38 21 00 30 */	addi r1, r1, 0x30
/* 80387160 00382DC0  4E 80 00 20 */	blr

.global GetVtxColor__Q34nw4r3lyt7PictureCFUl
GetVtxColor__Q34nw4r3lyt7PictureCFUl:
/* 80387164 00382DC4  54 A0 10 3A */	slwi r0, r5, 2
/* 80387168 00382DC8  7C E4 02 14 */	add r7, r4, r0
/* 8038716C 00382DCC  88 C7 00 D4 */	lbz r6, 0xd4(r7)
/* 80387170 00382DD0  88 A7 00 D5 */	lbz r5, 0xd5(r7)
/* 80387174 00382DD4  88 87 00 D6 */	lbz r4, 0xd6(r7)
/* 80387178 00382DD8  88 07 00 D7 */	lbz r0, 0xd7(r7)
/* 8038717C 00382DDC  98 C3 00 00 */	stb r6, 0(r3)
/* 80387180 00382DE0  98 A3 00 01 */	stb r5, 1(r3)
/* 80387184 00382DE4  98 83 00 02 */	stb r4, 2(r3)
/* 80387188 00382DE8  98 03 00 03 */	stb r0, 3(r3)
/* 8038718C 00382DEC  4E 80 00 20 */	blr

.global SetVtxColor__Q34nw4r3lyt7PictureFUlQ34nw4r2ut5Color
SetVtxColor__Q34nw4r3lyt7PictureFUlQ34nw4r2ut5Color:
/* 80387190 00382DF0


y_v1`.  Uses sets for neighbor checking and handles edge cases better."""
    n1 = len(graph1)
    n2 = len(graph2)
    max_node = max(n1, n2)
    refined_weights = [[0.0] * max_node for _ in range(max_node)]

    neighbors1 = [set(n for n, adj in enumerate(row) if adj) for row in graph1]
    neighbors2 = [set(n for n, adj in enumerate(row) if adj) for row in graph2]

    for i in range(n1):
        for j in range(n2):
            node_similarity = weights[i][j] if i < len(weights) and j < len(weights[i]) else 0  # Handle potential index errors

            degree_i = len(neighbors1[i])
            degree_j = len(neighbors2[j])
            degree_diff = abs(degree_i - degree_j)
            edge_similarity = 1.0 / (1.0 + degree_diff)

            common_neighbors = neighbors1[i].intersection(neighbors2[j])
            neighbor_similarity = 0
            if common_neighbors:  # Only calculate if there are common neighbors
              neighbor_similarity = sum(weights[k][l] for k in neighbors1[i] for l in neighbors2[j] if k < len(weights) and l < len(weights[k])) / len(common_neighbors)

            refined_weights[i][j] = (node_similarity + edge_similarity + neighbor_similarity) / 3

    return refined_weights

def priority_v15(graph1: list[list[int]], graph2: list[list[int]], weights: list[list[int]]) -> list[list[float]]:
    """Improved version of `priority_v1` using neighbor comparison."""
    n1 = len(graph1)
    n2 = len(graph2)
    max_node = max(n1, n2)
    refined_weights = [[0.0] * max_node for _ in range(max_node)]
    degrees1 = [sum(row) for row in graph1]
    degrees2 = [sum(row) for row in graph2]
    neighbors1 = [set(idx for idx, val in enumerate(row) if val) for row in graph1]
    neighbors2 = [set(idx for idx, val in enumerate(row) if val) for row in graph2]

    for i in range(n1):
        for j in range(n2):
            degree_diff = abs(degrees1[i] - degrees2[j])
            common_neighbors = len(neighbors1[i].intersection(neighbors2[j]))
            neighbor_diff = abs(len(neighbors1[i]) - len(neighbors2[j]))

            # Combine degree difference, common neighbors, and neighbor difference
            score = common_neighbors - degree_diff - neighbor_diff  # Prioritize common neighbors

            # Incorporate initial weights if available
            if i < len(weights) and j < len(weights[0]):
                score += weights[i][j]

            refined_weights[i][j] = max(0, score)  # Ensure non-negative scores

    # Normalize the scores to probabilities
    max_score = max(max(row) for row in refined_weights) if any(any(row) for row in refined_weights) else 1.0
    if max_score > 0:
        for i in range(n1):
            for j in range(n2):
                refined_weights[i][j] /= max_score

    return refined_weights


65
IHN0YWdl 6566
LlN0cmluZw== 6567
IEFmcg== 6568
aWdlbg== 6569
IFNI 6570
RGVsZXRl 6571
ZWxscw== 6572
IHNvbGlk 6573
IG1lZXRpbmc= 6574
IHdvcmtlZA== 6575
IGVkaXRvcg== 6576
aW55 6577
0Lw= 6578
X3JlYWQ= 6579
Lklk 6580
ZWZm 6581
T2Zmc2V0 6582
Y2hh 6583
VVNFUg== 6584
CQkgICA= 6585
aXBwZWQ= 6586
IGRpY3Q= 6587
IFJ1bg== 6588
LmhwcA== 6589
IGFuZw== 6590
eG1s 6591
aW1wbGU= 6592
IG1lZGljYWw= 6593
X3Rva2Vu 6594
Y29ubmVjdA== 6595
IGhvdXI= 6596
IGNvbnRyb2xsZXI= 6597
X21lc3NhZ2U= 6598
VUlE 6599
R3I= 6600
YW5kZWQ= 6601
X0NI 6602
IGJvb2tz 6603
IHNwZWFr 6604
YW1pbmc= 6605
IG1vdW50 6606
UmVjb3Jk 6607
CXN0cnVjdA== 6608
LldlYg== 6609
b25kb24= 6610
IC8vCg== 6611
IGZlbHQ= 6612
LkF1dG8= 6613
aWRnZQ== 6614
X3Bvcw== 6615
UFI= 6616
IG1vZGVybg== 6617
Q29sbGVjdGlvbg== 6618
X21zZw== 6619
Q0Q= 6620
IExv 6621
IHNlY29uZHM= 6622
aWJseQ== 6623
LmVxdWFscw== 6624
IGludGVybmF0aW9uYWw= 6625
I3ByYWdtYQ== 6626
b290aA== 6627
V3JpdGVy 6628
aWF0ZQ== 6629
IGNlbGU= 6630
IEJpdA== 6631
aXZv 6632
aXZlcnk= 6633
cmQ= 6634
SEVDSw== 6635
IGNhY2hl 6636
LmNvdW50 6637
IHJvbGw= 6638
LlJlYWQ= 6639
MTA4 6640
UkVE 6641
IHNldHVw 6642
aXpvbnRhbA== 6643
bW9kZWxz 6644
YXJndg== 6645
IGNvbnNpZGVyZWQ= 6646
PSIuLi8= 6647
c2V0dGluZ3M= 6648
IFJlbA== 6649
IGdyb3d0aA== 6650
IG1peA== 6651
IFdhc2hpbmd0b24= 6652
IHBsdA== 6653
IElN 6654
4bo= 6655
IHR1cm5lZA== 6656
IERhdGVUaW1l 6657
IFdlZA== 6658
KHVybA== 6659
ICIt 6660
IGxldHRlcg== 6661
QXN5bmM= 6662
ICAgICAgICAgICAgICAgICAgICAgICAgICAgIA== 6663
IE9jdG9iZXI= 6664
X2xpbmU= 6665
IGF0dGVudGlvbg== 6666
IGNvbGxlY3Q= 6667
IEhhc2g= 6668
IGltYWc= 6669
VHJlZQ== 6670
IHNpdHVhdGlvbg== 6671
ZXR0ZQ== 6672
X25v 6673
SVZF