'Ô': 'O', 'Ŕ': 'R', 'Š': 'S', 'Ť': 'T',
        'Ú': 'U', 'Ý': 'Y', 'Ž': 'Z'
    };
    const POLISH_MAP = {
        'ą': 'a', 'ć': 'c', 'ę': 'e', 'ł': 'l', 'ń': 'n', 'ó': 'o', 'ś': 's',
        'ź': 'z', 'ż': 'z',
        'Ą': 'A', 'Ć': 'C', 'Ę': 'E', 'Ł': 'L', 'Ń': 'N', 'Ó': 'O', 'Ś': 'S',
        'Ź': 'Z', 'Ż': 'Z'
    };
    const LATVIAN_MAP = {
        'ā': 'a', 'č': 'c', 'ē': 'e', 'ģ': 'g', 'ī': 'i', 'ķ': 'k', 'ļ': 'l',
        'ņ': 'n', 'š': 's', 'ū': 'u', 'ž': 'z',
        'Ā': 'A', 'Č': 'C', 'Ē': 'E', 'Ģ': 'G', 'Ī': 'I', 'Ķ': 'K', 'Ļ': 'L',
        'Ņ': 'N', 'Š': 'S', 'Ū': 'U', 'Ž': 'Z'
    };
    const ARABIC_MAP = {
        'أ': 'a', 'ب': 'b', 'ت': 't', 'ث': 'th', 'ج': 'g', 'ح': 'h', 'خ': 'kh', 'د': 'd',
        'ذ': 'th', 'ر': 'r', 'ز': 'z', 'س': 's', 'ش': 'sh', 'ص': 's', 'ض': 'd', 'ط': 't',
        'ظ': 'th', 'ع': 'aa', 'غ': 'gh', 'ف': 'f', 'ق': 'k', 'ك': 'k', 'ل': 'l', 'م': 'm',
        'ن': 'n', 'ه': 'h', 'و': 'o', 'ي': 'y'
    };
    const LITHUANIAN_MAP = {
        'ą': 'a', 'č': 'c', 'ę': 'e', 'ė': 'e', 'į': 'i', 'š': 's', 'ų': 'u',
        'ū': 'u', 'ž': 'z',
        'Ą': 'A', 'Č': 'C', 'Ę': 'E', 'Ė': 'E', 'Į': 'I', 'Š': 'S', 'Ų': 'U',
        'Ū': 'U', 'Ž': 'Z'
    };
    const SERBIAN_MAP = {
        'ђ': 'dj', 'ј': 'j', 'љ': 'lj', 'њ': 'nj', 'ћ': 'c', 'џ': 'dz',
        'đ': 'dj', 'Ђ': 'Dj', 'Ј': 'j', 'Љ': 'Lj', 'Њ': 'Nj', 'Ћ': 'C',
        'Џ': 'Dz', 'Đ': 'Dj'
    };
    const AZERBAIJANI_MAP = {
        'ç': 'c', 'ə': 'e', 'ğ': 'g', 'ı': 'i', 'ö': 'o', 'ş': 's', 'ü': 'u',
        'Ç': 'C', 'Ə': 'E', 'Ğ': 'G', 'İ': 'I', 'Ö': 'O', 'Ş': 'S', 'Ü': 'U'
    };
    const GEORGIAN_MAP = {
        'ა': 'a', 'ბ': 'b', 'გ': 'g', 'დ': 'd', 'ე': 'e', 'ვ': 'v', 'ზ': 'z',
        'თ': 't', 'ი': 'i', 'კ': 'k', 'ლ': 'l',


ounded-md shadow-lg">

                            {`${payload[0].name} : R$ ${payload[0].value.toFixed(2)} (${(payload[0].percent * 100).toFixed(2)}%)`}

                );
            }
            return null;
        };

        return (

                        <PieIcon size={20} className="mr-2 text-blue-500" />Distribuição da Carteira

                    {distributionData.length > 0 ? (
                        <ResponsiveContainer width="100%" height={250}>
                            <PieChart>
                                <Pie data={distributionData} dataKey="value" nameKey="name" cx="50%" cy="50%" outerRadius={80} label>
                                    {distributionData.map((_, i) => (
                                        <Cell key={`cell-${i}`} fill={COLORS[i % COLORS.length]} />
                                    ))}
                                </Pie>
                                <Tooltip content={<CustomTooltip />} />
                                <Legend />
                            </PieChart>
                        </ResponsiveContainer>
                    ) : (

Sem dados para exibir

                    )}

                        <BrainCircuit size={20} className="mr-2 text-indigo-500" />Alocação Ideal (Sugestão)

                    <ResponsiveContainer width="100%" height={250}>
                        <PieChart>
                            <Pie data={idealDistributionData} dataKey="value" nameKey="name" cx="50%" cy="50%" outerRadius={80} label>
                                {idealDistributionData.map((_, i) => (
                                    <Cell key={`cell-ideal-${i}`} fill={COLORS[i % COLORS.length]} />
                                ))}
                            </Pie>
                            <Tooltip formatter={(v) => `${v}%`} />
                            <Legend />
                        </PieChart>
                    </ResponsiveContainer>

        );
    };

    return (

Resumo Financeiro

                <MetricCard title="Custo da Carteira" value={totalInvested} icon={Briefcase} colorClass="text-blue-500" />
                <MetricCard title="Valor Atual" value={totalCurrentValue} icon={BarChart2} colorClass="text-indigo-500" />
                <MetricCard title="Dividendos Recebidos" value={summary.totalDividends} icon={DollarSign} colorClass="text-cyan-500" />
                <MetricCard title="Lucro Não Realizado" value={unrealizedProfit} icon={TrendingUp} colorClass="text-green-500" />
                <MetricCard title="Lucro Realizado" value={summary.realizedGains} icon={T


e_pre_slc_blk]
	ldr	x11, [x22, :lo12:p_sys_spare_buf]
	ldrh	w10, [x27, :lo12:gSysInfo]
	ldr	x9, [x21, :lo12:p_sys_data_buf]
	and	w8, w8, #0xffff
	sub	w12, w12, #1                    // =1
	stur	x11, [x24, #12]
	orr	w11, w8, w10, lsl #10
	cmp	w12, w8
	stur	x9, [x24, #4]
	str	w11, [x24]
	b.gt	.LBB31_13
// %bb.9:                               //   in Loop: Header=BB31_8 Depth=2
	adrp	x9, gSysInfo+2
	adrp	x8, gSysFreeQueue+6
	add	x9, x9, :lo12:gSysInfo+2
	ldrh	w8, [x8, :lo12:gSysFreeQueue+6]
	ldrh	w28, [x9, #2]
	strh	w10, [x9, #2]
	strh	wzr, [x9]
	cbz	w8, .LBB31_31
// %bb.10:                              //   in Loop: Header=BB31_8 Depth=2
	adrp	x11, gSysFreeQueue
	add	x11, x11, :lo12:gSysFreeQueue
	ldrh	w9, [x11, #2]
	mov	x24, x26
	mov	x26, x19
	mov	x19, x25
	add	x10, x11, x9, lsl #1
	mov	x25, x22
	sub	w8, w8, #1                      // =1
	ldrh	w22, [x10, #8]
	adrp	x10, req_erase
	strh	w8, [x11, #6]
	add	w8, w9, #1                      // =1
	ldr	x9, [x10, :lo12:req_erase]
	mov	x20, x23
	mov	x23, x21
	and	w8, w8, #0x3ff
	lsl	w21, w22, #10
	strh	w8, [x11, #2]
	str	w21, [x9, #4]
	ldr	x0, [x10, :lo12:req_erase]
	mov	w2, #1
	bl	FlashEraseBlocks
	adrp	x9, g_totle_sys_slc_erase_count
	ldr	w8, [x9, :lo12:g_totle_sys_slc_erase_count]
	mov	w10, #65535
	cmp	w22, w10
	add	w8, w8, #1                      // =1
	str	w8, [x9, :lo12:g_totle_sys_slc_erase_count]
	b.eq	.LBB31_32
// %bb.11:                              //   in Loop: Header=BB31_8 Depth=2
	cbz	w22, .LBB31_32
// %bb.12:                              //   in Loop: Header=BB31_8 Depth=2
	adrp	x10, g_GlobalSysVersion
	ldr	w8, [x10, :lo12:g_GlobalSysVersion]
	adrp	x9, gSysInfo
	add	x9, x9, :lo12:gSysInfo
	strh	w22, [x9]
	str	w8, [x9, #8]
	add	w9, w8, #1                      // =1
	str	w9, [x10, :lo12:g_GlobalSysVersion]
	ldr	x9, [sp, #8]                    // 8-byte Folded Reload
	adrp	x11, req_sys+4
	str	w21, [x11, :lo12:req_sys+4]
	mov	x21, x23
	str	w8, [x9, #4]
	strh	w22, [x9, #2]
	ldr	x


 0E01 ÷	#  × [0.3] EXCLAMATION MARK (EX) ÷ [999.0] THAI CHARACTER KO KAI (SA_AL) ÷ [0.3]
× 0021 × 0020 ÷ 0E01 ÷	#  × [0.3] EXCLAMATION MARK (EX) × [7.01] SPACE (SP) ÷ [18.0] THAI CHARACTER KO KAI (SA_AL) ÷ [0.3]
× 0021 × 0308 ÷ 0E01 ÷	#  × [0.3] EXCLAMATION MARK (EX) × [9.0] COMBINING DIAERESIS (CM1_CM) ÷ [999.0] THAI CHARACTER KO KAI (SA_AL) ÷ [0.3]
× 0021 × 0308 × 0020 ÷ 0E01 ÷	#  × [0.3] EXCLAMATION MARK (EX) × [9.0] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) ÷ [18.0] THAI CHARACTER KO KAI (SA_AL) ÷ [0.3]
× 0021 × 3041 ÷	#  × [0.3] EXCLAMATION MARK (EX) × [21.03] HIRAGANA LETTER SMALL A (CJ_NS) ÷ [0.3]
× 0021 × 0020 ÷ 3041 ÷	#  × [0.3] EXCLAMATION MARK (EX) × [7.01] SPACE (SP) ÷ [18.0] HIRAGANA LETTER SMALL A (CJ_NS) ÷ [0.3]
× 0021 × 0308 × 3041 ÷	#  × [0.3] EXCLAMATION MARK (EX) × [9.0] COMBINING DIAERESIS (CM1_CM) × [21.03] HIRAGANA LETTER SMALL A (CJ_NS) ÷ [0.3]
× 0021 × 0308 × 0020 ÷ 3041 ÷	#  × [0.3] EXCLAMATION MARK (EX) × [9.0] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) ÷ [18.0] HIRAGANA LETTER SMALL A (CJ_NS) ÷ [0.3]
× 00A0 × 0023 ÷	#  × [0.3] NO-BREAK SPACE (GL) × [12.0] NUMBER SIGN (AL) ÷ [0.3]
× 00A0 × 0020 ÷ 0023 ÷	#  × [0.3] NO-BREAK SPACE (GL) × [7.01] SPACE (SP) ÷ [18.0] NUMBER SIGN (AL) ÷ [0.3]
× 00A0 × 0308 × 0023 ÷	#  × [0.3] NO-BREAK SPACE (GL) × [9.0] COMBINING DIAERESIS (CM1_CM) × [12.0] NUMBER SIGN (AL) ÷ [0.3]
× 00A0 × 0308 × 0020 ÷ 0023 ÷	#  × [0.3] NO-BREAK SPACE (GL) × [9.0] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) ÷ [18.0] NUMBER SIGN (AL) ÷ [0.3]
× 00A0 × 2014 ÷	#  × [0.3] NO-BREAK SPACE (GL) × [12.0] EM DASH (B2) ÷ [0.3]
× 00A0 × 0020 ÷ 2014 ÷	#  × [0.3] NO-BREAK SPACE (GL) × [7.01] SPACE (SP) ÷ [18.0] EM DASH (B2) ÷ [0.3]
× 00A0 × 0308 × 2014 ÷	#  × [0.3] NO-BREAK SPACE (GL) × [9.0] COM


// characteristics of this timer.  Modifies a [`MaxTimerKey`]
/// variable or structure member provided by the caller, which should
/// be initialised with `MaxTimerKey::default()`.  If the timer key
/// currently in the variable is invalid or expired, then a new timer
/// is created using the call-args following, and the key stored in
/// the variable.  Otherwise the timer contained in the variable is
/// updated with the provided expiry time, and the call-args are
/// ignored.  If necessary, the timer may be deleted using
/// [`Core::timer_max_del`].
///
/// The syntax of the calls is identical to [`lazy!`], but with a
/// variable reference and `Instant` argument first.
///
/// ```ignore
/// let mut var = MaxTimerKey::default();
///   :::
/// timer_max!(&mut var, instant, ...args-as-for-lazy-macro...);
/// ```
///
/// Implemented using [`Core::timer_max_upd`],
/// [`Core::timer_max_add`], [`Actor::apply`] and
/// [`Actor::apply_prep`].
///
/// [`Actor::apply_prep`]: struct.Actor.html#method.apply_prep
/// [`Actor::apply`]: struct.Actor.html#method.apply
/// [`Core::timer_max_add`]: struct.Core.html#method.timer_max_add
/// [`Core::timer_max_del`]: struct.Core.html#method.timer_max_del
/// [`Core::timer_max_upd`]: struct.Core.html#method.timer_max_upd
/// [`MaxTimerKey`]: struct.MaxTimerKey.html
/// [`lazy!`]: macro.lazy.html
#[macro_export]
macro_rules! timer_max {
    ( $var:expr, $inst:expr, $($x:tt)+ ) => {{
        $crate::COVERAGE!(timer_max_0);
        let var: &mut $crate::MaxTimerKey = $var;
        let inst: std::time::Instant = $inst;
        $crate::generic_call!(timer_max_aux (var, inst) access_core; $($x)+) // Error? Try [actor, core] form
    }};
}
#[doc(hidden)]
#[macro_export]
macro_rules! timer_max_aux {
    (($var:ident, $inst:ident) $core:ident; $cb:expr) => {{
        $crate::COVERAGE!(timer_max_1);
        if !$core.timer_max_upd(*$var, $inst) {
            *$var = $core.timer_max_add($inst, $cb);
        }
    }};
}

/// Create or update a "Min" timer
///
/// A "Min" timer expires at the smallest (earliest) expiry time
/// provided.  See the [`MinTimerKey`] documentation for the
/// characteristics of this timer.  Modifies a [`MinTimerKey`]
/// variable or structure member provided by the caller, which should
/// be initialised with `MinTimerKey::default()`.  If the timer key
/// currently in the variable is invalid or expired, then a new timer
/// is created using the call-args following, and the key stored in
/// the variable.  Otherwise the timer contained in the variable is
/// updated with the provided expiry time, and the call-args are
/// ignored.  If necessary, the timer may be deleted using
/// [`Core::timer_min_del`].
///
/// The syntax of the calls is identical to [`lazy!`], but with a
/// variable reference and `Instant` argument first.
///
/// ```ignore
/// let mut var = MinTimerKey::default();
///   :::
/// timer_min!(&mut var, instant, ...args-as-for-lazy-macro...);
/// ```
///


title : 'xhtmlxtras.acronym_desc', cmd : 'mceAcronym'});
			ed.addButton('abbr', {title : 'xhtmlxtras.abbr_desc', cmd : 'mceAbbr'});
			ed.addButton('del', {title : 'xhtmlxtras.del_desc', cmd : 'mceDel'});
			ed.addButton('ins', {title : 'xhtmlxtras.ins_desc', cmd : 'mceIns'});
			ed.addButton('attribs', {title : 'xhtmlxtras.attribs_desc', cmd : 'mceAttributes'});

			ed.onNodeChange.add(function(ed, cm, n, co) {
				n = ed.dom.getParent(n, 'CITE,ACRONYM,ABBR,DEL,INS');

				cm.setDisabled('cite', co);
				cm.setDisabled('acronym', co);
				cm.setDisabled('abbr', co);
				cm.setDisabled('del', co);
				cm.setDisabled('ins', co);
				cm.setDisabled('attribs', n && n.nodeName == 'BODY');
				cm.setActive('cite', 0);
				cm.setActive('acronym', 0);
				cm.setActive('abbr', 0);
				cm.setActive('del', 0);
				cm.setActive('ins', 0);

				// Activate all
				if (n) {
					do {
						cm.setDisabled(n.nodeName.toLowerCase(), 0);
						cm.setActive(n.nodeName.toLowerCase(), 1);
					} while (n = n.parentNode);
				}
			});

			ed.onPreInit.add(function() {
				// Fixed IE issue where it can't handle these elements correctly
				ed.dom.create('abbr');
			});
		},

		getInfo : function() {
			return {
				longname : 'XHTML Xtras Plugin',
				author : 'Moxiecode Systems AB',
				authorurl : 'http://tinymce.moxiecode.com',
				infourl : 'http://wiki.moxiecode.com/index.php/TinyMCE:Plugins/xhtmlxtras',
				version : tinymce.majorVersion + "." + tinymce.minorVersion
			};
		}
	});

	// Register plugin
	tinymce.PluginManager.add('xhtmlxtras', tinymce.plugins.XHTMLXtrasPlugin);
})();(function(){var c=tinymce.DOM,a=tinymce.dom.Event,d=tinymce.each,b=tinymce.explode;tinymce.create("tinymce.plugins.TabFocusPlugin",{init:function(f,g){function e(i,j){if(j.keyCode===9){return a.cancel(j)}}function h(l,p){var j,m,o,n,k;function q(i){o=c.getParent(l.id,"form");n=o.elements;if(o){d(n,function(s,r){if(s.id==l.id){j=r;return false}});if(i>0){for(m=j+1;m<n.length;m++){if(n[m].type!="hidden"){return n[m]}}}else{for(m=j-1;m>=0;m--){if(n[m].type!="hidden"){return n[m]}}}}return null}if(p.keyCode===9){k=b(l.getParam("tab_focus",l.getParam("tabfocus_elements",":prev,:next")));if(k.length==1){k[1]=k[0];k[0]=":prev"}if(p.shiftKey){if(k[0]==":prev"){n=q(-1)}else{n=c.get(k[0])}}else{if(k[1]==":next"){n=q(1)}else{n=c.get(k[1])}}if(n){if(l=tinymce.get(n.id||n.name)){l.focus()}else{window.setTimeout(function(){window.focus();n.focus()},10)}return a.cancel(p)}}}f.onKeyUp.add(e);if(tinymce.isGecko){f.onKeyPress.add(h);f.onKeyDown.add(e)}else{f.onKeyDown.add(h)}f.onInit.add(fu


pertyName = "")
        where T : struct;

    T? GetReferenceType<T>(SettingEncryption encryption, [CallerMemberName] string propertyName = "")
        where T : class;

    void SetReferenceType<T>(T? newValue, SettingEncryption encryption, [CallerMemberName] string propertyName = "")
        where T : class;

    // Null - The setting was never set up. Useful to be filled with a default value.
    // Empty - The setting was set up as an empty list. Useful to not be filled with a default value.
    List<T>? GetListValueType<T>(SettingEncryption encryption, [CallerMemberName] string propertyName = "")
        where T : struct;

    void SetListValueType<T>(List<T>? newValue, SettingEncryption encryption, [CallerMemberName] string propertyName = "")
        where T : struct;

    List<T>? GetListReferenceType<T>(SettingEncryption encryption, [CallerMemberName] string propertyName = "")
        where T : class;

    void SetListReferenceType<T>(List<T>? newValue, SettingEncryption encryption, [CallerMemberName] string propertyName = "")
        where T : class;
}


5x2 * vk12;
      vo0p0 += vi2x2 * vk22;
      vo1p0 += vi4x2 * vk22;
      vo2p0 += vi6x2 * vk22;

      float vo0 = math_max_f32(vo0p0, vmin);
      float vo1 = math_max_f32(vo1p0, vmin);
      float vo2 = math_max_f32(vo2p0, vmin);

      vo0 = math_min_f32(vo0, vmax);
      vo1 = math_min_f32(vo1, vmax);
      vo2 = math_min_f32(vo2, vmax);

      *o2++ = vo2;
      *o1++ = vo1;
      *o0++ = vo0;
    }
    // Potentially process the last pixel.
    assert(w <= 1 * sizeof(float));
    if (w != 0) {
      const float vi0x1 = *i0++;
      const float vi1x1 = *i1++;
      const float vi2x1 = *i2++;
      const float vi3x1 = *i3++;
      const float vi4x1 = *i4++;
      const float vi5x1 = *i5++;
      const float vi6x1 = *i6++;

      float vo0p0 = vbias + vi0x0 * vk00;
      float vo1p0 = vbias + vi2x0 * vk00;
      float vo2p0 = vbias + vi4x0 * vk00;
      vo0p0 += vi1x0 * vk10;
      vo1p0 += vi3x0 * vk10;
      vo2p0 += vi5x0 * vk10;
      vo0p0 += vi2x0 * vk20;
      vo1p0 += vi4x0 * vk20;
      vo2p0 += vi6x0 * vk20;

      vo0p0 += vi0x1 * vk01;
      vo1p0 += vi2x1 * vk01;
      vo2p0 += vi4x1 * vk01;
      vo0p0 += vi1x1 * vk11;
      vo1p0 += vi3x1 * vk11;
      vo2p0 += vi5x1 * vk11;
      vo0p0 += vi2x1 * vk21;
      vo1p0 += vi4x1 * vk21;
      vo2p0 += vi6x1 * vk21;

      float vo0 = math_max_f32(vo0p0, vmin);
      float vo1 = math_max_f32(vo1p0, vmin);
      float vo2 = math_max_f32(vo2p0, vmin);

      vo0 = math_min_f32(vo0, vmax);
      vo1 = math_min_f32(vo1, vmax);
      vo2 = math_min_f32(vo2, vmax);

      *o2++ = vo2;
      *o1++ = vo1;
      *o0++ = vo0;
    }

    i0 = (const float*) ((uintptr_t) i5);
    i1 = (const float*) ((uintptr_t) i6);
    i2 = (const float*) ((uintptr_t) i1 + input_width);
    i3 = (const float*) ((uintptr_t) i2 + input_width);
    i4 = (const float*) ((uintptr_t) i3 + input_width);
    i5 = (const float*) ((uintptr_t) i4 + input_width);
    i6 = (const float*) ((uintptr_t) i5 + input_width);

    o0 = o2;
    o1 = (float*) ((uintptr_t) o0 + output_width);
    o2 = (float*) ((uintptr_t) o1 + output_width);

    output_height = doz(output_height, 3);
    padded_input_height = doz(padded_input_height, 6);
  } while (output_height != 0);
}


#nullable enable

using System;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using ObjCRuntime;
using Foundation;
using CoreFoundation;

using OS_nw_proxy_config = System.IntPtr;
using OS_nw_relay_hop = System.IntPtr;
using OS_nw_endpoint = System.IntPtr;
using OS_nw_protocol_options = System.IntPtr;

namespace Network {
	[SupportedOSPlatform ("tvos17.0")]
	[SupportedOSPlatform ("macos14.0")]
	[SupportedOSPlatform ("ios17.0")]
	[SupportedOSPlatform ("maccatalyst17.0")]
	public class NWProxyConfig : NativeObject {
		[Preserve (Conditional = true)]
		internal NWProxyConfig (NativeHandle handle, bool owns) : base (handle, owns) { }

#if !COREBUILD
		[DllImport (Constants.NetworkLibrary)]
		static extern OS_nw_proxy_config nw_proxy_config_create_relay (OS_nw_relay_hop first_hop, /* [NullAllowed] */ OS_nw_relay_hop second_hop);

		public static NWProxyConfig? CreateRelay (NWRelayHop firstHop, NWRelayHop? secondHop)
		{
			if (firstHop is null)
				ObjCRuntime.ThrowHelper.ThrowArgumentNullException (nameof (firstHop));
			var handle = nw_proxy_config_create_relay (firstHop.GetCheckedHandle (), secondHop.GetHandle ());
			GC.KeepAlive (firstHop);
			GC.KeepAlive (secondHop);
			if (handle == NativeHandle.Zero)
				return default;
			return new NWProxyConfig (handle, owns: true);
		}

		[DllImport (Constants.NetworkLibrary)]
		static unsafe extern OS_nw_proxy_config nw_proxy_config_create_oblivious_http (OS_nw_relay_hop relay, /* sbyte* */IntPtr relay_resource_path, byte* gateway_key_config, nuint gateway_key_config_length);

		public static NWProxyConfig? CreateObliviousHttp (NWRelayHop hop, string relaysResourcePath, byte [] gatewayKeyConfig)
		{
			if (hop is null)
				ObjCRuntime.ThrowHelper.ThrowArgumentNullException (nameof (hop));
			if (relaysResourcePath is null)
				ObjCRuntime.ThrowHelper.ThrowArgumentNullException (nameof (relaysResourcePath));
			if (gatewayKeyConfig is null)
				ObjCRuntime.ThrowHelper.ThrowArgumentNullException (nameof (gatewayKeyConfig));

			using var resourcePathPtr = new TransientString (relaysResourcePath);

			unsafe {
				fixed (byte* gatewayKeyConfigPointer = gatewayKeyConfig) {
					var handle = nw_proxy_config_create_oblivious_http (hop.GetCheckedHandle (), resourcePathPtr, gatewayKeyConfigPointer, (nuint) gatewayKeyConfig.Length);
					GC.KeepAlive (hop);
					if (handle == NativeHandle.Zero)
						return default;
					return new NWProxyConfig (handle, owns: true);
				}
			}
		}

		[DllImport (Constants.NetworkLibrary)]
		static extern OS_nw_proxy_config nw_proxy_config_create_http_connect (OS_nw_endpoint proxy_endpoint, /* [NullAllowed] */ OS_nw_protocol_options proxy_tls_options);

		public static NWProxyConfig? CreateHttpConnect (NWEndpoint proxyEndpoint, NWProtocolTlsOptions? options)
		{
			if (proxyEndpoint is null)
				ObjCRuntime.ThrowHelper.ThrowArgumentNullException (nameof (proxyEndpoint));

			var handle = nw_proxy_config_create_http_connect (proxyEndpoint.GetCheckedHandle (), options.GetHandle ());
			GC.KeepAlive (proxyEndpoint);
			GC.KeepAlive (options);
			if (handle == NativeHandle.Zero)
				return default;
			return new NWProxyConfig (handle, true);
		}

		[DllImport (Constants.NetworkLibrary)]
		static extern OS_nw_proxy_config nw_proxy_config_create_socksv5 (OS_nw_endpoint pro


	LFD	f19,  3 * SIZE(AO)
	bdnz	.L42
	.align 4

.L45:
	fadd	f0, f0, f4
	fadd	f1, f1, f5
	fadd	f2, f2, f6
	fadd	f3, f3, f7

#ifndef TRMMKERNEL
	andi.	r0,  K,  3
	lfd	f30, ALPHA_R
	lfd	f31, ALPHA_I
	mtspr	CTR,r0
	ble	.L47
#else
#if (defined(LEFT) && !defined(TRANSA)) || (!defined(LEFT) && defined(TRANSA))
	sub	TEMP, K, KK
#elif defined(LEFT)
	addi	TEMP, KK, 1
#else
	addi	TEMP, KK, 1
#endif
	andi.	TEMP,  TEMP,  3
	lfd	f30, ALPHA_R
	lfd	f31, ALPHA_I
	mtspr	CTR,TEMP
	ble	.L47
#endif
	.align 4

.L46:
	fmadd	f0,  f16,  f20,  f0
	fmadd	f3,  f16,  f21,  f3
	LFDU	f16, 2 * SIZE(AO)
	fmadd	f2,  f17,  f20,  f2
	LFDU	f20, 2 * SIZE(BO)
	fmadd	f1,  f17,  f21,  f1
	LFD	f17, 1 * SIZE(AO)
	LFD	f21, 1 * SIZE(BO)
	bdnz	.L46
	.align 4

.L47:
#if   defined(NN) || defined(NT) || defined(TN) || defined(TT) || \
      defined(CC) || defined(CR) || defined(RC) || defined(RR)
	fsub	f0, f0, f1
	fadd	f2, f2, f3
#elif defined(CN) || defined(CT) || defined(RN) || defined(RT)
	fadd	f0, f0, f1
	fsub	f2, f2, f3
#else
	fadd	f0, f0, f1
	fsub	f2, f3, f2
#endif

#ifndef TRMMKERNEL
	LFD	f16,  0 * SIZE(CO1)
	LFD	f17,  1 * SIZE(CO1)
#endif

#if   defined(NN) || defined(NT) || defined(TN) || defined(TT)
#ifndef TRMMKERNEL
	FMADD	f16, f30, f0, f16
	FMADD	f17, f30, f2, f17
#else
	FMUL	f16, f30, f0
	FMUL	f17, f30, f2
#endif

	FNMSUB	f16, f31, f2, f16
	FMADD	f17, f31, f0, f17

#else /* defined(CN)||defined(CT)||defined(NC)||defined(TC)||defined(CC) */
      /* defined(RN)||defined(RT)||defined(NR)||defined(TR)||defined(CR) */
      /* defined(RC) || defined(RR) */

#ifndef TRMMKERNEL
	FMADD	f16, f30, f0, f16
	FNMSUB	f17, f30, f2, f17

	FMADD	f16, f31, f2, f16
	FMADD	f17, f31, f0, f17
#else
	FMUL	f16, f


assets/img/image.png'),
        imageCircle: 8,
      ),
    ],
  );
}

@Demo(group: 'cell')
Widget _buildCard(BuildContext context) {
  return const TDCellGroup(
    theme: TDCellGroupTheme.cardTheme,
    cells: [
      TDCell(arrow: true, title: '单行标题'),
      TDCell(arrow: true, title: '单行标题', required: true),
      TDCell(arrow: true, title: '单行标题'),
    ],
  );
}

@Demo(group: 'cell')
Widget _buildPadding(BuildContext context) {
  var style = TDCellStyle(context: context);
  style.padding = const EdgeInsets.all(30);
  return TDCellGroup(
    theme: TDCellGroupTheme.cardTheme,
    cells: [
      TDCell(
        arrow: true,
        title: 'padding-all-30',
        style: style,
        onClick: (cell) {
          print('padding-all-30');
        },
      ),
    ],
  );
}

@Demo(group: 'cell')
Widget _buildTestContent(BuildContext context) {
  return const TDCell(
    title: '这是标题，非常长的标题',
    note: '这是一个很长很长的note字段，测试长内容，你说这内容长不长！',
    arrow: true,
  );
}
import 'package:flutter/cupertino.dart';
import 'package:tdesign_flutter/tdesign_flutter.dart';

import '../annotation/demo.dart';
import '../base/example_widget.dart';

class TDTreeSelectPage extends StatefulWidget {
  const TDTreeSelectPage({Key? key}) : super(key: key);

  @override
  State<StatefulWidget> createState() => _TDTreeSelectPageState();
}

class _TDTreeSelectPageState extends State<TDTreeSelectPage> {
  String? inputText;
  List<dynamic> values1 = [
    1,
    11,
  ];
  List<dynamic> values2 = [
    1,
    [11, 12, 13],
  ];
  List<dynamic> values3 = [1, 11, 111];

  @override
  Widget build(BuildContext context) {
    return ExamplePage(
      title: tdTitle(),
      desc: '适用于选择树形的数据结构',
      exampleCodeGroup: 'tree',
      children: [
        ExampleModule(
          title: '组件类型',
          children: [
            ExampleItem(desc: '基础树形选择', builder: _buildDefaultTreeSelect),
            ExampleItem(desc: '多选树形选择', builder: _buildMultipleTreeSelect),
          ],
        ),
        ExampleModule(
          title: '组件状态',
          children: [
            ExampleItem(desc: '三级树形选择', builder: _buildThirdTreeSelect),
          ],
        ),
      ],
      test: [
        ExampleItem(desc: '局部多选', builder: _buildPartMultipleTreeSelect),
        ExampleItem(desc: '局部多选', builder: _buildPartMultipleTreeSelect2),
      ],
    );
  }

  @Demo(group: 'tree')
  Widget _buildDefaultTreeSelect(BuildContext context) {
    var options = <TDSelectOption>[];

    for (var i = 1; i <= 10; i++) {
      options


0);
			HierarchicalTiledNode startNode = worldMap.getNode(startTileX, startTileY);
			HierarchicalTiledNode endNode = worldMap.getNode(tileX, tileY);
			if (forceUpdate || endNode.type == TiledNode.TILE_FLOOR) {
				if (endNode.type == TiledNode.TILE_FLOOR) {
					lastEndTileX = tileX;
					lastEndTileY = tileY;
				} else {
					endNode = worldMap.getNode(lastEndTileX, lastEndTileY);
				}

				if (metrics)
					if (PathFinderRequestControl.DEBUG)
						System.out.println("------------ Hierarchical Indexed A* Path Finder Metrics ------------");

				requestNewPathFinding(startNode, endNode, 0);
			}
		}
	}

	private void requestNewPathFinding (HierarchicalTiledNode startNode, HierarchicalTiledNode endNode, int pathIndex) {
		TiledSmoothableGraphPath<HierarchicalTiledNode> path = paths[pathIndex];

		MyPathFinderRequest pfRequest = requestPool.obtain();
		pfRequest.startNode = startNode;
		pfRequest.endNode = endNode;
		pfRequest.heuristic = heuristic;
		pfRequest.resultPath = path;
		pfRequest.pathIndex = pathIndex;
		pfRequest.responseMessageCode = PF_RESPONSE;
		MessageManager.getInstance().dispatchMessage(this, PF_REQUEST, pfRequest);
	}

	/** An {@link InputProcessor} that allows you to define a path to find.
	 *
	 * @autor davebaol */
	static class TiledHierarchicalAStarInputProcessor extends InputAdapter {
		InterruptibleHierarchicalTiledAStarTest test;

		public TiledHierarchicalAStarInputProcessor (InterruptibleHierarchicalTiledAStarTest test) {
			this.test = test;
		}

		@Override
		public boolean keyTyped (char character) {
			switch (character) {
			case 'm':
			case 'M':
				test.checkMetrics.toggle();
				break;
			case 'd':
			case 'D':
				test.checkDiagonal.toggle();
				break;
			case 's':
			case 'S':
				test.checkSmooth.toggle();
				break;
			case '-':
				test.sliderMillisAvailablePerFrame.setValue(test.sliderMillisAvailablePerFrame.getValue()
					- test.sliderMillisAvailablePerFrame.getStepSize());
				break;
			case '+':
				test.sliderMillisAvailablePerFrame.setValue(test.sliderMillisAvailablePerFrame.getValue()
					+ test.sliderMillisAvailablePerFrame.getStepSize());
				break;
			}
			return true;
		}

		@Override
		public boolean touchUp (int screenX, int screenY, int pointer, int button) {
			test.getCamera().unproject(test.tmpUnprojection.set(screenX, screenY, 0));
			int tileX = (int)(test.tmpUnprojection.x / width);
			int tileY = (int)(test.tmpUnprojection.y / width);
			test.worldMap.setLevel(0);
			HierarchicalTiledNode startNode = test.worldMap.getNode(tileX, tileY);
			if (startNode.type == TiledNode.TILE_FLOOR) {
				test.startTileX = tileX;
				test.startTileY = tileY;
				test.updatePath(true);
			}
			return true;
		}

		@Override
		public boolean mouseMoved (int screenX, int screenY) {
			test.lastScreenX = screenX;
			test.lastScreenY = screenY;
			test.updatePath(false);
			return true;
		}
	}

	class MyPathFinderRequest extends PathFinderRequest<HierarchicalTiledNode> implements Poolable {
		boolean smoothFinished;
		int pathIndex;

		public MyPathFinderRequest () {
		}

		@Override
		public boolean initializeSearch (long timeToRun) {
			resultPath.clear();
			worldMap.startNode = startNode;
			return true


3)]
#[cfg_attr(test, assert_instr(vpcmp, op = 0))]
pub unsafe fn _mm512_mask_cmp_epu32_mask(
    m: __mmask16,
    a: __m512i,
    b: __m512i,
    op: _MM_CMPINT_ENUM,
) -> __mmask16 {
    macro_rules! call {
        ($imm3:expr) => {
            vpcmpud(a.as_i32x16(), b.as_i32x16(), $imm3, m as i16)
        };
    }
    let r = constify_imm3!(op, call);
    transmute(r)
}

/// Compare packed unsigned 32-bit integers in a and b for less-than, and store the results in a mask vector.
///
/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=727,1063,4909,1062,1062&text=_mm512_cmplt_epi32)
#[inline]
#[target_feature(enable = "avx512f")]
#[cfg_attr(test, assert_instr(vpcmp))]
pub unsafe fn _mm512_cmplt_epi32_mask(a: __m512i, b: __m512i) -> __mmask16 {
    simd_bitmask::<i32x16, _>(simd_lt(a.as_i32x16(), b.as_i32x16()))
}

/// Compare packed unsigned 32-bit integers in a and b for less-than, and store the results in a mask vector k
/// using zeromask m (elements are zeroed out when the corresponding mask bit is not set).
///
/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=727,1063,4909,1062,1062,1063&text=_mm512_mask_cmplt_epi32)
#[inline]
#[target_feature(enable = "avx512f")]
#[cfg_attr(test, assert_instr(vpcmp))]
pub unsafe fn _mm512_mask_cmplt_epi32_mask(m: __mmask16, a: __m512i, b: __m512i) -> __mmask16 {
    _mm512_cmplt_epi32_mask(a, b) & m
}

/// Compare packed signed 32-bit integers in a and b for greater-than, and store the results in a mask vector.
///
/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=727,1063,4909,1062,1062&text=_mm512_cmpgt_epi32)
#[inline]
#[target_feature(enable = "avx512f")]
#[cfg_attr(test, assert_instr(vpcmp))]
pub unsafe fn _mm512_cmpgt_epi32_mask(a: __m512i, b: __m512i) -> __mmask16 {
    simd_bitmask::<i32x16, _>(simd_gt(a.as_i32x16(), b.as_i32x16()))
}

/// Compare packed signed 32-bit integers in a and b for greater-than, and store the results in a mask vector k
/// using zeromask m (elements are zeroed out when the corresponding mask bit is not set).
///
/// [Intel's documentation](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=727,1063,4909,1062,1062,1063&text=_mm512_mask_cmpgt_epi32)
#[inline]
#[target_feature(enable = "avx512f")]
#[cfg_attr(test, assert_instr(vpcmp))]
pub unsafe fn _mm512_mask_cmpgt_epi32_mask(m: __mmask16, a: __m512i, b: __m512i) -> __mmask16 {
    _mm512_cmpgt_epi32_mask(a,


https://twitter.com/lovyan03)

Contributors:
 [ciniml](https://github.com/ciniml)
 [mongonta0716](https://github.com/mongonta0716)
 [tobozo](https://github.com/tobozo)
/----------------------------------------------------------------------------*/
#include "Touch_XPT2046.hpp"

#include "../../internal/algorithm.h"
#include "../platforms/common.hpp"

namespace lgfx
{
 inline namespace v1
 {
//----------------------------------------------------------------------------

  bool Touch_XPT2046::init(void)
  {
    _inited = false;

    if (_cfg.pin_cs > -1) {
      lgfx::gpio_hi(_cfg.pin_cs);
      lgfx::pinMode(_cfg.pin_cs, lgfx::pin_mode_t::output);
    }
    if (_cfg.spi_host < 0)
    {
      pinMode(_cfg.pin_sclk, lgfx::pin_mode_t::output);
      pinMode(_cfg.pin_mosi, lgfx::pin_mode_t::output);
      pinMode(_cfg.pin_miso, lgfx::pin_mode_t::input_pullup);
    }
    else
    if (lgfx::spi::init(_cfg.spi_host, _cfg.pin_sclk, _cfg.pin_miso, _cfg.pin_mosi).has_error())
    {
      return false;
    }

    if (_cfg.pin_int >= 0)
    {
      lgfx::pinMode(_cfg.pin_int, pin_mode_t::input);
    }

    _inited = true;
    return true;
  }

  static void transfer(uint8_t* read_data, const uint8_t* write_data, size_t len, const Touch_XPT2046::config_t *cfg)
  {
    int pin_sclk = cfg->pin_sclk;
    int pin_miso = cfg->pin_miso;
    int pin_mosi = cfg->pin_mosi;

    do
    {
      uint_fast8_t r = 0;
      uint_fast8_t mask = 0x80;
      uint_fast8_t d = *write_data++;
      do
      {
        gpio_lo(pin_sclk);
        if (d & mask) { gpio_hi(pin_mosi); } else { gpio_lo(pin_mosi); }
        gpio_hi(pin_sclk);
        if (gpio_in(pin_miso)) { r += mask; }
      } while (mask >>= 1);

      *read_data++ = (uint8_t)r;
    } while (--len);
    gpio_lo(pin_sclk);
  }

  uint_fast8_t Touch_XPT2046::getTouchRaw(touch_point_t* __restrict tp, uint_fast8_t count)
  {
    if (!_inited || count == 0) return 0;

    tp->size = 0;

    if (_cfg.pin_int >= 0 && lgfx::gpio_in(_cfg.pin_int))
    {
      return 0;
    }

    uint8_t data[57];

    memset(data, 0, 8);
    data[ 0] = 0x91;
    data[ 2] = 0xB1;
    data[ 4] = 0xD1;
    data[ 6] = 0xC1;
    data[56] = 0x80; // last power off.
    memcpy(&data[ 8], data,  8);
    memcpy(&data[16], data, 16);
    memcpy(&data[32], data, 24);

    if (_cfg.spi_host < 0)
    {
      lgfx::gpio_lo(_cfg.pin_cs);
      transfer(data, data, 57, &_cfg);
      lgfx::gpio_hi(_cfg.pin_cs);
    }
    else
    {
      spi::beginTransaction(_cfg.spi_host, _cfg.freq, 0);
      if (_cfg.pin_cs > -1)
        lgfx::gpio_lo(_cfg.pin_cs);
      spi::readBytes(_cfg.spi_host, data, 57);
      if (_cfg.pin_cs > -1)
        lgfx::gpio_hi(_cfg.pin_cs);
      spi::endTransaction(_cfg.spi_host);
    }

    size_t ix = 0, iy = 0, iz = 0;
    uint_fast16_t xt[7], yt[7], zt[7];
    for (size_t j =


        super.initParams()
        if (rowb.size < buflen) rowb = ByteArray(buflen)
        if (rowbfilter == null || rowbfilter!!.size < buflen) rowbfilter = ByteArray(buflen)
        if (rowbprev == null || rowbprev!!.size < buflen) rowbprev = ByteArray(buflen) else fill(rowbprev!!, 0.toByte())

        // if adaptative but too few rows or columns, use default
        if (imgInfo.cols < 3 && !FilterType.isValidStandard(filterType)) filterType = FilterType.FILTER_DEFAULT
        if (imgInfo.rows < 3 && !FilterType.isValidStandard(filterType)) filterType = FilterType.FILTER_DEFAULT
        if (imgInfo.totalPixels <= 1024 && !FilterType.isValidStandard(filterType)) filterType = defaultFilter
        if (FilterType.isAdaptive(filterType)) {
            // adaptCurSkip = 0;
            adaptNextRow = 0
            if (filterType === FilterType.FILTER_ADAPTIVE_FAST) {
                adaptMaxSkip = 200
                adaptSkipIncreaseSinceRow = 3
                adaptSkipIncreaseFactor = 1 / 4.0 // skip ~ row/3
            } else if (filterType === FilterType.FILTER_ADAPTIVE_MEDIUM) {
                adaptMaxSkip = 8
                adaptSkipIncreaseSinceRow = 32
                adaptSkipIncreaseFactor = 1 / 80.0
            } else if (filterType === FilterType.FILTER_ADAPTIVE_FULL) {
                adaptMaxSkip = 0
                adaptSkipIncreaseSinceRow = 128
                adaptSkipIncreaseFactor = 1 / 120.0
            } else throw PngjOutputException("bad filter $filterType")
        }
    }

    override fun filterAndWrite(rowb: ByteArray) {
        require(rowb.contentEquals(this.rowb)) { "??" } // we rely on this

        decideCurFilterType()
        val filtered: ByteArray = filterRowWithFilterType(curfilterType!!, rowb, rowbprev!!, rowbfilter!!)
        sendToCompressedStream(filtered)
        // swap rowb <-> rowbprev
        val aux = this.rowb
        this.rowb = rowbprev!!
        rowbprev = aux
    }

    private fun decideCurFilterType() {
        // decide the real filter and store in curfilterType
        if (FilterType.isValidStandard(filterType)) {
            curfilterType = filterType
        } else if (filterType === FilterType.FILTER_PRESERVE) {
            curfilterType = FilterType.getByVal(rowb[0].toInt())
        } else if (filterType === FilterType.FILTER_CYCLIC) {
            curfilterType = FilterType.getByVal(currentRow % 5)
        } else if (filterType === FilterType.FILTER_DEFAULT) {
            filterType = defaultFilter
            curfilterType = filterType // this could be done once
        } else if (FilterType.isAdaptive(filterType)) { // adaptive
            if (currentRow == adaptNextRow) {
                for (ftype in FilterType.allStandard) filtersPerformance.updateFromRaw(
                    ftype,
                    rowb,
                    rowbprev,
                    currentRow
                )
                curfilterType = filtersPerformance.preferred
                var skip =
                    if (currentRow >= adaptSkipIncreaseSinceRow) round((currentRow - adaptSkipIncreaseSinceRow) * adaptSkipIncreaseFactor)
                        .toInt() else 0
                if (skip > adaptMaxSkip) skip = adaptMaxSkip
                if (currentRow == 0) skip = 0
                adaptNextRow = currentRow + 1 + skip
            }
        } else {
            throw PngjOutputException("not implemented filter: $filterType")
        }
        if (currentRow == 0 && curfilterType !== FilterType.FILTER_NONE && curfilterType !== FilterType.FILTER_SUB) curfilterType =
            FilterType.FILTER_SUB


p Game Developers search the right tool for the job, learn about new technologies, or discover new and fun Game Engines to use and get inspired by.
- [The Generous Space of Alternative Game Engines (A Curation)](http://www.nathalielawhead.com/candybox/the-generous-space-of-alternative-game-engines-a-curation)

## Html5 Game Engine
- [HTML5 Game Engines](https://html5gameengine.com/): Listed are the cream of the crop of HTML5 / JavaScript game engines - frameworks that are respected and maintained. Click "More Details" for a full description, reviews, important links, and sample games.
- [What are the best HTML5/JavaScript frameworks for web-based games?](https://www.slant.co/topics/973/~best-html5-javascript-frameworks-for-web-based-games)
- [2016年最火的15款HTML5游戏引擎](http://www.oschina.net/news/72092/2016-top-15-html5-game-engines)
- [HTML5游戏引擎深度测评](http://www.jianshu.com/p/0469cd7b1711)

### recommend
- [[phaser]], [[godot]], [[cocos-creator]]
- [libGDX](https://github.com/libGDX/libGDX) is a cross-platform Java game development framework based on OpenGL (ES) that works on Windows, Linux, Mac OS X, Android, your WebGL enabled browser and iOS. [awesome-libgdx](https://github.com/rafaskb/awesome-libgdx)
- [Babylon.js](https://github.com/BabylonJS/Babylon.js) is a powerful, beautiful, simple, and open game and rendering engine packed into a friendly JavaScript framework.
- [PlayCanvas](https://github.com/playcanvas/engine) is an open-source game engine. It uses HTML5 and WebGL to run games and other interactive 3D content in any mobile or desktop browser.

### proprietary
- [Stencyl](http://www.stencyl.com/) Create Flash, HTML5, iOS, Android, Mac, Windows and Linux games with no code with Stencyl.
  - This is [the source](https://github.com/Stencyl/stencyl-engine) to Stencyl's Haxe-based game engine.

### others
- inactive: [[egret]], ~~[[layabox]]~~

## 2D Game Engine
- [What are the best 2D game engines?](https://www.slant.co/topics/341/~best-2d-game-engines)

### recommend
- Moderate
  - [[godot]], [[cocos creator]]/[[cocos2d-x]], [[phaser]]
  - [libGDX](https://github.com/libGDX/libGDX)
  - [[Defold]]
- Lightweight
  - [[love2d]], [[pygame]]

### proprietary
- [Stencyl](http://www.stencyl.com/)
- [GameMaker Studio](https://www.yoyogames.com/) 2 is a tool designed to empower you and your team to make new and innovative games as well as prototype ideas in the fastest and most intuitive way possible across multiple target platforms.
- [Construct 3](https://www.construct.net/en) is the best software to create games. Over 100,000 users monthly make & sell thousands of games globally. - [Awesome Construct](https://github.com/WebCreationClub/awesome-construct)

### others
- [[ejoy2d]]: inactive
- [GDevelop](https://github.com/4ian/GDevelop) is an open-source, cross-platform game engine designed to be used by everyone. https://gdevelop-app.com
- [Orx](https://github.com/orx/orx) is a 2.5D data-driven game development engine. It is open source, ultra-fast, multi-platform and full-featured for C/C++ programmers: beginners and experts alike. http://orx-project.org
- [Gideros](https://github.com/gideros/gideros) is a cross-platform development environment for creating amazing games and interactive applications in 2D or 3D. It is easy to pick up, quick to develop and robust to deploy. Code your game once and deploy to Android, iOS, MacOS, tvOS, Windows, HTML 5 and more. - [Awesome Gideros](https://github.com/stetso/awesome-gideros)

## 3D Game Engine
- [What are the best 3D game engines?](https://www.slant.co/topics/1495/~


   constructor(){super({ uniqueName:"念", info:"ランダムな一体に過去攻撃",
                              type:TecType.過去, targetings:Targeting.RANDOM,
                              mul:1, num:1, hit:1.2, mp:1,
        });}
    }
    export const                          メテオ:ActiveTec = new class extends ActiveTec{
        constructor(){super({ uniqueName:"メテオ", info:"ランダムに4～6回過去攻撃",
                              type:TecType.過去, targetings:Targeting.RANDOM,
                              mul:1, num:4, hit:1.2, ep:1,
        });}
        rndAttackNum = ()=> randomInt(4,6);
    }
    //--------------------------------------------------------------------------
    //
    //過去Passive
    //
    //--------------------------------------------------------------------------
    export const                         ネガティヴフィードバック:PassiveTec = new class extends PassiveTec{
        constructor(){super({uniqueName:"ネガティヴフィードバック", info:"過去攻撃時　状態異常一つにつき、消費MPの10%を還元",
                                type:TecType.過去,
        });}
        async beforeDoAtk(action:Action, attacker:Unit, target:Unit, dmg:Dmg){
            if(action instanceof ActiveTec && (action.type === TecType.過去)){
                let num = ConditionType.badConditions()
                                        .filter(type=> attacker.existsCondition(type))
                                        .length;
                if(num === 0){return;}
                Unit.healMP( attacker, action.mpCost * 0.1 * num);
            }
        }
    };
    //--------------------------------------------------------------------------
    //
    //銃術Active
    //
    //--------------------------------------------------------------------------
    export const                          撃つ:ActiveTec = new class extends ActiveTec{
        constructor(){super({ uniqueName:"撃つ", info:"ランダムに銃術攻撃2回",
                              type:TecType.銃術, targetings:Targeting.RANDOM,
                              mul:1, num:2, hit:0.8,
        });}
    }
    export const                          二丁拳銃:ActiveTec = new class extends ActiveTec{
        constructor(){super({ uniqueName:"二丁拳銃", info:"一体に銃術攻撃2回",
                              type:TecType.銃術, targetings:Targeting.RANDOM,
                              mul:1, num:2, hit:0.8, tp:1,
        });}
    }
    export const                          あがらない雨:ActiveTec = new class extends ActiveTec{
        constructor(){super({ uniqueName:"あがらない雨", info:"全体に銃術攻撃2回",
                              type:TecType.銃術, targetings:Targeting.ALL,
                              mul:1, num:2, hit:0.7, ep:1,
        });}
    }
    export const                          ショットガン:ActiveTec = new class extends ActiveTec{
        constructor(){super({ uniqueName:"ショットガン", info:"ランダムに銃術攻撃4回x0.7",
                              type:TecType.銃術, targetings:Targeting.RANDOM,
                              mul:0.7, num:4, hit:0.8,
                              item:()=>[[Item.散弾, 1]],
        });}
    }
    //--------------------------------------------------------------------------
    //
    //銃術Passive
    //
    //--------------------------------------------------------------------------
    export const                         テーブルシール


	recommendations:     []timestampedRecommendation{},
		expectedConditions: []autoscalingv2.HorizontalPodAutoscalerCondition{
			{Type: autoscalingv2.AbleToScale, Status: v1.ConditionTrue, Reason: "SucceededGetScale"},
			{Type: autoscalingv2.ScalingActive, Status: v1.ConditionFalse, Reason: "InvalidMetricSourceType"},
		},
		expectedReportedReconciliationActionLabel: monitor.ActionLabelNone,
		expectedReportedReconciliationErrorLabel:  monitor.ErrorLabelInternal,
		expectedReportedMetricComputationActionLabels: map[autoscalingv2.MetricSourceType]monitor.ActionLabel{
			autoscalingv2.ResourceMetricSourceType: monitor.ActionLabelScaleDown,
			"CheddarCheese":                        monitor.ActionLabelNone,
		},
		expectedReportedMetricComputationErrorLabels: map[autoscalingv2.MetricSourceType]monitor.ErrorLabel{
			autoscalingv2.ResourceMetricSourceType: monitor.ErrorLabelNone,
			"CheddarCheese":                        monitor.ErrorLabelSpec,
		},
	}

	tc.runTest(t)
}

func TestNoScaleDownOneMetricEmpty(t *testing.T) {
	tc := testCase{
		minReplicas:             2,
		maxReplicas:             6,
		specReplicas:            5,
		statusReplicas:          5,
		expectedDesiredReplicas: 5,
		CPUTarget:               50,
		metricsTarget: []autoscalingv2.MetricSpec{
			{
				Type: autoscalingv2.ExternalMetricSourceType,
				External: &autoscalingv2.ExternalMetricSource{
					Metric: autoscalingv2.MetricIdentifier{
						Name:     "qps",
						Selector: &metav1.LabelSelector{},
					},
					Target: autoscalingv2.MetricTarget{
						Type:  autoscalingv2.ValueMetricType,
						Value: resource.NewMilliQuantity(1000, resource.DecimalSI),
					},
				},
			},
		},
		reportedLevels:      []uint64{100, 300, 500, 250, 250},
		reportedCPURequests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
		useMetricsAPI:       true,
		recommendations:     []timestampedRecommendation{},
		expectedConditions: []autoscalingv2.HorizontalPodAutoscalerCondition{
			{Type: autoscalingv2.AbleToScale, Status: v1.ConditionTrue, Reason: "SucceededGetScale"},
			{Type: autoscalingv2.ScalingActive, Status: v1.ConditionFalse, Reason: "FailedGetExternalMetric"},
		},
		expectedReportedReconciliationActionLabel: monitor.ActionLabelNone,
		expectedReportedReconciliationErrorLabel:  monitor.ErrorLabelInternal,
		expectedReportedMetricComputationActionLabels: map[autoscalingv2.MetricSourceType]monitor.ActionLabel{
			autoscalingv2.ResourceMetricSourceType: monitor.ActionLabelScaleDown,
			autoscalingv2.ExternalMetricSourceType: monitor.ActionLabelNone,
		},
		expectedReportedMetricComputationErrorLabels: map[autoscalingv2.MetricSourceType]monitor.ErrorLabel{
			autoscalingv2.ResourceMetricSourceType: monitor.ErrorLabelNone,
			autoscalingv2.ExternalMetricSourceType: monitor.ErrorLabelInternal,
		},
	}
	_, _, _, testEMClient, _ := tc.prepareTestClient(t)
	testEMClient.PrependReactor("list", "*", func(action core.Action) (handled bool, ret runtime.Object, err error) {
		return true, &emapi.ExternalMe


il", methodName, got)
		}
		return resp, err
	})
}

func TestDependency_Marshal(t *testing.T) {
	t.Parallel()
	testJSONMarshal(t, &Dependency{}, "{}")

	h := &Dependency{
		Package: &VulnerabilityPackage{
			Ecosystem: Ptr("pip"),
			Name:      Ptr("django"),
		},
		ManifestPath: Ptr("path/to/requirements.txt"),
		Scope:        Ptr("runtime"),
	}

	want := `{
		"package": {
        "ecosystem": "pip",
        "name": "django"
      },
      "manifest_path": "path/to/requirements.txt",
      "scope": "runtime"
	}`

	testJSONMarshal(t, h, want)
}

func TestAdvisoryCVSS_Marshal(t *testing.T) {
	t.Parallel()
	testJSONMarshal(t, &AdvisoryCVSS{}, "{}")

	h := &AdvisoryCVSS{
		Score:        Ptr(7.5),
		VectorString: Ptr("CVSS:3.0/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N"),
	}

	want := `{
		"vector_string": "CVSS:3.0/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N",
        "score": 7.5
	}`

	testJSONMarshal(t, h, want)
}

func TestAdvisoryCWEs_Marshal(t *testing.T) {
	t.Parallel()
	testJSONMarshal(t, &AdvisoryCWEs{}, "{}")

	h := &AdvisoryCWEs{
		CWEID: Ptr("CWE-200"),
		Name:  Ptr("Exposure of Sensitive Information to an Unauthorized Actor"),
	}

	want := `{
		"cwe_id": "CWE-200",
		"name": "Exposure of Sensitive Information to an Unauthorized Actor"
	}`

	testJSONMarshal(t, h, want)
}

func TestDependabotSecurityAdvisory_Marshal(t *testing.T) {
	t.Parallel()
	testJSONMarshal(t, &DependabotSecurityAdvisory{}, "{}")

	publishedAt, _ := time.Parse(time.RFC3339, "2018-10-03T21:13:54Z")
	updatedAt, _ := time.Parse(time.RFC3339, "2022-04-26T18:35:37Z")

	h := &DependabotSecurityAdvisory{
		GHSAID:      Ptr("GHSA-rf4j-j272-fj86"),
		CVEID:       Ptr("CVE-2018-6188"),
		Summary:     Ptr("Django allows remote attackers to obtain potentially sensitive information by leveraging data exposure from the confirm_login_allowed() method, as demonstrated by discovering whether a user account is inactive"),
		Description: Ptr("django.contrib.auth.forms.AuthenticationForm in Django 2.0 before 2.0.2, and 1.11.8 and 1.11.9, allows remote attackers to obtain potentially sensitive information by leveraging data exposure from the confirm_login_allowed() method, as demonstrated by discovering whether a user account is inactive."),
		Vulnerabilities: []*AdvisoryVulnerability{
			{
				Package: &VulnerabilityPackage{
					Ecosystem: Ptr("pip"),
					Name:      Ptr("django"),
				},
				Severity:               Ptr("high"),
				VulnerableVersionRange: Ptr(">= 2.0.0, < 2.0.2"),
				FirstPatchedVersion:    &FirstPatchedVersion{Identifier: Ptr("2.0.2")},
			},
			{
				Package: &VulnerabilityPackage{
					Ecosystem: Ptr("pip"),
					Name:      Ptr("django"),
				},
				Severity:               Ptr("high"),
				VulnerableVersionRange:


ch key, the values in both maps compare equal. Elements are
   * compared as per normal Ruby semantics, by calling their :== methods (or
   * performing a more efficient comparison for primitive types).
   *
   * Maps with dissimilar key types or value types/typeclasses are never equal,
   * even if value comparison (for example, between integers and floats) would
   * have otherwise indicated that every element has equal value.
   */
  @JRubyMethod(name = "==")
  public IRubyObject eq(ThreadContext context, IRubyObject _other) {
    if (_other instanceof RubyHash) return singleLevelHash(context).op_equal(context, _other);
    RubyMap other = (RubyMap) _other;
    if (this == other) return context.runtime.getTrue();
    if (!typeCompatible(other) || this.table.size() != other.table.size())
      return context.runtime.getFalse();
    for (IRubyObject key : table.keySet()) {
      if (!other.table.containsKey(key)) return context.runtime.getFalse();
      if (!other.table.get(key).equals(table.get(key))) return context.runtime.getFalse();
    }
    return context.runtime.getTrue();
  }

  /*
   * call-seq:
   *     Map.inspect => string
   *
   * Returns a string representing this map's elements. It will be formatted as
   * "{key => value, key => value, ...}", with each key and value string
   * representation computed by its own #inspect method.
   */
  @JRubyMethod
  public IRubyObject inspect() {
    return singleLevelHash(getRuntime().getCurrentContext()).inspect();
  }

  /*
   * call-seq:
   *     Map.hash => hash_value
   *
   * Returns a hash value based on this map's contents.
   */
  @JRubyMethod
  public IRubyObject hash(ThreadContext context) {
    try {
      MessageDigest digest = MessageDigest.getInstance("SHA-256");
      for (IRubyObject key : table.keySet()) {
        digest.update((byte) key.hashCode());
        digest.update((byte) table.get(key).hashCode());
      }
      return context.runtime.newFixnum(ByteBuffer.wrap(digest.digest()).getLong());
    } catch (NoSuchAlgorithmException ignore) {
      return context.runtime.newFixnum(System.identityHashCode(table));
    }
  }

  /*
   * call-seq:
   *     Map.keys => [list_of_keys]
   *
   * Returns the list of keys contained in the map, in unspecified order.
   */
  @JRubyMethod
  public IRubyObject keys(ThreadContext context) {
    return RubyArray.newArray(context.runtime, table.keySet());
  }

  /*
   * call-seq:
   *     Map.values => [list_of_values]
   *
   * Returns the list of values contained in the map, in unspecified order.
   */
  @JRubyMethod
  public IRubyObject values(ThreadContext context) {
    return RubyArray.newArray(context.runtime, table.values());
  }

  /*
   * call-seq:
   *     Map.clear
   *
   * Removes all entries from the map.
   */
  @JRubyMethod
  public IRubyObject clear(ThreadContext context) {
    checkFrozen();
    table.clear();
    return context.nil;
  }

  /*
   * call-seq:
   *     Map.each(&block)
   *
   * Invokes &block on each |key, value| pair in the map, in unspecified order.
   * Note that Map also includes Enumerable; map thus acts like a normal Ruby
   * sequence.
   */
  @JRubyMethod
  public IRubyObject each(ThreadContext context, Block block) {
    for (IRubyObject key : table.keySet()) {
      block.yieldSpecific(context, key, table.get(key));
    }
    return context.nil;


 o, i = [], a = this.value, s = "undefined" !== typeof e.n, u = 0; u < a.length; u++) 1 === a[u].type ? i.push({
                    value: a[u].value,
                    type: 1
                }) : 3 === a[u].type ? i.push({
                    value: e[a[u].value],
                    type: 1
                }) : 0 === a[u].type ? "undefined" === typeof i[i.length - 1].type ? i[i.length - 1].value.push(a[u]) : i[i.length - 1].value = a[u].value(i[i.length - 1].value) : 7 === a[u].type ? "undefined" === typeof i[i.length - 1].type ? i[i.length - 1].value.push(a[u]) : i[i.length - 1].value = a[u].value(i[i.length - 1].value) : 8 === a[u].type ? (t = i.pop(), n = i.pop(), i.push({
                    type: 1,
                    value: a[u].value(n.value, t.value)
                })) : 10 === a[u].type ? (t = i.pop(), "undefined" === typeof(n = i.pop()).type ? (n.value = n.concat(t), n.value.push(a[u]), i.push(n)) : "undefined" === typeof t.type ? (t.unshift(n), t.push(a[u]), i.push(t)) : i.push({
                    type: 1,
                    value: a[u].value(n.value, t.value)
                })) : 2 === a[u].type || 9 === a[u].type ? (t = i.pop(), "undefined" === typeof(n = i.pop()).type ? (console.log(n), (n = n.concat(t)).push(a[u]), i.push(n)) : "undefined" === typeof t.type ? (t.unshift(n), t.push(a[u]), i.push(t)) : i.push({
                    type: 1,
                    value: a[u].value(n.value, t.value)
                })) : 12 === a[u].type ? ("undefined" !== typeof(t = i.pop()).type && (t = [t]), n = i.pop(), o = i.pop(), i.push({
                    type: 1,
                    value: a[u].value(o.value, n.value, new r(t))
                })) : 13 === a[u].type && (s ? i.push({
                    value: e[a[u].value],
                    type: 3
                }) : i.push([a[u]]));
                if (i.length > 1) throw new r.exception("Uncaught Syntax error");
                return i[0].value > 1e15 ? "Infinity" : parseFloat(i[0].value.toFixed(15))
            }, r.eval = function(e, t, n) {
                return "undefined" === typeof t ? this.lex(e).toPostfix().postfixEval() : "undefined" === typeof n ? "undefined" !== typeof t.length ? this.lex(e, t).toPostfix().postfixEval() : this.lex(e).toPostfix().postfixEval(t) : this.lex(e, t).toPostfix().postfixEval(n)
            }, e.exports = r
        },
        "./node_modules/mdurl/decode.js": function(e, t, n) {
            "use strict";
            var r = {};

            function o(e, t) {
                var n;
                return "string" !== typeof t && (t = o.defaultChars), n = function(e) {
                    var t, n, o = r[e];
                    if (o) return o;
                    for (o = r[e] = [], t = 0; t < 128


uction coefficients:
 * log(2) inverted = 2^k/ln2 */
gnu_double_vector __dbInvLn2 0x40971547652b82fe

/* right-shifter value = 3*2^52 */
gnu_double_vector __dbShifter 0x4338000000000000

/* log(2) high part = ln2/2^k(52-k-9 hibits) */
gnu_double_vector __dbLn2hi 0x3f462e42fec00000

/* log(2) low part = ln2/2^k(52-k-9..104-k-9 lobits) */
gnu_double_vector __dbLn2lo 0x3d5d1cf79abc9e3b

/* Polynomial coefficients (k=10, deg=3): */
gnu_double_vector __dPC0 0x3ff0000000000000
gnu_double_vector __dPC1 0x3fe0000001ebfbe0
gnu_double_vector __dPC2 0x3fc5555555555556

/* Other constants:
 * index mask = 2^k-1 */
gnu_double_vector __lIndexMask 0x00000000000003ff

/* absolute value mask (SP) */
gnu_float_vector __iAbsMask 0x7fffffff

/* domain range (SP) (>=4086232B) */
gnu_float_vector __iDomainRange 0x4086232a
	.type	__svml_dgnuexp_data,@object
	.size __svml_dgnuexp_data,.-__svml_dgnuexp_data


/*
 *	The tty port on the MBC is very very simplistic indeed. In fact
 *	excessively so as we may block the entire system on a write 8(
 *
 *	This file implements the serial ports for the platform. Fuzix implements
 *	a reasonable subset of the System 5 termios. Certain things that are
 *	rarely relevant like XCASE, delay fills and parity are left to the
 *	driver if desired.
 *
 */

#include <kernel.h>
#include <kdata.h>
#include <printf.h>
#include <tty.h>
#include <devtty.h>
#include <bios.h>

static uint8_t sleeping;

tcflag_t termios_mask[NUM_DEV_TTY + 1];

/*
 *	One entry per tty. The 0th entry is never used as tty minor 0 is
 *	special (/dev/tty) and it's cheaper to waste a few bytes that keep
 *	doing subtractions.
 */
struct s_queue ttyinq[NUM_DEV_TTY + 1]; /* ttyinq[0] is never used */
/* TODO: dynamic setup */

/* Write to system console. This is the backend to all the kernel messages,
   kprintf(), panic() etc. */

void kputchar(uint_fast8_t c)
{
	if (c == '\n')
		tty_putc(1, '\r');
	while(tty_writeready(0) != TTY_READY_NOW);
	tty_putc(0, c);
}

/*
 *	See if the given tty is able to transmit data without blocking. This
 *	may be done by checking the hardware, or if there is a software
 *	transmit queue by checking the queue is full.
 *
 *	There are three possible returns
 *	TTY_READY_NOW means fire away
 *	TTY_READY_SOON means we will spin trying until pre-empted. As the
 *		8bit processors are slow relative to baud rates it's often
 *		more efficient to do this
 *	TTY_READY_LATER means we will give up the CPU. This is best if the
 *		baud rate is low, the link is blocked by flow control signals
 *		or the CPU is fast.
 *
 *	If TTY_READY_LATER is returned then the kernel will also call
 *	tty_sleeping(minor) before sleeping on the tty so that the driver
 *	can turn on or off tx complete interrupts.
 *
 *	A video display that never blocks will just return TTY_READY_NOW
 */
uint_fast8_t tty_writeready(uint_fast8_t minor)
{
	if (fuzixbios_serial_txready(minor))
		return TTY_READY_NOW;
	return TTY_READY_SOON;
}

/*
 *	Write a character to a tty. This is the normal user space path for
 *	each outbound byte. It gets called in the normal tty flow, but may
 *	also be called from an interrupt to echo characters even if the
 *	tty is busy. This one reason to implement a small transmit queue.
 *
 *	If the character echo doesn't fit just drop it. It should pretty much
 *	never occur and there is nothing else to do.
 */
void tty_putc(uint_fast8_t minor, uint_fast8_t c)
{
	fuzixbios_serial_tx(minor | (c << 8));
}

/*
 *	This function is called whenever the terminal interface is opened
 *	or the settings changed. It is responsible for making the requested
 *	changes to the port if possible. Strictly speaking it should write
 *	back anything that cannot be implemented to the state it selected.
 */
void tty_setup(uint_fast8_t minor, uint_fast8_t flags)
{
	static struct fuzixbios_ttyconfig tc;
	tc.device = minor;
	tc.flags = flags;
	tc.termios = ttydata[minor].termios;
	fuzixbios_serial_setup(&tc);
	ttydata[minor].termios = tc.termios;
}

/*
 *	This function is called when the kernel is about to sleep on a tty.
 *	We don't care about this.
 */
void tty_sleeping(uint_fast8_t minor)
{
	used(minor);
}

/*
 *	Return 1 if the carrier on the terminal is raised. If the port has
 *	no carrier signal always return 1. It is used to block a port on open
 *	until carrier.
 */
int tty_carrier(uint_fast8_t minor)
{
	return fuzixbios_serial_carrier(minor);
}

/*
 *	When the input queue is part drained this method is called from the
 *	kernel so that hardware flow control signals can be updated.
 */
void tty_data_consumed(uint_fast8_t minor)
{
	used(minor);
}

int biostty_open(uint_fast8_t minor, uint16_t flag)
{
	if (minor <= biosinfo->num_serial)
		return tty_open(minor, flag);
	udata.u_error = ENXIO;
	return -1;
}


 für Walking-Workouts adaptiert werden. So überzeugt etwa **Shakira** mit Songs wie **Hips Don’t Lie (2006)** durch karibisch inspirierte Rhythmen und knackige Percussions.

Auch afrikanische Künstler*innen prägen den globalen Sound des Genres. **Master KG** aus Südafrika landete mit **Jerusalema (2019)** einen Welthit, der durch seinen leichtfüßigen Beat, den repetitiven Groove und seine positive Energie neue Maßstäbe setzte. Das Stück wurde zu einem viralen Hit, begleitet von Tanz- und Walking-Challenges, und findet sich heute auf Playlists von Rio bis Tokio.

In Südeuropa, besonders in Italien und Spanien, beeinflussen regionale Pop- und Danceproduktionen das globale Klangbild. **Tones and I** aus Australien brachte mit **Dance Monkey (2019)** einen Song hervor, der mit rhythmischer Klarheit, eingängiger Melodie und universeller Verständlichkeit überzeugt. Solche internationalen Erfolgstitel spiegeln den Trend wider, dass Power Walk Musik kulturelle Unterschiede nicht einebnet, sondern als Inspirationsquelle und Bereicherung nutzt.

### Von der Playlist zum Lebensgefühl: Die Bedeutung ikonischer Werke

Viele Lieder sind über ihren musikalischen Wert hinaus zu Symbolen eines aktiven Lebensstils geworden. **Eye of the Tiger** von **Survivor (1982)** ist längst mehr als ein Rocksong – weltweit steht er für Durchhaltewillen, Motivation und die Kraft, jede Herausforderung Schritt für Schritt anzugehen. Solche Tracks finden sich noch heute auf Power Walk Playlists, weil sie Kopf und Beine gleichermaßen bewegen.

Ähnlich verhält es sich mit **Can’t Stop the Feeling! (2016)** von **Justin Timberlake**, das seit Erscheinen für gute Laune und Aufbruchsstimmung sorgt. Die Produktion verbindet Elemente aus Funk und Pop, wodurch der Song zu einem perfekten Begleiter für Bewegung wird. Jeder Takt bringt Energie, jeder Chorus mobilisiert neue Kraftreserven.

Ein weiteres Beispiel für den Einfluss ikonischer Titel ist **Lose Yourself (2002)** von **Eminem**. Flow, Groove und ein stetiges, antreibendes Tempo machen diesen Song zur Favoritenwahl vieler Power Walker, da der Track eine mitreißende Spannung vom ersten bis zum letzten Takt aufbaut.

So zeigen Schlüsselwerke und Künstler*innen aus unterschiedlichen Epochen und Weltregionen, wie facettenreich und einflussstark Power Walk Musik ist. Der Sound zum schnellen Gehen bleibt im Wandel und passt sich immer neuen Hörerwünschen, Technologien und Lebensgewohnheiten an.

## Von Kopfhörer zu Klangrausch: Die Technik hinter dem Power Walk Sound

### Digitaler Antrieb: Wie Technologie den idealen Power Walk-Track erschafft

Die technischen Grundlagen von Power Walk Musik wirken zwar scheinbar unsichtbar, spielen jedoch eine entscheidende Rolle beim Erfolg jedes Tracks. Im Zentrum der Produktion stehen präzise Zielvorgaben: Ein Song für Power Walker muss sowohl den richtigen Puls liefern als auch langfristig motivieren. Schon das Songwriting beginnt häufig mit dem sogenannten **Tempo-Mapping** – dabei legen Produzent*innen die **exakten Beats pro Minute** (meist zwischen 120 und 140 BPM) fest, die später zuverlässig das Schrittmaß treiben. In modernen Tonstudios arbeiten Musikschaffende mit digitalen Audioprogrammen, den DAWs


(D)",d:[7,11],g:1,f:{e:1d,i:"D"},c:{n:"W",b:"w",a:p,h:"E"}},{j:"13 d m E (k)",d:[7,11],g:1,f:{e:1d,i:"k"},c:{n:"W",b:"w",a:p,h:"E"}},{j:"13 d m r (o)",d:[7,11],g:1,f:{e:1d,i:"o"},c:{n:"W",b:"w",a:p,h:"r"}},{j:"13 d m r (D)",d:[7,11],g:1,f:{e:1d,i:"D"},c:{n:"W",b:"w",a:p,h:"r"}},{j:"13 d m r (k)",d:[7,11],g:1,f:{e:1d,i:"k"},c:{n:"W",b:"w",a:p,h:"r"}},{j:"13 d N J m L (o)",d:[7,11],g:1,f:{e:1d,i:"o"},c:{n:"W",b:"w",a:p,h:"L"}},{j:"13 d N J m L (k)",d:[7,11],g:1,f:{e:1d,i:"k"},c:{n:"W",b:"w",a:p,h:"L"}},{j:"13 d N L m J (D)",d:[7,11],g:1,f:{e:1d,i:"D"},c:{n:"W",b:"w",a:p,h:"J"}},{j:"13 d N L m J (k)",d:[7,11],g:1,f:{e:1d,i:"k"},c:{n:"W",b:"w",a:p,h:"J"}},{j:"13 P m L (o)",d:1,g:[12,16],f:{e:q,i:"o"},c:{n:"W",b:"w",a:p,h:"L"}},{j:"13 P m L (D)",d:1,g:[12,16],f:{e:q,i:"D"},c:{n:"W",b:"w",a:p,h:"L"}},{j:"13 P m L (k)",d:1,g:[12,16],f:{e:q,i:"k"},c:{n:"W",b:"w",a:p,h:"L"}},{j:"13 P m J (o)",d:1,g:[12,16],f:{e:q,i:"o"},c:{n:"W",b:"w",a:p,h:"J"}},{j:"13 P m J (D)",d:1,g:[12,16],f:{e:q,i:"D"},c:{n:"W",b:"w",a:p,h:"J"}},{j:"13 P m J (k)",d:1,g:[12,16],f:{e:q,i:"k"},c:{n:"W",b:"w",a:p,h:"J"}},{j:"13 P N r m E (o)",d:1,g:[12,16],f:{e:q,i:"o"},c:{n:"W",b:"w",a:p,h:"E"}},{j:"13 P N r m E (k)",d:1,g:[12,16],f:{e:q,i:"k"},c:{n:"W",b:"w",a:p,h:"E"}},{j:"13 P N E m r (D)",d:1,g:[12,16],f:{e:q,i:"D"},c:{n:"W",b:"w",a:p,h:"r"}},{j:"13 P N E m r (k)",d:1,g:[12,16],f:{e:q,i:"k"},c:{n:"W",b:"w",a:p,h:"r"}},{j:"Z v Y R m E (k)",d:[2,4],g:[4,7],f:{e:1f,i:"k"},c:{n:"Q",b:


                        ok = false;
                    } else {
                        //If it does not exceed, continue to accumulate
                        totalBackAmountMap.put(key, tempTotalBackAmount);
                    }
                }
                if (!ok) {
                    invalidCtxList.add(ctx);
                } else {
                    verifiedCtxSet.add(ctxHash);
                }

            } catch (NulsException e) {
                invalidCtxList.add(ctx);
                chain.getLogger().error("Cross-Chain Transaction Verification Failure");
                chain.getLogger().error(e);
                errorCode = e.getErrorCode().getCode();
            } catch (IOException io) {
                invalidCtxList.add(ctx);
                chain.getLogger().error("Cross-Chain Transaction Verification Failure");
                chain.getLogger().error(io);
                errorCode = NulsCrossChainErrorCode.SERIALIZE_ERROR.getCode();
            }
        }
        result.put("txList", invalidCtxList);
        result.put("errorCode", errorCode);
        return result;
    }

    private BackOutAmount getBackAmount(Transaction ctx, Chain chain) throws NulsException {
        BackOutAmount backOutAmount = null;
        CoinData coinData = new CoinData();
        coinData.parse(ctx.getCoinData(), 0);
        CoinTo coinTo = coinData.getTo().get(0);
        if (chain.getChainId() != coinTo.getAssetsChainId()) {
            //Only handle assets in this chain
            return null;
        }
        byte[] toAddress = coinTo.getAddress();
        int chainId = AddressTool.getChainIdByAddress(toAddress);
        backOutAmount = new BackOutAmount(coinTo.getAssetsChainId(), coinTo.getAssetsId());
        if (chain.getChainId() == chainId) {
            //Guess it's a reversal
            backOutAmount.addBack(coinTo.getAmount());
        } else {
            backOutAmount.addOut(coinTo.getAmount());
        }
        //It should be verifiedfromaddress
        CoinFrom from = coinData.getFrom().get(0);
        int fromChainId = AddressTool.getChainIdByAddress(from.getAddress());
        if (fromChainId == chainId) {
            throw new NulsException(TO_ADDRESS_ERROR);
        }
        return backOutAmount;
    }

    @Override
    @SuppressWarnings("unchecked")
    public Result getCrossTxState(Map<String, Object> params) {
        if (params.get(CHAIN_ID) == null || params.get(TX_HASH) == null) {
            return Result.getFailed(PARAMETER_ERROR);
        }
        int chainId = (Integer) params.get(CHAIN_ID);
        if (chainId <= 0) {
            return Result.getFailed(PARAMETER_ERROR);
        }
        Chain chain = chainManager.getChainMap().get(chainId);
        if (chain == null) {
            return Result.getFailed(CHAIN_NOT_EXIST);
        }
        String hashStr = (String) params.get(TX_HASH);
        Map<String, Object> result = new HashMap<>(2);
        NulsHash requestHash = NulsHash.fromHex(hashStr);
        byte statisticsResult = TxUtil.getCtxState(chain, requestHash);
        result.put(VALUE, statisticsResult);
        return Result.getSuccess(SUCCESS).setData(result);
    }

    @Override
    @SuppressWarnings("unchecked")
    public Result getRegisteredChainInfoList(Map<String, Object> params) {
        Map<String, Object> result = new HashMap<>(2);
        LoggerUtil.commonLog.info("------Obtain cross chain asset information---Total length：" + chainManager.getRegisteredCrossChainList().size());
        result.put(LIST, chainManager.getRegisteredCrossChainList());
        return Result.getSuccess(SUCCESS).setData(result);
    }

    @Override
    public int getCrossChainTxTy


order: none;
    }
    ul.thumbnails figure div {
        min-height: 105px;
    }
    ul.thumbnails figure label {
        font-size: 12px;
    }

ul.renditions {
    background: #f8f8f8;
    padding: 5px 12px;
    box-shadow: none;
    position: absolute;
    top: 45px;
    bottom: 214px;
    left: 0;
    right: 0;
    overflow-y: auto;
    display: block;
    box-sizing: border-box;
    height: auto;
    border-top: 1px solid #ddd;
    }
    ul.renditions li {
        background: #fff;
        padding: 0;
        margin: 7px 6px;
        border: #d4d4d4 solid 1px;
        width: 168px;
        border-radius: 2px;
        -moz-border-radius: 2px;
        -webkit-border-radius: 2px;
        box-shadow: 0 2px 0 rgba(212,212,212,1);
        }
        ul.renditions li:hover {
            border: 1px solid #707070;
            box-shadow: 0 2px 0 rgba(112,112,112,1);
        }
        ul.renditions li dl.rendition .preview, ul.renditions li.state-active dl.rendition .preview {
            border: none;
        }
        ul.renditions li.active {
            background: #d9eaf9;
        }
        ul.renditions li.active dl.rendition dd {
            background: #cfe1f1;
        }
        ul.renditions li.active dl.rendition dd.name {
            border-top: 1px solid #c7dbeb;
        }

        ul.renditions li dl.rendition dt {
            padding: 8px;
            }
            ul.renditions li dl.rendition dd {
                margin: 0;
                padding: 0;
                background: #fafafa;
                }
                ul.renditions li dl.rendition dd.name {
                    border-top: 1px solid #e6e6e6;
                    color: #808080 !important;
                    padding: 3px 0 0;
                    }
.renditions .reset {
    background: #007fb3;
    right: 10px;
    top: 8px;
    padding: 3px 5px;
    }

.save-button {
    padding: 4px 12px;
    margin-right: 40px;
    font-family: 'Roboto', Arial, Helvetica, sans-serif;
    font-size: 13px;
    background-image: -webkit-linear-gradient(top, #2591be 0%, #207da4 100%);
    background-image: -webkit-gradient(linear, left top, left bottom, from(#2591be), to(#207da4));
    background-image: linear-gradient(to bottom, #2591be 0%, #207da4 100%);
    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff2591be', endColorstr='#ff207da4', GradientType=0);
    filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
    background-repeat: repeat-x;
    border-color: #1d7093;
    border-radius: 2px;
    -moz-border-radius: 2px;
    -webkit-border-radius: 2px;
    text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.2);
    -webkit-box-shadow: 0 1px 0 #ffffff, inset 0 1px 0 rgba(255, 255, 255, 0.3);
    box-shadow: 0 1px 0 #ffffff, inset 0 1px 0 rgba


/* $NetBSD: t_modf.c,v 1.1 2014/06/16 12:54:43 joerg Exp $ */

/*-
 * Copyright (c) 2014 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Joerg Sonnenberger.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 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.
 */

#include <atf-c.h>
#include <float.h>
#include <math.h>

ATF_TC(modf);
ATF_TC_HEAD(modf, tc)
{
	atf_tc_set_md_var(tc, "descr","Check modf family");
}

ATF_TC_BODY(modf, tc)
{
	float basef;
	double base;
	long double basel;
	ATF_CHECK(modff(1.0, &basef) == 0.0);
	ATF_CHECK(basef == 1.0);
	ATF_CHECK(modf(1.0, &base) == 0.0);
	ATF_CHECK(base == 1.0);
	ATF_CHECK(modfl(1.0, &basel) == 0.0);
	ATF_CHECK(basel == 1.0);

	ATF_CHECK(modff(-1 - FLT_EPSILON, &basef) == -FLT_EPSILON);
	ATF_CHECK(basef == -1.0);
	ATF_CHECK(modf(-1 - DBL_EPSILON, &base) == -DBL_EPSILON);
	ATF_CHECK(base == -1.0);
	ATF_CHECK(modfl(-1 - LDBL_EPSILON, &basel) == -LDBL_EPSILON);
	ATF_CHECK(basel == -1.0);
}

ATF_TP_ADD_TCS(tp)
{

	ATF_TP_ADD_TC(tp, modf);

	return atf_no_error();
}


eturn;
    }
    this._buffer[row][col] = val;
    const data = this._page.data;
    let color;
    let off = (col * 14 + row * 560 * 8 * 2) * 4;

    let fore = this._greenMode ? this._green : this._white;
    const back = this._black;
    let char = 0;

    if (!val) {
      if (this._blinking) {
        fore = this._black;
      }
    } else {
      char = val & 0x1f;
      char |= val & 0x40 ? 0 : 0x20;
    }

    for (let jdx = 0; jdx < 8; jdx++) {
      let b = charset[char * 8 + jdx];
      for (let idx = 0; idx < 7; idx += 1) {
        b <<= 1;
        color = b & 0x80 ? fore : back;
        const c0 = color[0],
          c1 = color[1],
          c2 = color[2];
        data[off + 0] = data[off + 4] = c0;
        data[off + 1] = data[off + 5] = c1;
        data[off + 2] = data[off + 6] = c2;
        if (!this._scanlines) {
          data[off + 560 * 4] = data[off + 560 * 4 + 4] = c0;
          data[off + 560 * 4 + 1] = data[off + 560 * 4 + 5] = c1;
          data[off + 560 * 4 + 2] = data[off + 560 * 4 + 6] = c2;
        } else {
          data[off + 560 * 4] = data[off + 560 * 4 + 4] = c0 >> 1;
          data[off + 560 * 4 + 1] = data[off + 560 * 4 + 5] = c1 >> 1;
          data[off + 560 * 4 + 2] = data[off + 560 * 4 + 6] = c2 >> 1;
        }
        off += 8;
      }
      off += 546 * 4 + 560 * 4;
    }
  }
  _blink() {
    for (let row = 0; row < 24; row++) {
      for (let col = 0; col < 40; col++) {
        const val = this._buffer[row][col];
        if (!val) {
          this.writeAt(row, col, val);
        }
      }
    }
    this._dirty = true;
  }
  refresh() {
    for (let row = 0; row < 24; row++) {
      for (let col = 0; col < 40; col++) {
        this.writeAt(row, col, this._buffer[row][col]);
      }
    }
    this._dirty = true;
  }
  green(on: boolean) {
    this._greenMode = on;
    this.refresh();
  }
  scanlines(on: boolean) {
    this._scanlines = on;
    this.refresh();
  }
  blit() {
    if (!this._page || !this._context) {
      return;
    }
    if (this._dirty) {
      this._context.putImageData(
        this._page,
        0,
        0,
        0,
        0,
        7 * 40 * 2,
        8 * 24 * 2,
      );
    }
  }
  setContext(context: CanvasRenderingContext2D) {
    this._context = context;
    this._page = context.createImageData(560, 384);
    for (let idx = 0; idx < 560 * 384 * 4; idx++) {
      this._page.data[idx] = 0xff;
    }
  }
  getText() {
    function mapCharCode(charCode: byte) {
      charCode &= 0x7f;
      if (charCode < 0x20) {
        charCode += 0x40;
      }
      if (charCode >= 0x60) {
        charCode -= 0x40;
      }
      return charCode;
    }

    let buffer = '',
      line,
      charCode;
    let row, col;
    for (row = 0; row < 24; row++) {
      line = '';
      for (


ClaimRetentionPolicy
	retainPVC := pvcRetentionPolicy != nil && pvcRetentionPolicy.WhenDeleted == appsv1.RetainPersistentVolumeClaimRetentionPolicyType
	if ptr.Deref(inst.Spec.ScaledDown, false) {
		retainPVC = pvcRetentionPolicy != nil && pvcRetentionPolicy.WhenScaled == appsv1.RetainPersistentVolumeClaimRetentionPolicyType
	}

	// delete secondary objects first
	if has, err := r.deleteSecondaryObjects(tree, retainPVC); has {
		return kubebuilderx.Continue, err
	}

	// delete root object
	tree.DeleteRoot()
	return kubebuilderx.Continue, nil
}

func (r *deletionReconciler) deleteSecondaryObjects(tree *kubebuilderx.ObjectTree, retainPVC bool) (bool, error) {
	// secondary objects to be deleted
	secondaryObjects := maps.Clone(tree.GetSecondaryObjects())
	if retainPVC {
		// exclude PVCs from them
		pvcList := tree.List(&corev1.PersistentVolumeClaim{})
		for _, pvc := range pvcList {
			name, err := model.GetGVKName(pvc)
			if err != nil {
				return true, err
			}
			delete(secondaryObjects, *name)
		}
	}
	// delete them
	for _, obj := range secondaryObjects {
		if err := tree.Delete(obj); err != nil {
			return true, err
		}
	}
	return len(secondaryObjects) > 0, nil
}
/*
Copyright (C) 2022-2025 ApeCloud Co., Ltd

This file is part of KubeBlocks project

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

This program is distributed in the hope that it will be useful
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

package instance

import (
	"reflect"
	"slices"
	"strings"

	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"sigs.k8s.io/controller-runtime/pkg/client"
	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"

	kbappsv1 "github.com/apecloud/kubeblocks/apis/apps/v1"
	workloads "github.com/apecloud/kubeblocks/apis/workloads/v1"
	"github.com/apecloud/kubeblocks/pkg/constant"
	"github.com/apecloud/kubeblocks/pkg/controller/builder"
	"github.com/apecloud/kubeblocks/pkg/controller/lifecycle"
	"github.com/apecloud/kubeblocks/pkg/controller/model"
	intctrlutil "github.com/apecloud/kubeblocks/pkg/controllerutil"
)

func podName(inst *workloads.Instance) string {
	return inst.Name
}

func podObj(inst *workloads.Instance) *corev1.Pod {
	return &corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Namespace: inst.Namespace,
			Name:      podName(inst),
		},
	}
}

// getRoleName gets role name of pod


nment on UI_OpeningShow_C_PreConstruct");
static_assert(sizeof(UI_OpeningShow_C_PreConstruct) == 0x000001, "Wrong size on UI_OpeningShow_C_PreConstruct");
static_assert(offsetof(UI_OpeningShow_C_PreConstruct, IsDesignTime) == 0x000000, "Member 'UI_OpeningShow_C_PreConstruct::IsDesignTime' has a wrong offset!");

// Function UI_OpeningShow.UI_OpeningShow_C.UpdateOpeningShow
// 0x0001 (0x0001 - 0x0000)
struct UI_OpeningShow_C_UpdateOpeningShow final
{
public:
	EDefenderTeamType                             TeamType;                                          // 0x0000(0x0001)(BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
};
static_assert(alignof(UI_OpeningShow_C_UpdateOpeningShow) == 0x000001, "Wrong alignment on UI_OpeningShow_C_UpdateOpeningShow");
static_assert(sizeof(UI_OpeningShow_C_UpdateOpeningShow) == 0x000001, "Wrong size on UI_OpeningShow_C_UpdateOpeningShow");
static_assert(offsetof(UI_OpeningShow_C_UpdateOpeningShow, TeamType) == 0x000000, "Member 'UI_OpeningShow_C_UpdateOpeningShow::TeamType' has a wrong offset!");

// Function UI_OpeningShow.UI_OpeningShow_C.StartPlayExitAnim
// 0x0008 (0x0008 - 0x0000)
struct UI_OpeningShow_C_StartPlayExitAnim final
{
public:
	class UCanvasPanel*                           Panel_Logo_Root;                                   // 0x0000(0x0008)(BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
};
static_assert(alignof(UI_OpeningShow_C_StartPlayExitAnim) == 0x000008, "Wrong alignment on UI_OpeningShow_C_StartPlayExitAnim");
static_assert(sizeof(UI_OpeningShow_C_StartPlayExitAnim) == 0x000008, "Wrong size on UI_OpeningShow_C_StartPlayExitAnim");
static_assert(offsetof(UI_OpeningShow_C_StartPlayExitAnim, Panel_Logo_Root) == 0x000000, "Member 'UI_OpeningShow_C_StartPlayExitAnim::Panel_Logo_Root' has a wrong offset!");

// Function UI_OpeningShow.UI_OpeningShow_C.SequenceEvent__ENTRYPOINTUI_OpeningShow_0
// 0x0008 (0x0008 - 0x0000)
struct UI_OpeningShow_C_SequenceEvent__ENTRYPOINTUI_OpeningShow_0 final
{
public:
	class UCanvasPanel*                           Panel_Logo_Root;                                   // 0x0000(0x0008)(BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
};
static_assert(alignof(UI_OpeningShow_C_SequenceEvent__ENTRYPOINTUI_OpeningShow_0) == 0x000008, "Wrong alignment on UI_OpeningShow_C_SequenceEvent__ENTRYPOINTUI_OpeningShow_0");
static_assert(sizeof(UI_OpeningShow_C_SequenceEvent__ENTRYPOINTUI_OpeningShow_0) == 0x000008, "Wrong size on UI_OpeningShow_C_SequenceEvent__ENTRYPOINTUI_OpeningShow_0");
static_assert(offsetof(UI_OpeningShow_C_SequenceEvent__ENTRYPOINTUI_OpeningShow_0, Panel_Logo_Root) == 0x000000, "Member 'UI_OpeningShow_C_SequenceEvent__ENTRYPOINTUI_OpeningShow_0::Panel_Logo_Root' has a wrong offset!");

// Function UI_OpeningShow.UI_OpeningShow_C.SequenceEvent__ENTRYPOINTUI_OpeningShow_1
// 0x0008 (


;
    pub const INDIRECT_Y_INDEXED: u8 = 0x91;
    pub const X_INDEXED_INDIRECT: u8 = 0x81;
    pub const ZERO_PAGE: u8 = 0x85;
    pub const ZERO_PAGE_X_INDEXED: u8 = 0x95;
}
pub mod stx {
    pub const ABSOLUTE: u8 = 0x8E;
    pub const ZERO_PAGE: u8 = 0x86;
    pub const ZERO_PAGE_Y_INDEXED: u8 = 0x96;
}
pub mod sty {
    pub const ABSOLUTE: u8 = 0x8C;
    pub const ZERO_PAGE: u8 = 0x84;
    pub const ZERO_PAGE_X_INDEXED: u8 = 0x94;
}
pub mod sxa {
    pub mod unofficial0 {
        pub const ABSOLUTE_Y_INDEXED: u8 = 0x9E;
    }
}
pub mod sya {
    pub mod unofficial0 {
        pub const ABSOLUTE_X_INDEXED: u8 = 0x9C;
    }
}
pub mod tax {
    pub const IMPLIED: u8 = 0xAA;
}
pub mod tay {
    pub const IMPLIED: u8 = 0xA8;
}
pub mod tsx {
    pub const IMPLIED: u8 = 0xBA;
}
pub mod txa {
    pub const IMPLIED: u8 = 0x8A;
}
pub mod txs {
    pub const IMPLIED: u8 = 0x9A;
}
pub mod tya {
    pub const IMPLIED: u8 = 0x98;
}
<reponame>rarescosma/advent-of-code-2021-rs
use aoc_2dmap::prelude::*;
use aoc_prelude::*;

#[derive(Parser)]
#[grammar = "parsers/day09-depth.pest"]
pub struct DepthParser;

struct DepthMap(Map<u8>);

const MAX_DEPTH: u8 = 9;

impl DepthMap {
    fn new(depths: Vec<Vec<u8>>) -> Self {
        Self(Map::<u8>::new(
            (depths[0].len(), depths.len()),
            depths.into_iter().flatten(),
        ))
    }

    fn depth_of(&self, pos: Pos) -> u8 {
        self.0.get(pos).unwrap_or(MAX_DEPTH)
    }

    fn flows<F: Fn(u8) -> bool>(&self, pos: Pos, pred: F) -> Vec<(Pos, bool)> {
        let depth = self.depth_of(pos);
        pos.neighbors_simple()
            .into_iter()
            .flat_map(move |pos| {
                self.0
                    .get(pos)
                    .map(|n_depth| (pos, pred(n_depth) && n_depth > depth))
            })
            .collect()
    }

    fn basin_size(&self, pos: Pos) -> usize {
        let depth = self.depth_of(pos);
        if depth == MAX_DEPTH {
            return 0;
        }
        let mut stack = VecDeque::<Pos>::new();
        stack.push_back(pos);

        let mut basin_acc = HashSet::<Pos>::new();
        basin_acc.insert(pos);

        while let Some(pos) = stack.pop_back() {
            let basin: Vec<_> = self.basin(pos).collect();
            basin_acc.extend(basin.iter());
            stack.extend(basin.iter());
        }
        basin_acc.len()
    }

    fn basin(&self, pos: Pos) -> impl Iterator<Item = Pos> + '_ {
        self.flows(pos, |n_depth| n_depth < MAX_DEPTH)
            .into_iter()
            .filter(|&(_, n_flow)| n_flow)
            .map(|(n_pos, _)| n_pos)
    }
}

fn process_line<'r>(line: &(impl Iterator<Item = Pair<'r, Rule>> + Clone)) -> Vec<u8> {
    line.to_owned()
        .filter(|x| x.as_rule() == Rule::digit)
        .flat_


hould have received a copy of the GNU General Public License along with
// the ClearCanvas RIS/PACS open source project.  If not, see
// <http://www.gnu.org/licenses/>.

#endregion

using ClearCanvas.Common;

namespace ClearCanvas.ImageViewer.Tools.Standard.PresetVoiLuts.Operations
{
	internal sealed class MinMaxAlgorithmPresetVoiLutOperationFactory : PresetVoiLutOperationFactory<MinMaxAlgorithmPresetVoiLutOperationComponent>
	{
		internal static readonly string FactoryName = "Min/Max Algorithm";

		public MinMaxAlgorithmPresetVoiLutOperationFactory()
		{
		}

		public override string Name
		{
			get { return FactoryName; }
		}

		public override string Description
		{
			get { return SR.MinMaxAlgorithmPresetVoiLutOperationFactoryDescription; }
		}
	}
}


e
    if employee_id:
        employee = Employee.objects.get(id=employee_id)
        shift = employee.get_shift
    form = NewRequestForm()
    if request.GET.get("bulk") and eval_validate(request.GET.get("bulk")):
        form = BulkAttendanceRequestForm()
    form.fields["shift_id"].queryset = EmployeeShift.objects.all()
    form.fields["shift_id"].widget.attrs["hx-trigger"] = "load,change"
    form.fields["shift_id"].initial = shift
    shift_id = render_to_string(
        "requests/attendance/form_field.html",
        {
            "field": form["shift_id"],
            "shift": shift,
        },
    )
    return HttpResponse(f"{shift_id}")


_ASSERT_NO_THROW ( std::clog << static_cast<finalcut::FLog::LogLevel>(99) );

  // Reset to the default rdbuf of clog
  std::clog.rdbuf(default_clog_rdbuf);
}

// Put the test suite in the registry
CPPUNIT_TEST_SUITE_REGISTRATION (FLoggerTest);

// The general unit test main part
#include <main-test.inc>

/***********************************************************************
* foptimove-test.cpp - FOptiMove unit tests                            *
*                                                                      *
* This file is part of the FINAL CUT widget toolkit                    *
*                                                                      *
* Copyright 2018-2024 Markus Gans                                      *
*                                                                      *
* FINAL CUT is free software; you can redistribute it and/or modify    *
* it under the terms of the GNU Lesser General Public License as       *
* published by the Free Software Foundation; either version 3 of       *
* the License, or (at your option) any later version.                  *
*                                                                      *
* FINAL CUT is distributed in the hope that it will be useful, but     *
* WITHOUT ANY WARRANTY; without even the implied warranty of           *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        *
* GNU Lesser General Public License for more details.                  *
*                                                                      *
* You should have received a copy of the GNU Lesser General Public     *
* License along with this program.  If not, see                        *
* <http://www.gnu.org/licenses/>.                                      *
***********************************************************************/

#include <iomanip>
#include <string>

#include <cppunit/BriefTestProgressListener.h>
#include <cppunit/CompilerOutputter.h>
#include <cppunit/extensions/HelperMacros.h>
#include <cppunit/TestFixture.h>
#include <cppunit/TestResult.h>
#include <cppunit/TestResultCollector.h>
#include <cppunit/TestRunner.h>
#include <cppunit/SourceLine.h>
#include <cppunit/TestAssert.h>

#include <final/final.h>

#define CPPUNIT_ASSERT_STRING(expected, actual) \
            check_string (expected, actual, CPPUNIT_SOURCELINE())

//----------------------------------------------------------------------
void check_string ( const std::string& s1
                  , const std::string& s2
                  , const CppUnit::SourceLine& sourceLine )
{
  if ( s1 == s2 )  // Strings are equal
    return;

  ::CppUnit::Asserter::fail ("Strings are not equal", sourceLine);
}

//----------------------------------------------------------------------
class DirectLogger final : public finalcut::FLog
{
  public:
    // Constructor
    DirectLogger() = default;

    // Destructor
    ~DirectLogger() noexcept override;

    void info (const std::string& entry) override
    {
      output << entry << "\r" << std::endl;
    }

    void warn (const std::string&) override
    {
      // An implementation is not required in this context
    }

    void error (const std::string&) override
    {
      // An implementation is not required in this context
    }

    void debug (const std::string&) override
    {
      // An implementation is not required in this context
    }

    void flush() override
    {
      output.flush();
    }

    void setOutputStream (const std::ostream& os) override
    { output.rdbuf(os.rdbuf()); }

    void setLineEnding (LineEnding) overrid


R = crate::R<u8, u8>;
#[doc = "Write proxy for field `EN`"]
pub struct EN_W<'a> {
    w: &'a mut W,
}
impl<'a> EN_W<'a> {
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !0x03) | ((value as u32) & 0x03);
        self.w
    }
}
#[doc = "Write proxy for field `CLR`"]
pub struct CLR_W<'a> {
    w: &'a mut W,
}
impl<'a> CLR_W<'a> {
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x03 << 8)) | (((value as u32) & 0x03) << 8);
        self.w
    }
}
#[doc = "Write proxy for field `SET`"]
pub struct SET_W<'a> {
    w: &'a mut W,
}
impl<'a> SET_W<'a> {
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x03 << 16)) | (((value as u32) & 0x03) << 16);
        self.w
    }
}
#[doc = "Reader of field `RTCTGL`"]
pub type RTCTGL_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `RTCTGL`"]
pub struct RTCTGL_W<'a> {
    w: &'a mut W,
}
impl<'a> RTCTGL_W<'a> {
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x03 << 24)) | (((value as u32) & 0x03) << 24);
        self.w
    }
}
impl R {
    #[doc = "Bits 0:1 - Enable Output"]
    #[inline(always)]
    pub fn en(&self) -> EN_R {
        EN_R::new((self.bits & 0x03) as u8)
    }
    #[doc = "Bits 24:25 - RTC Toggle Output"]
    #[inline(always)]
    pub fn rtctgl(&self) -> RTCTGL_R {
        RTCTGL_R::new(((self.bits >> 24) & 0x03) as u8)
    }
}
impl W {
    #[doc = "Bits 0:1 - Enable Output"]
    #[inline(always)]
    pub fn en(&mut self) -> EN_W {
        EN_W { w: self }
    }
    #[doc = "Bits 8:9 - Clear Output"]
    #[inline(always)]
    pub fn clr(&mut self) -> CLR_W {
        CLR_W { w: self }
    }
    #[doc = "Bits 16:17 - Set Output"]
    #[inline(always)]
    pub fn set(&mut self) -> SET_W {
        SET_W { w: self }
    }
    #[doc = "Bits 24:25 - RTC Toggle Output"]
    #[inline(always)]
    pub fn rtctgl(&mut self) -> RTCTGL_W {
        RTCTGL_W { w: self }
    }
}
<reponame>matthieu-m/stysh
//! Registry
//!
//! A read-only interface to obtain the definition of items.

use std::fmt;

use crate::model::hir::*;

/// Registry.
pub trait Registry: fmt::Debug {
    /// Returns the list of functions associated to the enum, sorted.
    fn get_builtin_functions(&self, ty: BuiltinType) -> &[(Identifier, FunctionId)];

    /// Returns the list of known enum IDs.
    fn enums(&self) -> Vec<EnumId>;

    /// Returns the definition of the enum associated to the ID.
    ///
    /// #   Panics
    ///
    /// Panics if the ID is


   val rule = BaselineProfileRule()

    @Test
    fun generate() {
        rule.collect(
            packageName = "com.dot.gallery",
            includeInStartupProfile = true
        ) {
            // This block defines the app's critical user journey. Here we are interested in
            // optimizing for app startup. But you can also navigate and scroll
            // through your most important UI.

            // Start default activity for your app
            pressHome()
            startActivityAndWait()

            // TODO Write more interactions to optimize advanced journeys of your app.
            // For example:
            // 1. Wait until the content is asynchronously loaded
            // 2. Scroll the feed content
            // 3. Navigate to detail screen

            // Check UiAutomator documentation for more information how to interact with the app.
            // https://d.android.com/training/testing/other-components/ui-automator
        }
    }
}package com.daangn.www.mvvmsample.viewmodel

import android.util.Patterns
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import com.daangn.www.mvvmsample.model.Repository
import com.daangn.www.mvvmsample.utils.SingleLiveEvent
import com.rengwuxian.materialedittext.validation.METValidator
import com.rengwuxian.materialedittext.validation.RegexpValidator
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.schedulers.Schedulers

class ShortenUrlViewModel(private val repository: Repository) : DisposableViewModel() {

    private val _shortenUrl = MutableLiveData<String>()
    private val _error = MutableLiveData<String>()
    private val _clickCopyToClipboard = SingleLiveEvent<String>()
    private val _clickOpenWeb = SingleLiveEvent<String>()
    private val _clickConvert = SingleLiveEvent<Any>()

    val showResult = MutableLiveData<Boolean>()

    //mutableLiveData를 immutable 하게 노출
    val shortenUrl: LiveData<String> get() = _shortenUrl
    val error: LiveData<String> get() = _error
    val clickCopyToClipboard: LiveData<String> get() = _clickCopyToClipboard
    val clickOpenWeb: LiveData<String> get() = _clickOpenWeb
    val clickConvert: LiveData<Any> get() = _clickConvert

    fun getUrlValidator(errorMessage: String): METValidator {
        return RegexpValidator(errorMessage, Patterns.WEB_URL.pattern())
    }

    fun getShortenUrl(url: String) {
        addDisposable(repository.getShortenUrl(url)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe({
                showResult.value = true
                _shortenUrl.value = it.url
            }, {
                _error.value = it.message
            }))
    }

    fun clickConvert() {
        _clickConvert.call()
    }

    fun clickCopyToClipboard(){
        _clickCopyToClipboard.value = _shortenUrl.value
    }

    fun clickOpenWeb() {
        _clickOpenWeb.value = _shortenUrl.value
    }
}package com.example.docscanner.feature_createpdf.presentation.searchpdf

import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.


E ASTPANGetDataAfterExpMono8(int iCameraID, [Out] byte[] pBuffer, int lBuffSize);
        ASTPAN_RET_TYPE ASTPANGetNumOfCameras(out int number);
        ASTPAN_RET_TYPE ASTPANGetVideoDataMono16(int iCameraID, [Out] ushort[] pBuffer, int lBuffSize, int iWaitms);
        ASTPAN_RET_TYPE ASTPANGetVideoDataMono8(int iCameraID, [Out] byte[] pBuffer, int lBuffSize, int iWaitms);
        ASTPAN_RET_TYPE ASTPANInitCamera(int id);
        ASTPAN_RET_TYPE ASTPANOpenCamera(int id);
        ASTPAN_RET_TYPE ASTPANSetAutoConfigValue(int id, ASTPAN_AUTO_TYPE index, int value, int bAuto);
        ASTPAN_RET_TYPE ASTPANSetConfigValue(int id, ref ASTPAN_CONFIG pConfig, ASTPAN_CFG_TYPE index);
        ASTPAN_RET_TYPE ASTPANStartExposure(int id);
        ASTPAN_RET_TYPE ASTPANStartVideoCapture(int id);
        ASTPAN_RET_TYPE ASTPANStopExposure(int id);
        ASTPAN_RET_TYPE ASTPANStopVideoCapture(int id);
    }
}