ts/SystemFonts\0", "<init>\0", "()V\0");
        //         __jni_env.new_object_a(__jni_class, __jni_method, __jni_args.as_ptr())
        //     }
        // }

        /// [getAvailableFonts](https://developer.android.com/reference/android/graphics/fonts/SystemFonts.html#getAvailableFonts())
        ///
        /// Required features: "java-util-Set"
        #[cfg(any(feature = "all", all(feature = "java-util-Set")))]
        pub fn getAvailableFonts<'env>(__jni_env: &'env __jni_bindgen::Env) -> __jni_bindgen::std::result::Result<__jni_bindgen::std::option::Option<__jni_bindgen::Local<'env, crate::java::util::Set>>, __jni_bindgen::Local<'env, crate::java::lang::Throwable>> {
            // class.path == "android/graphics/fonts/SystemFonts", java.flags == PUBLIC | STATIC, .name == "getAvailableFonts", .descriptor == "()Ljava/util/Set;"
            unsafe {
                let __jni_args = [];
                let (__jni_class, __jni_method) = __jni_env.require_class_static_method("android/graphics/fonts/SystemFonts\0", "getAvailableFonts\0", "()Ljava/util/Set;\0");
                __jni_env.call_static_object_method_a(__jni_class, __jni_method, __jni_args.as_ptr())
            }
        }
    }
}
<gh_stars>10-100
use crate::runtime::blocking::NoopSchedule;
use crate::runtime::task::{self, unowned, Id, JoinHandle, OwnedTasks, Schedule, Task};
use crate::util::TryLock;

use std::collections::VecDeque;
use std::future::Future;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;

struct AssertDropHandle {
    is_dropped: Arc<AtomicBool>,
}
impl AssertDropHandle {
    #[track_caller]
    fn assert_dropped(&self) {
        assert!(self.is_dropped.load(Ordering::SeqCst));
    }

    #[track_caller]
    fn assert_not_dropped(&self) {
        assert!(!self.is_dropped.load(Ordering::SeqCst));
    }
}

struct AssertDrop {
    is_dropped: Arc<AtomicBool>,
}
impl AssertDrop {
    fn new() -> (Self, AssertDropHandle) {
        let shared = Arc::new(AtomicBool::new(false));
        (
            AssertDrop {
                is_dropped: shared.clone(),
            },
            AssertDropHandle {
                is_dropped: shared.clone(),
            },
        )
    }
}
impl Drop for AssertDrop {
    fn drop(&mut self) {
        self.is_dropped.store(true, Ordering::SeqCst);
    }
}

// A Notified does not shut down on drop, but it is dropped once the ref-count
// hits zero.
#[test]
fn create_drop1() {
    let (ad, handle) = AssertDrop::new();
    let (notified, join) = unowned(
        async {
            drop(ad);
            unreachable!()
        },
        NoopSchedule,
        Id::next(),
    );
    drop(notified);
    handle.assert_not_dropped();
    drop(join);
    handle.assert_dropped();
}

#[test]
fn create_drop2() {
    let (ad, handle) = AssertDrop::new();
    let (notified, join) = unowned(
        async {
            drop(ad);
            un


{q8}, d25
	vldmia	r4!, {q8}
	veor	q10, q10, q2
	vtbl.8	d2, {q9}, d24
	vtbl.8	d3, {q9}, d25
	vldmia	r4!, {q9}
	veor	q11, q11, q3
	vtbl.8	d4, {q10}, d24
	vtbl.8	d5, {q10}, d25
	vldmia	r4!, {q10}
	vtbl.8	d6, {q11}, d24
	vtbl.8	d7, {q11}, d25
	vldmia	r4!, {q11}
	veor	q8, q8, q4
	veor	q9, q9, q5
	vtbl.8	d8, {q8}, d24
	vtbl.8	d9, {q8}, d25
	veor	q10, q10, q6
	vtbl.8	d10, {q9}, d24
	vtbl.8	d11, {q9}, d25
	veor	q11, q11, q7
	vtbl.8	d12, {q10}, d24
	vtbl.8	d13, {q10}, d25
	vtbl.8	d14, {q11}, d24
	vtbl.8	d15, {q11}, d25
.Lenc_sbox:
	veor	q2, q2, q1
	veor	q5, q5, q6
	veor	q3, q3, q0
	veor	q6, q6, q2
	veor	q5, q5, q0

	veor	q6, q6, q3
	veor	q3, q3, q7
	veor	q7, q7, q5
	veor	q3, q3, q4
	veor	q4, q4, q5

	veor	q2, q2, q7
	veor	q3, q3, q1
	veor	q1, q1, q5
	veor	q11, q7, q4
	veor	q10, q1, q2
	veor	q9, q5, q3
	veor	q13, q2, q4
	vmov	q8, q10
	veor	q12, q6, q0

	vorr	q10, q10, q9
	veor	q15, q11, q8
	vand	q14, q11, q12
	vorr	q11, q11, q12
	veor	q12, q12, q9
	vand	q8, q8, q9
	veor	q9, q3, q0
	vand	q15, q15, q12
	vand	q13, q13, q9
	veor	q9, q7, q1
	veor	q12, q5, q6
	veor	q11, q11, q13
	veor	q10, q10, q13
	vand	q13, q9, q12
	vorr	q9, q9, q12
	veor	q11, q11, q15
	veor	q8, q8, q13
	veor	q10, q10, q14
	veor	q9, q9, q15
	veor	q8, q8, q14
	vand	q12, q2, q3
	veor	q9, q9, q14
	vand	q13, q4, q0
	vand	q14, q1, q5
	vorr	q15, q7, q6
	veor	q11, q11, q12
	veor	q9, q9, q14
	veor	q8, q8, q15
	veor	q10, q10, q13

	@ Inv_GF16 	0, 	1, 	2,


uccess', 'info', 'warning', 'danger'];

    for (var i = 0, n = ((_random.nextDouble() * 4).floor() + 1); i < n; i++) {
      var index = ((_random.nextDouble() * 4)).floor();
      stacked.add({
          'value': ((_random.nextDouble() * 30) + 1).floor(), 'type': types[index]
      });
    }
  }

  ProgressDemo() {
    randomStacked();
    random();
  }
}//Copyright (C) 2012 Sergey Akopkokhyants. All Rights Reserved.
//Author: akserg

part of dart_web_toolkit_test;

/**
 * UiObject Tests.
 */
class UiObjectTestGroup extends TestGroup {

  registerTests() {
    this.testGroupName = "UiObject";

    // Static methods
    this.testList["isVisible"] = isVisibleTest;
    this.testList["setVisible"] = setVisibleTest;
    this.testList["getElementStyleName"] = getElementStyleNameTest;
    this.testList["setElementStyleName"] = setElementStyleNameTest;
    this.testList["getElementStylePrimaryName"] = getElementStylePrimaryNameTest;
    this.testList["setElementStylePrimaryName"] = setElementStylePrimaryNameTest;
    this.testList["manageElementStyleName"] = manageElementStyleNameTest;

    // Instance level methods
    this.testList["addStyleDependentName"] = addStyleDependentNameTest;
    this.testList["addStyleName"] = addStyleNameTest;
    this.testList["clearAndSetStyleName"] = clearAndSetStyleNameTest;
    this.testList["extractLengthValue"] = extractLengthValueTest;
    this.testList["getAbsoluteLeft"] = getAbsoluteLeftTest;
    this.testList["getAbsoluteTop"] = getAbsoluteTopTest;
    this.testList["getElement"] = getElementTest;
    this.testList["getOffsetHeight"] = getOffsetHeightTest;
    this.testList["getOffsetWidth"] = getOffsetWidthTest;
    this.testList["getStyleElement"] = getStyleElementTest;
    this.testList["getStyleName"] = getStyleNameTest;
    this.testList["getStylePrimaryName"] = getStylePrimaryNameTest;
    this.testList["removeStyleDependentName"] = removeStyleDependentNameTest;
    this.testList["removeStyleName"] = removeStyleNameTest;
    this.testList["replaceElement"] = replaceElementTest;
    this.testList["setElement"] = setElementTest;
    this.testList["setHeight"] = setHeightTest;
    this.testList["setPixelSize"] = setPixelSizeTest;
    this.testList["setSize"] = setSizeTest;
    this.testList["setStyleDependentName"] = setStyleDependentNameTest;
    this.testList["setStyleName"] = setStyleNameTest;
    this.testList["setStylePrimaryName"] = setStylePrimaryNameTest;
    this.testList["setWidth"] = setWidthTest;

    this.testList["getTitle"] = getTitleTest;
    this.testList["setTitle"] = setTitleTest;
    this.testList["getVisible"] = getVisibleUiObjectTest;
    this.testList["setVisible"] = setVisibleUiObjectTest;

//    this.testList["sinkBitlessEvent"] = sinkBitlessEventTest;
//    this.testList["sinkEvents"] = sinkEventsTest;
//    this.testList["unsinkEvents"] = unsinkEventsTest;
  }

  //***************
  // Static methods
  //***************

  /**
   * Check static method [UiObject.isVisible].
   *
   * Returns whether the given element is visible.
   */
  void isVisibleTest() {
    dart_html.Element element = new dart_html.DivElement();
    // By default element always visible
    expect(ui.UiObject.isVisible(element), isTrue);
    // Set element invisible
    element.style.display = "none";
    // Check does element invisible
    expect


ool Disposing;

        /// <summary>
        /// Initializes a new instance of a DisposeEventArgs class.
        /// </summary>
        /// <param name="disposing">True when disposing, otherwise false.</param>
        private DisposeEventArgs(bool disposing)
        {
            Disposing = disposing;
        }

        /// <summary>
        /// Gets event args base on disposing parameter.
        /// </summary>
        /// <param name="disposing">True when disposing, otherwise false.</param>
        /// <returns>DisposeEventArgs object based on disposing parameter.</returns>
        public static DisposeEventArgs Get(bool disposing)
        {
            return disposing ? DisposingEventArgs : NotDisposingEventArgs;
        }
    }
}


AntiSpam.Commands.SIMILARITY_FORGIVE_TIME).getTimeSeconds() * 1000)
						continue;

					if (this.type == LogType.COMMAND && Settings.AntiSpam.Commands.SIMILARITY_MIN_ARGS > 0)
						if (output.getOutput().split(" ").length - 1 < Settings.AntiSpam.Commands.SIMILARITY_MIN_ARGS)
							continue;

					final boolean isWhitelisted = this.type == LogType.CHAT ? AntiSpam.Chat.WHITELIST_SIMILARITY.isInListRegex(lastOutput.getOutput())
							: AntiSpam.Commands.WHITELIST_SIMILARITY.isInList(output.getOutput().split(" ")[0]);

					if (isWhitelisted)
						continue;

					final double similarity = ChatUtil.getSimilarityPercentage(output.getOutput(), this.message);

					if (similarity >= threshold && ++breaches >= this.get(Settings.AntiSpam.Chat.SIMILARITY_START_AT, Settings.AntiSpam.Commands.SIMILARITY_START_AT)) {
						this.get(WarningPoints.TRIGGER_CHAT_SIMILARITY, WarningPoints.TRIGGER_COMMAND_SIMILARITY)
								.execute(this.wrapped.getSender(),
										Lang.component("checker-similarity-" + (this.type == LogType.CHAT ? "chat" : "command"), "similarity", String.valueOf(Math.round(similarity * 100))),
										SerializedMap.fromArray("similarity_percentage_double", threshold));
					}
				}
			}
		}

		// Cache last message before grammar
		if (this.type == LogType.CHAT)
			senderCache.cacheMessage(this.message, this.channel);

		else if (this.type == LogType.COMMAND)
			senderCache.cacheCommand(this.message);

		else
			throw new FoException("Caching of " + this.type + " not implemented yet");

		// Grammar
		if (this.type == LogType.CHAT && !this.hasPerm(Permissions.Bypass.GRAMMAR)) {
			if (Grammar.CAPITALIZE_MSG_LENGTH != 0 && this.message.length() >= Grammar.CAPITALIZE_MSG_LENGTH) {
				this.message = ChatUtil.capitalizeFirst(this.message);

				this.messageChanged = true;
			}

			if (Grammar.INSERT_DOT_MSG_LENGTH != 0 && this.message.length() >= Grammar.INSERT_DOT_MSG_LENGTH) {
				this.message = ChatUtil.insertDot(this.message);

				this.messageChanged = true;
			}
		}

		if (pendingAntiCapsWarning != null)
			for (final SimpleComponent component : pendingAntiCapsWarning)
				Messenger.warn(this.wrapped.getSender(), component);
	}

	/*
	 * Return if the sender has the given permission
	 */
	private boolean hasPerm(final String permission) {
		return this.wrapped.hasPermission(permission);
	}

	/*
	 * Cancels the pipeline by throwing a {@link EventHandledException}
	 * and send an error message to the player
	 */
	private void cancel(@NonNull final SimpleComponent errorMessage) {
		throw new EventHandledException(true, Variables.builder(this.wrapped.getAudience()).replaceComponent(errorMessage));
	}

	/*
	 * If the checker checks chat, return first argument, if checker checks commands
	 * return the second
	 */
	private <T> T get(final T returnThisIfChat, final T returnThisIfCommand) {
		return this.type == LogType.CHAT ? returnThisIfChat : returnThisIfCommand;
	}
}
package org.mineacademy.chatcontrol.command.chatcontrol;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.mineacademy.chatcontrol.command.chatcontrol.ChatControlCommands


using System;
using System.Collections.Generic;
using System.Linq;
using Nuke.Common;
using Nuke.Common.IO;
using Nuke.Common.Tooling;
using Nuke.Common.Utilities;
using Nuke.Common.Utilities.Collections;
using static Serilog.Log;

public static class CustomNpmTasks
{
    static AbsolutePath RootDirectory;
    static AbsolutePath TempDir;
    static AbsolutePath NodeDir;
    static AbsolutePath NodeDirPerOs;
    static AbsolutePath WorkingDirectory;

    static IReadOnlyDictionary<string, string> NpmEnvironmentVariables;

    static Tool Npm;

    static string Version;

    static Func<string, bool> GetCachedNodeModules;

    public static bool HasCachedNodeModules;

    public static void Initialize(AbsolutePath root)
    {
        RootDirectory = root;
        NodeDir = RootDirectory / ".nuke" / "temp";

        Version = (RootDirectory / "NodeVersion").ReadAllText().Trim();
        GetCachedNodeModules = os => NodeDir.GlobFiles($"node*{Version}-{os}*/**/node*", $"node*{Version}-{os}*/**/npm*").Count != 0;
    }

    public static void NpmFetchRuntime()
    {
        DownloadNodeArchive().ExtractNodeArchive();

        LinkTools();
    }

    static AbsolutePath DownloadNodeArchive()
    {
        AbsolutePath archive = NodeDir;
        string os = null;
        string archiveType = null;

        if (EnvironmentInfo.IsWin)
        {
            os = "win";
            archiveType = ".zip";
        }
        else if (EnvironmentInfo.IsOsx)
        {
            os = "darwin";
            archiveType = ".tar.gz";
        }
        else if (EnvironmentInfo.IsLinux)
        {
            os = "linux";
            archiveType = ".tar.xz";
        }

        os.NotNull();
        archiveType.NotNull();

        string architecture =
            EnvironmentInfo.IsArm64 ? "arm64" :
            EnvironmentInfo.Is64Bit ? "x64" : "x86";

        os = $"{os}-{architecture}";

        HasCachedNodeModules = GetCachedNodeModules(os);

        if (!HasCachedNodeModules)
        {
            Information($"Fetching node.js ({Version}) for {os}");

            string downloadUrl = $"https://nodejs.org/dist/v{Version}/node-v{Version}-{os}{archiveType}";
            archive = NodeDir / $"node{archiveType}";

            HttpTasks.HttpDownloadFile(downloadUrl, archive, clientConfigurator: c =>
            {
                c.Timeout = TimeSpan.FromSeconds(50);

                return c;
            });
        }
        else
        {
            Information("Skipping archive download due to cache");
        }

        NodeDirPerOs = NodeDir / $"node-v{Version}-{os}";
        WorkingDirectory = NodeDirPerOs;

        return archive;
    }

    static void ExtractNodeArchive(this AbsolutePath archive)
    {
        if (HasCachedNodeModules)
        {
            Information("Skipping archive extraction due to cache");

            return;
        }

        Information($"Extracting node.js binary archive ({archive}) to {NodeDir}");

        if (EnvironmentInfo.IsWin)
        {


from data_fetch import fetch_crypto_data
from optimizer import optimize_portfolio
from backtest import backtest
from market_regime import detect_market_regime
from backtest import performance_stats
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

#PROJECT PARAMETERS
tickers = ["BTC-USD", "ETH-USD", "SOL-USD", "AVAX-USD", "ADA-USD", "XRP-USD", "LINK-USD"]
start_date="2022-01-01"
end_date="2025-01-01"
window=30 #update portfolio every 30 days
bullish_penalty=0.2
bearish_penalty=0.8
risk_penalty=0.5

#DATA FETCHING
prices=fetch_crypto_data(tickers, start=start_date, end=end_date)
prices.to_csv("data/crypto_data.csv")
print("Data saved to data/crypto_data.csv ... :)")

#OPTIMIZATION
result=optimize_portfolio(prices, risk_penalty)

#DETECT MARKET REGIME
regime=detect_market_regime(prices["BTC-USD"])

#BACKTEST
print("\nDynamic portfolio vs Static portfolio strategy)")
result, dynamic_portfolio_return, static_portfolio_return,static_weights, dynamic_weights=backtest(prices, window, bullish_penalty, bearish_penalty)

print(f"static_weights: {static_weights}")
print(f"dynamic_weights: {dynamic_weights}")

#COMPARISON
dyn=performance_stats(dynamic_portfolio_return)
stat=performance_stats(static_portfolio_return)

results_df=pd.DataFrame({
  "Sharpe Ratio": [np.round(dyn["Sharpe Ratio"], 3),np.round(stat["Sharpe Ratio"],3)],
  "Cumulative Return[%]":[np.round(dynamic_portfolio_return.cumsum()*100, 3), np.round(static_portfolio_return.cumsum()*100, 3)],
}, index=["Dynamic Strategy", "Static Strategy"])

weights_df =pd.DataFrame({
  "Strategy": ["Dynamic Strategy", "Static Strategy"],
  **{ticker: [dynamic_weights[i], static_weights[i]] for i, ticker in enumerate(prices.columns)}
})
summary=results_df.join(weights_df.set_index("Strategy"))
print("\nPerformance comparison:")
print(summary)
summary.to_csv("data/weights.csv")

dyn_ret=np.round(dynamic_portfolio_return.cumsum().iloc[-1]*100, 2)
stat_ret=np.round(static_portfolio_return.cumsum().iloc[-1]*100, 2)

print(f"Static portfolio cumulative return: {stat_ret} %")
print(f"Dynamic portfolio cumulative return: {dyn_ret} %")
print(f"Dynamic outperformed Static of: {(dyn_ret)-(stat_ret)}%")

#RESULT SAVING
result.to_csv("data/backtest_results.csv")
print("result saved to data/backtest_results.csv")

#RESULT PLOTTING
#cumulative return of portfolios
plt.figure(figsize=(10,6))
plt.plot(dynamic_portfolio_return.index, dynamic_portfolio_return.cumsum()*100, label="Dynamic Strategy", linewidth=2)
plt.plot(static_portfolio_return.index, static_portfolio_return.cumsum()*100, label="Static Strategy", linestyle="--")
plt.title("Backtest: Dynamic vs Static Strategy - Cumulative Return")
plt.ylabel("Cumulative return [%]")
plt.legend()
plt.grid(True)
plt.savefig("plot/backtest_comparison.png", dpi=300, bbox_inches="tight")
plt.show()

#pie chart of final weights for the month
plt.figure(figsize=(10,6))
labels=[f"{t}({w:.2f}%)" for t,w in zip(tickers, dynamic_weights)]
plt.pie(dynamic_weights, labels=labels)
plt.title("Portfolio allocation (last, dynamic)")
plt.savefig("plot/asset_allocation.png", dpi=300, bbox_inches="tight")
plt.show()


);
        let mut choices64: Vec<Box<dyn Fn(&mut Unstructured, u64, usize) -> Result<Instruction>>> =
            vec![];
        choices64.push(Box::new(|u, min_size, data_len| {
            Ok(Instruction::I64Const(arbitrary_offset(
                u,
                min_size.saturating_mul(64 * 1024),
                u64::MAX,
                data_len,
            )? as i64))
        }));

        for (i, g) in self.globals[..self.globals.len() - self.defined_globals.len()]
            .iter()
            .enumerate()
        {
            if g.mutable {
                continue;
            }
            if g.val_type == ValType::I32 {
                choices32.push(Box::new(move |_, _, _| {
                    Ok(Instruction::GlobalGet(i as u32))
                }));
            } else if g.val_type == ValType::I64 {
                choices64.push(Box::new(move |_, _, _| {
                    Ok(Instruction::GlobalGet(i as u32))
                }));
            }
        }

        // Build a list of candidate memories that we'll add data initializers
        // for. If a memory doesn't have an initial size then any initializers
        // for that memory will trap instantiation, which isn't too
        // interesting. Try to make this happen less often by making it less
        // likely that a memory with 0 size will have a data segment.
        let mut memories = Vec::new();
        for (i, mem) in self.memories.iter().enumerate() {
            if mem.minimum > 0 || u.int_in_range(0..=CHANCE_SEGMENT_ON_EMPTY)? == 0 {
                memories.push(i as u32);
            }
        }

        // With memories we can generate data segments, and with bulk memory we
        // can generate passive segments. Without these though we can't create
        // a valid module with data segments.
        if memories.len() == 0 && !self.config.bulk_memory_enabled() {
            return Ok(());
        }

        arbitrary_loop(
            u,
            self.config.min_data_segments(),
            self.config.max_data_segments(),
            |u| {
                let init: Vec<u8> = u.arbitrary()?;

                // Passive data can only be generated if bulk memory is enabled.
                // Otherwise if there are no memories we *only* generate passive
                // data. Finally if all conditions are met we use an input byte to
                // determine if it should be passive or active.
                let kind = if self.config.bulk_memory_enabled()
                    && (memories.is_empty() || u.arbitrary()?)
                {
                    DataSegmentKind::Passive
                } else {
                    let memory_index = *u.choose(&memories)?;
                    let mem = &self.memories[memory_index as usize];
                    let f = if mem.memory64 {
                        u.choose(&choices64)?
                    } else {
                        u.choose(&choices32)?
                    };
                    let offset = f(u, mem.minimum, init.len())?;
                    DataSegmentKind::Active {
                        offset,
                        memory_index,
                    }
                };
                self.data.push(DataSegment { kind, init });
                Ok(true)
            },
        )


.Equal(0xFFFF0000, unchecked((uint)parsed?.ToArgb()));
			}
		}

		public class ParseSizeString
		{
			[Theory]
			[InlineData("1,2")]
			[InlineData("1;2")]
			public void ParsesHexValues(string hex)
			{
				var parsed = Utils.ParseSizeString(hex);

				Assert.NotNull(parsed);
				Assert.Equal(new Size(1, 2), parsed);
			}

			[Theory]
			[InlineData(null)]
			[InlineData("")]
			public void SupportsEmptyNull(string hex)
			{
				var parsed = Utils.ParseSizeString(hex);

				Assert.Null(parsed);
			}
		}
	}
}


end: '\"\"\"(?=[^\"])',\n      contains: [VARIABLE, SUBST]\n    }, // Can't use built-in modes easily, as we want to use STRING in the meta\n    // context as 'meta-string' and there's no syntax to remove explicitly set\n    // classNames in built-in modes.\n    {\n      begin: '\\'',\n      end: '\\'',\n      illegal: /\\n/,\n      contains: [hljs.BACKSLASH_ESCAPE]\n    }, {\n      begin: '\"',\n      end: '\"',\n      illegal: /\\n/,\n      contains: [hljs.BACKSLASH_ESCAPE, VARIABLE, SUBST]\n    }]\n  };\n  SUBST.contains.push(STRING);\n  var ANNOTATION_USE_SITE = {\n    className: 'meta',\n    begin: '@(?:file|property|field|get|set|receiver|param|setparam|delegate)\\\\s*:(?:\\\\s*' + hljs.UNDERSCORE_IDENT_RE + ')?'\n  };\n  var ANNOTATION = {\n    className: 'meta',\n    begin: '@' + hljs.UNDERSCORE_IDENT_RE,\n    contains: [{\n      begin: /\\(/,\n      end: /\\)/,\n      contains: [hljs.inherit(STRING, {\n        className: 'meta-string'\n      })]\n    }]\n  }; // https://kotlinlang.org/docs/reference/whatsnew11.html#underscores-in-numeric-literals\n  // According to the doc above, the number mode of kotlin is the same as java 8,\n  // so the code below is copied from java.js\n\n  var KOTLIN_NUMBER_MODE = NUMERIC;\n  var KOTLIN_NESTED_COMMENT = hljs.COMMENT('/\\\\*', '\\\\*/', {\n    contains: [hljs.C_BLOCK_COMMENT_MODE]\n  });\n  var KOTLIN_PAREN_TYPE = {\n    variants: [{\n      className: 'type',\n      begin: hljs.UNDERSCORE_IDENT_RE\n    }, {\n      begin: /\\(/,\n      end: /\\)/,\n      contains: [] // defined later\n\n    }]\n  };\n  var KOTLIN_PAREN_TYPE2 = KOTLIN_PAREN_TYPE;\n  KOTLIN_PAREN_TYPE2.variants[1].contains = [KOTLIN_PAREN_TYPE];\n  KOTLIN_PAREN_TYPE.variants[1].contains = [KOTLIN_PAREN_TYPE2];\n  return {\n    name: 'Kotlin',\n    aliases: ['kt'],\n    keywords: KEYWORDS,\n    contains: [hljs.COMMENT('/\\\\*\\\\*', '\\\\*/', {\n      relevance: 0,\n      contains: [{\n        className: 'doctag',\n        begin: '@[A-Za-z]+'\n      }]\n    }), hljs.C_LINE_COMMENT_MODE, KOTLIN_NESTED_COMMENT, KEYWORDS_WITH_LABEL, LABEL, ANNOTATION_USE_SITE, ANNOTATION, {\n      className: 'function',\n      beginKeywords: 'fun',\n      end: '[(]|$',\n      returnBegin: true,\n      excludeEnd: true,\n      keywords: KEYWORDS,\n      relevance: 5,\n      contains: [{\n        begin: hljs.UNDERSCORE_IDENT_RE + '\\\\s*\\\\(',\n        returnBegin: true,\n        relevance: 0,\n        contains: [hljs.UNDERSCORE_TITLE_MODE]\n      }, {\n        className: 'type',\n        begin: /</,\n        end: />/,\n        keywords: 'reified',\n        relevance: 0\n      }, {\n        className: 'params',\n        begin: /\\(/,\n        end: /\\)/,\n        endsParent: true,\n        keywords: KEYWORDS,\n        relevance: 0,\n        contains: [{\n          begin: /:/,\n          end: /[=,\\/]/,\n          endsWithParent: true,\n          contains: [KOTLIN_PAREN_TYPE, hljs.C_LINE_COMMENT_MODE, KOTLIN_NESTED_COMMENT],\n          rel


ージを聞いている、または単に目が見えない）ので、alt属性は省略することが許可されるよりむしろ、上記の例のようにまったく代替テキストが利用できず、何も利用できない場合に、置換テキストを備えるのである。著者の一部による努力の欠如は、alt属性を省略するための許容可能な理由でない。

4.8.4.3.12 ユーザーを意図しない画像

一般に、著者は画像を表示する以外の目的でimg要素を使用することは避けるべきである。

img要素が画像を表示する以外の目的で使用されている場合、たとえば、ページビューをカウントするサービスの一部として用いる場合、alt属性は空文字列でなければならない。

このような場合、widthとheight属性は、両方とも0に設定すべきである。

4.8.4.3.13 画像を閲覧できることが知られている特定の人のために意図された電子メールまたは私的文書における画像

この節は、公にアクセス可能な、すなわち、ウェブサイト上の文書、公開メーリングリストに送信された電子メール、またはソフトウェアのドキュメントなど、対象となる読者が必ずしも個人的に著者に知られていない文書には適用されない。

画像が、画像を見ることができることが知られている特定の人に向けた私的通信（たとえばHTML形式の電子メールなど）に含まれる場合、alt<


         .modify(|_, w| w.etsic().bits(trigger_config.external_trigger as u8));
                self.rb.ctl1.modify(|_, w| w.eteic().set_bit());
            }

            // TODO: discontinuous
            // TODO: constraints
            // - 单次转换模式只能有一个通道 RSQ0[4:0], ISQ3[4:0]
            // - 连续转换模式只能有一个通道 RSQ0[4:0], 只能regular
            // - 规则组扫描时必须 DMA
            // - 规则组和注入组不能同时工作在间断模式，同一时刻只能有一组被设置成间断模式。
        }
    }

    /// Applies all fields in AdcConfig
    pub fn apply_config(&mut self, config: config::AdcConfig) {
        self.config = config;
    }

    /// ADC sampling time config
    fn set_channel_sample_time(&mut self, channel: u8, sample_time: config::SampleTime) {
        match channel {
            0..=9 => unsafe {
                let mask = !(0b111 << (3 * channel));
                self.rb.sampt1.modify(|r, w| {
                    let cleared = r.bits() & mask;
                    let masked = (sample_time as u8 as u32) << (3 * channel);
                    w.bits(cleared | masked)
                });
            },
            10..=17 => unsafe {
                let mask = !(0b111 << (3 * (channel - 10)));
                self.rb.sampt0.modify(|r, w| {
                    let cleared = r.bits() & mask;
                    let masked = (sample_time as u8 as u32) << (3 * (channel - 10));
                    w.bits(cleared | masked)
                });
            },
            _ => unreachable!("invalid channel"),
        }
    }

    /// configure ADC regular channel
    ///
    /// 12 - Used in single mode
    pub fn configure_regular_channel<CHANNEL>(
        &mut self,
        rank: u8,
        _channel: &CHANNEL,
        sample_time: config::SampleTime,
    ) where
        CHANNEL: Channel<ADC0, ID = u8>,
    {
        let channel = CHANNEL::channel();

        // ADC regular sequence config
        match rank {
            0..=5 => unsafe {
                let mask = !(0b11111 << (5 * rank));
                self.rb.rsq2.modify(|r, w| {
                    let cleared = r.bits() & mask;
                    w.bits(cleared | ((rank as u32) << (5 * rank)))
                })
            },
            6..=11 => unsafe {
                let mask = !(0b11111 << (5 * (rank - 6)));
                self.rb.rsq1.modify(|r, w| {
                    let cleared = r.bits() & mask;
                    w.bits(cleared | ((rank as u32) << (5 * (rank - 6))))
                })
            },
            12..=15 => unsafe {
                let mask = !(0b11111 << (5 * (rank - 12)));
                self.rb.rsq0.modify(|r, w| {
                    let cleared = r.bits() & mask;
                    w.bits(cleared | ((rank as u32) << (5 * (rank - 12))))
                })
            },
            _ => panic!("invalid rank"),
        }
        // ADC sampling time config
        self.set_channel_sample_time(channel, sample_time);
    }

    /// configure ADC inserted channel
    ///
    /// - 0 -> ISQ3
    /// - 1 -> ISQ2
    /// - 2 -> ISQ1
    /// - 3 -> ISQ0
    pub fn configure_inserted_channel<CHANNEL>(
        &mut self,
        rank: u8,
        _channel: &CHANNEL,
        sample_time: config::SampleTime,
    ) where
        CHANNEL: Channel<ADC0, ID = u8>,
    {
        // Check the sequence is long


 #E03997;
  color: #E03997;
}

.ui.basic.labels a.pink.label:hover,
a.ui.ui.ui.basic.pink.label:hover {
  background: none #FFFFFF;
  border-color: #e61a8d;
  color: #e61a8d;
}

/* Inverted */

.ui.inverted.labels .pink.label,
.ui.ui.ui.inverted.pink.label {
  background-color: #FF8EDF;
  border-color: #FF8EDF;
  color: #1B1C1D;
}

/* Inverted Link */

.ui.inverted.labels a.pink.label:hover,
a.ui.ui.ui.inverted.pink.label:hover {
  background-color: #ff5bd1;
  border-color: #ff5bd1;
  color: #1B1C1D;
}

/* Inverted Ribbon */

.ui.ui.ui.inverted.pink.ribbon.label {
  border-color: #ff5bd1;
}

/* Inverted Basic */

.ui.inverted.basic.labels .pink.label,
.ui.ui.ui.inverted.basic.pink.label {
  background-color: #1B1C1D;
  border-color: #FF8EDF;
  color: #FF8EDF;
}

.ui.inverted.basic.labels a.pink.label:hover,
a.ui.ui.ui.inverted.basic.pink.label:hover {
  border-color: #ff5bd1;
  background-color: #1B1C1D;
  color: #ff5bd1;
}

/* Inverted Basic Tags */

.ui.inverted.basic.tag.labels .pink.label,
.ui.ui.ui.inverted.pink.basic.tag.label {
  border: 1px solid #FF8EDF;
}

.ui.inverted.basic.tag.labels .pink.label:before,
.ui.ui.ui.inverted.pink.basic.tag.label:before {
  border-color: inherit;
  border-width: 1px 0 0 1px;
  border-style: inherit;
  background-color: #1B1C1D;
  right: calc(100% + 1px);
}

.ui.brown.labels .label,
.ui.ui.ui.brown.label {
  background-color: #A5673F;
  border-color: #A5673F;
  color: #FFFFFF;
}

/* Link */

.ui.brown.labels a.label:hover,
a.ui.ui.ui.brown.label:hover {
  background-color: #975b33;
  border-color: #975b33;
  color: #FFFFFF;
}

/* Ribbon */

.ui.ui.ui.brown.ribbon.label {
  border-color: #805031;
}

/* Basic */

.ui.basic.labels .brown.label,
.ui.ui.ui.basic.brown.label {
  background: none #FFFFFF;
  border-color: #A5673F;
  color: #A5673F;
}

.ui.basic.labels a.brown.label:hover,
a.ui.ui.ui.basic.brown.label:hover {
  background: none #FFFFFF;
  border-color: #975b33;
  color: #975b33;
}

/* Inverted */

.ui.inverted.labels .brown.label,
.ui.ui.ui.inverted.brown.label {
  background-color: #D67C1C;
  border-color: #D67C1C;
  color: #1B1C1D;
}

/* Inverted Link */

.ui.inverted.labels a.brown.label:hover,
a.ui.ui.ui.inverted.brown.label:hover {
  background-c


    //   -- optional, attemp to reload the given path, return true if handled
    //
    // object plugin.analyze()
    //   -- optional, returns plugin-specific information about the current document (to send to the connected server)
    //      (LiveReload 2 server currently only defines 'disable' key in this object; return {disable:true} to disable server-side
    //       compilation of a matching plugin's files)

    this.plugins.push(plugin);
    this.reloader.addPlugin(plugin);
  }

  analyze () {
    if (!this.initialized) {
      return;
    }

    if (!(this.connector.protocol >= 7)) {
      return;
    }

    const pluginsData = {};

    for (const plugin of this.plugins) {
      const pluginData = (typeof plugin.analyze === 'function' ? plugin.analyze() : undefined) || {};

      pluginsData[plugin.constructor.identifier] = pluginData;
      pluginData.version = plugin.constructor.version;
    }

    this.connector.sendCommand({
      command: 'info',
      plugins: pluginsData,
      url: this.window.location.href
    });
  }
};

exports.LiveReload = LiveReload;
class LessPlugin {
  constructor (window, host) {
    this.window = window;
    this.host = host;
  }

  reload (path, options) {
    if (this.window.less && this.window.less.refresh) {
      if (path.match(/\.less$/i)) {
        return this.reloadLess(path);
      }

      if (options.originalPath.match(/\.less$/i)) {
        return this.reloadLess(options.originalPath);
      }
    }

    return false;
  }

  reloadLess (path) {
    let link;

    const links = ((() => {
      const result = [];

      for (link of Array.from(document.getElementsByTagName('link'))) {
        if ((link.href && link.rel.match(/^stylesheet\/less$/i)) || (link.rel.match(/stylesheet/i) && link.type.match(/^text\/(x-)?less$/i))) {
          result.push(link);
        }
      }

      return result;
    })());

    if (links.length === 0) {
      return false;
    }

    for (link of Array.from(links)) {
      link.href = this.host.generateCacheBustUrl(link.href);
    }

    this.host.console.log('LiveReload is asking LESS to recompile all stylesheets');
    this.window.less.refresh(true);

    return true;
  }

  analyze () {
    return {
      disable: !!(this.window.less && this.window.less.refresh)
    };
  }
};

LessPlugin.identifier = 'less';
LessPlugin.version = '1.0';

module.exports = LessPlugin;
//@ts-check
// Helpers to work with different data types
// by Humans for All
//

/**
 * Given the limited context size of local LLMs and , many a times when context gets filled
 * between the prompt and the response, it can lead to repeating text garbage generation.
 * And many a times setting penalty wrt repeatation leads to over-intelligent garbage
 * repeatation with slight variations. These garbage inturn can lead to overloading of the
 * available model context, leading to less valuable response for subsequent prompts/queries,
 * if chat history is sent to ai model.
 *
 * So two simple minded garbage trimming logics are experimented below.
 * * one based on progressively-larger-substring-based-repeat-matching-with-partial-skip and
 * * another based on char-histogram-driven garbage trimming.
 *   * in future characteristic of histogram over varying lengths could be used to allow for
 *     a more aggressive and adaptive trimming logic.
 */

/**
 * Simple minded logic to help remove repeating garbage at end of the string.
 * The repeatation needs to be perfectly matching.
 *


func Decode(src []byte) (inst Inst, err error) {
	if len(src) < 4 {
		return Inst{}, errShort
	}

	x := binary.LittleEndian.Uint32(src)

Search:
	for i := range instFormats {
		f := &instFormats[i]

		if (x & f.mask) != f.value {
			continue
		}

		// Decode args.
		var args Args
		for j, aop := range f.args {
			if aop == 0 {
				break
			}

			arg := decodeArg(aop, x, i)
			if arg == nil {
				// Cannot decode argument
				continue Search
			}

			args[j] = arg
		}

		decoderCover[i] = true
		inst = Inst{
			Op:   f.op,
			Args: args,
			Enc:  x,
		}
		return inst, nil
	}

	return Inst{}, errUnknown
}

// decodeArg decodes the arg described by aop from the instruction bits x.
// It returns nil if x cannot be decoded according to aop.
func decodeArg(aop instArg, x uint32, index int) Arg {
	switch aop {
	case arg_fd:
		return F0 + Reg(x&((1<<5)-1))

	case arg_fj:
		return F0 + Reg((x>>5)&((1<<5)-1))

	case arg_fk:
		return F0 + Reg((x>>10)&((1<<5)-1))

	case arg_fa:
		return F0 + Reg((x>>15)&((1<<5)-1))

	case arg_rd:
		return R0 + Reg(x&((1<<5)-1))

	case arg_rj:
		return R0 + Reg((x>>5)&((1<<5)-1))

	case arg_rk:
		return R0 + Reg((x>>10)&((1<<5)-1))

	case arg_fcsr_4_0:
		return FCSR0 + Fcsr(x&((1<<5)-1))

	case arg_fcsr_9_5:
		return FCSR0 + Fcsr((x>>5)&((1<<5)-1))

	case arg_cd:
		return FCC0 + Fcc(x&((1<<3)-1))

	case arg_cj:
		return FCC0 + Fcc((x>>5)&((1<<3)-1))

	case arg_ca:
		return FCC0 + Fcc((x>>15)&((1<<3)-1))

	case arg_op_4_0:
		tmp := x & ((1 << 5) - 1)
		return Uimm{tmp, false}

	case arg_csr_23_10:
		tmp := (x >> 10) & ((1 << 14) - 1)
		return Uimm{tmp, false}

	case arg_sa2_16_15:
		f := &instFormats[index]
		tmp := SaSimm((x >> 15) & ((1 << 2) - 1))
		if (f.op == ALSL_D) || (f.op == ALSL_W) || (f.op == ALSL_WU) {
			return tmp + 1
		} else {
			return tmp + 0
		}

	case arg_sa3_17_15:
		return SaSimm((x >> 15) & ((1 << 3) - 1))

	case arg_code_4_0:
		return CodeSimm(x & ((1 << 5) - 1))

	case arg_code_14_0:
		return CodeSimm(x & ((1 << 15) - 1))

	case arg_ui5_14_10:
		tmp := (x >> 10) & ((1 << 5) - 1)
		return Uimm{tmp, false}

	case arg_ui6_15_10:
		tmp := (x >> 10) & ((1 << 6) - 1)
		return Uimm{tmp, false}

	case arg_ui12_21_10:
		tmp := ((x >> 10) & ((1 << 12) - 1) & 0xfff)
		return Uimm{tmp, false}

	case arg_lsbw:
		tmp := (x >> 10) & ((1 << 5) - 1)
		return Uimm{tmp, false}

	case arg_msbw:
		tmp := (x >> 16) & ((1 << 5) - 1)
		return Uimm{tmp, false}

	case arg_lsbd:
		tmp := (x >> 10) & ((1 << 6) - 1)
		return Uimm{tmp, false}

	case arg_msbd:
		tmp := (x >> 16) & ((1 << 6) - 1)


2, X15);
	xor_src_dst(DST, SRC, (64 * 3 + 16 * 0), X3, X15);
	transpose_4x4(X4, X5, X6, X7, X0, X1, X2);
	movdqa (STACK_TMP)(%rsp), X13;
	movdqa (STACK_TMP1)(%rsp), X14;
	movdqa (STACK_TMP2)(%rsp), X15;
	xor_src_dst(DST, SRC, (64 * 0 + 16 * 1), X4, X0);
	xor_src_dst(DST, SRC, (64 * 1 + 16 * 1), X5, X0);
	xor_src_dst(DST, SRC, (64 * 2 + 16 * 1), X6, X0);
	xor_src_dst(DST, SRC, (64 * 3 + 16 * 1), X7, X0);
	transpose_4x4(X8, X9, X10, X11, X0, X1, X2);
	xor_src_dst(DST, SRC, (64 * 0 + 16 * 2), X8, X0);
	xor_src_dst(DST, SRC, (64 * 1 + 16 * 2), X9, X0);
	xor_src_dst(DST, SRC, (64 * 2 + 16 * 2), X10, X0);
	xor_src_dst(DST, SRC, (64 * 3 + 16 * 2), X11, X0);
	transpose_4x4(X12, X13, X14, X15, X0, X1, X2);
	xor_src_dst(DST, SRC, (64 * 0 + 16 * 3), X12, X0);
	xor_src_dst(DST, SRC, (64 * 1 + 16 * 3), X13, X0);
	xor_src_dst(DST, SRC, (64 * 2 + 16 * 3), X14, X0);
	xor_src_dst(DST, SRC, (64 * 3 + 16 * 3), X15, X0);

	subq $4, (STACK_MAX + 7 * 8)(%rsp); # NBLKS

	lea (4 * 64)(DST), DST;
	lea (4 * 64)(SRC), SRC;
	movq SRC, (STACK_MAX + 5 * 8)(%rsp);
	movq DST, (STACK_MAX + 6 * 8)(%rsp);

	jnz .Loop_poly4;

	/* Store state */
	POLY1305_STORE_STATE();

	/* clear the used vector registers and stack */
	clear(X0);
	movdqa X0, (STACK_VEC_X12)(%rsp);
	movdqa X0, (STACK_VEC_X13)(%rsp);
	movdqa X0, (STACK_TMP)(%rsp);
	movdqa X0, (STACK_TMP1)(%rsp);
	movdqa X0, (STACK_TMP2)(%rsp);
	clear(X1);
	clear(X2);
	clear(X3);
	clear(X4);
	clear(X5);
	clear(X6);
	clear(X7);
	clear(X8);
	clear(X9);
	clear(X10);
	clear(X11);
	clear(X12);
	clear(X13);
	clear(X14);
	clear(X15);

	movq (STACK_MAX + 0 * 8)(%rsp), %rbx;
	movq (STACK_MAX + 1 * 8)(%rsp), %r12;
	movq (STACK_MAX + 2 * 8)(%rsp), %r13;
	movq (STACK_MAX + 3 * 8)(%rsp), %r14;
	movq (STACK_MAX + 4 * 8)(%rsp), %r15;
	CFI_RESTORE(%rbx);
	CFI_RESTORE(%r12);
	CFI_RESTORE(%r13);
	CFI_RESTORE(%r14);
	CFI_RESTORE(%r15);

	xorl %eax, %eax


   + "\ua788\ua788"
        + "\ua8c4\ua8c4"
        + "\ua8e0\ua8f1"
        + "\ua92b\ua92e"
        + "\ua953\ua953"
        + "\ua9b3\ua9b3"
        + "\ua9c0\ua9c0"
        + "\uaa7b\uaa7b"
        + "\uaabf\uaac2"
        + "\uabec\uabed"
        + "\ufb1e\ufb1e"
        + "\ufe20\ufe26"
        + "\uff3e\uff3e"
        + "\uff40\uff40"
        + "\uff70\uff70"
        + "\uff9e\uff9f"
        + "\uffe3\uffe3"
        + "\ud804\udcb9\ud804\udcba"
        + "\ud834\udd67\ud834\udd69"
        + "\ud834\udd6d\ud834\udd72"
        + "\ud834\udd7b\ud834\udd82"
        + "\ud834\udd85\ud834\udd8b"
        + "\ud834\uddaa\ud834\uddad",
    // Unicode 6.0 property value: {egyptianhieroglyphs}
    "\ud80c\udc00\ud80d\udc2e",
    // Unicode 6.0 property value: {ethiopic}
    "\u1200\u1248"
        + "\u124a\u124d"
        + "\u1250\u1256"
        + "\u1258\u1258"
        + "\u125a\u125d"
        + "\u1260\u1288"
        + "\u128a\u128d"
        + "\u1290\u12b0"
        + "\u12b2\u12b5"
        + "\u12b8\u12be"
        + "\u12c0\u12c0"
        + "\u12c2\u12c5"
        + "\u12c8\u12d6"
        + "\u12d8\u1310"
        + "\u1312\u1315"
        + "\u1318\u135a"
        + "\u135d\u137c"
        + "\u1380\u1399"
        + "\u2d80\u2d96"
        + "\u2da0\u2da6"
        + "\u2da8\u2dae"
        + "\u2db0\u2db6"
        + "\u2db8\u2dbe"
        + "\u2dc0\u2dc6"
        + "\u2dc8\u2dce"
        + "\u2dd0\u2dd6"
        + "\u2dd8\u2dde"
        + "\uab01\uab06"
        + "\uab09\uab0e"
        + "\uab11\uab16"
        + "\uab20\uab26"
        + "\uab28\uab2e",
    // Unicode 6.0 property value: {extender}
    "\u00b7\u00b7"
        + "\u02d0\u02d1"
        + "\u0640\u0640"
        + "\u07fa\u07fa"
        + "\u0e46\u0e46"
        + "\u0ec6\u0ec6"
        + "\u1843\u1843"
        + "\u1aa7\u1aa7"
        + "\u1c36\u1c36"
        + "\u1c7b\u1c7b"
        + "\u3005\u3005"
        + "\u3031\u3035"


4s24 10.7 24 24l0 64 64 0c13.3 0 24 10.7 24 24s-10.7 24-24 24l-64 0 0 64c0 13.3-10.7 24-24 24s-24-10.7-24-24z"],
    "arrows-left-right": [576, 512, ["arrows-h"], "f07e", "M470.6 374.6l96-96c12.5-12.5 12.5-32.8 0-45.3l-96-96c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l41.4 41.4-357.5 0 41.4-41.4c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0l-96 96c-6 6-9.4 14.1-9.4 22.6s3.4 16.6 9.4 22.6l96 96c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3l-41.4-41.4 357.5 0-41.4 41.4c-12.5 12.5-12.5 32.8 0 45.3s32.8 12.5 45.3 0z"],
    "fan": [512, 512, [], "f863", "M160 144c0-79.5 64.5-144 144-144 8.8 0 16 7.2 16 16l0 152.2c15-5.3 31.2-8.2 48-8.2 79.5 0 144 64.5 144 144 0 8.8-7.2 16-16 16l-152.2 0c5.3 15 8.2 31.2 8.2 48 0 79.5-64.5 144-144 144-8.8 0-16-7.2-16-16l0-152.2c-15 5.3-31.2 8.2-48 8.2-79.5 0-144-64.5-144-144 0-8.8 7.2-16 16-16l152.2 0c-5.3-15-8.2-31.2-8.2-48zm96 144a32 32 0 1 0 0-64 32 32 0 1 0 0 64z"],
    "crow": [640, 512, [], "f520", "M456.5 0c-48.6 0-88 39.4-88 88l0 36-355.2 266.4C-.8 401-3.7 421 6.9 435.2s30.6 17 44.8 6.4l76.8-57.6 131.3 0 46.6 113.1 1 2.2c5.7 10.7 18.8 15.5 30.3 10.8s17.3-17.3 13.9-29l-.8-2.3-39.1-94.9 40.9 0c1.1 0 2.2 0 3.2 0l46.6 113.2 1 2.2c5.7 10.7 18.8 15.5 30.3 10.8s17.3-17.3 13.9-29l-.8-2.3-42-102C485.3 354.1 544.5 280 544.5 192l0-72 80.5-20.1c8.6-2.1 13.8-10.8 11.6-19.4-7.1-28.5-32.7-48.5-62.1-48.5l-50.1 0C508.2 12.5 483.8 0 456.5 0zm0 64a24 24 0 1 1 0 48 24 24 0 1 1 0-48z"],
    "file-circle-check": [576, 512, [], "e5a0", "M96 0C60.7 0 32 28.7 32 64l0 384c0 35.3 28.7 64 64 64l180 0c-22.7-31.5-36-70.2-36-112 0-100.6 77.4-183.2 176-191.3l0-38.1c0-17-6.7-33.3-18.


ZXMiOlsiQW1wU3RhdGVDb250ZXh0IiwiUmVhY3QiLCJjcmVhdGVDb250ZXh0IiwicHJvY2VzcyIsImVudiIsIk5PREVfRU5WIiwiZGlzcGxheU5hbWUiXSwiaWdub3JlTGlzdCI6W10sInNvdXJjZVJvb3QiOiIifQ==\n//# sourceURL=webpack-internal:///(app-pages-browser)/./node_modules/next/dist/shared/lib/amp-context.shared-runtime.js\n"));

/***/ }),

/***/ "(app-pages-browser)/./node_modules/next/dist/shared/lib/amp-mode.js":
/*!*******************************************************!*\
  !*** ./node_modules/next/dist/shared/lib/amp-mode.js ***!
  \*******************************************************/
/***/ ((module, exports, __webpack_require__) => {

"use strict";
eval(__webpack_require__.ts("\nObject.defineProperty(exports, \"__esModule\", ({\n    value: true\n}));\nObject.defineProperty(exports, \"isInAmpMode\", ({\n    enumerable: true,\n    get: function() {\n        return isInAmpMode;\n    }\n}));\nfunction isInAmpMode(param) {\n    let { ampFirst = false, hybrid = false, hasQuery = false } = param === void 0 ? {} : param;\n    return ampFirst || hybrid && hasQuery;\n} //# sourceMappingURL=amp-mode.js.map\n\n\n;\n    // Wrapped in an IIFE to avoid polluting the global scope\n    ;\n    (function () {\n        var _a, _b;\n        // Legacy CSS implementations will `eval` browser code in a Node.js context\n        // to extract CSS. For backwards compatibility, we need to check we're in a\n        // browser context before continuing.\n        if (typeof self !== 'undefined' &&\n            // AMP / No-JS mode does not inject these helpers:\n            '$RefreshHelpers$' in self) {\n            // @ts-ignore __webpack_module__ is global\n            var currentExports = module.exports;\n            // @ts-ignore __webpack_module__ is global\n            var prevSignature = (_b = (_a = module.hot.data) === null || _a === void 0 ? void 0 : _a.prevSignature) !== null && _b !== void 0 ? _b : null;\n            // This cannot happen in MainTemplate because the exports mismatch between\n            // templating and execution.\n            self.$RefreshHelpers$.registerExportsForReactRefresh(currentExports, module.id);\n            // A module can be accepted automatically based on its exports, e.g. when\n            // it is a Refresh Boundary.\n            if (self.$RefreshHelpers$.isReactRefreshBoundary(currentExports)) {\n                // Save the previous exports signature on update so we can compare the boundary\n                // signatures. We avoid saving exports themselves since it causes memory leaks (https://github.com/vercel/next.js/pull/53797)\n                module.hot.dispose(function (data) {\n                    data.prevSignature =\n                        self.$RefreshHelpers$.getRefreshBoundarySignature(currentExports);\n                });\n                // Unconditionally accept an update to this module, we'll check if it's\n                // still a Refresh Boundary later.\n                // @ts-ignore importMeta is replaced in the loader\n                module.hot.accept();\n                // This field is set when the previous version of this module was a\n


ove log.
    /// let replica = Replica::<Data>::new(vec![log]);
    /// ```
    pub fn new<'b>(
        logs: Vec<Arc<Log<'b, <D as Dispatch>::WriteOperation>>>,
    ) -> Arc<Replica<'b, D>> {
        let mut uninit_replica: Arc<MaybeUninit<Replica<D>>> = Arc::new_zeroed();

        // This is the preferred but unsafe mode of initialization as it avoids
        // putting the (often big) Replica object on the stack first.
        unsafe {
            let uninit_ptr = Arc::get_mut_unchecked(&mut uninit_replica).as_mut_ptr();
            let nlogs = logs.len();
            // Register the replica with all the logs.
            let mut idx = Vec::with_capacity(nlogs);
            for log in logs.iter() {
                idx.push(log.register().unwrap());
            }
            // Allocate a combiner for each log.
            let mut combiners = Vec::with_capacity(nlogs);
            let mut pending = Vec::with_capacity(nlogs);
            for _i in 0..nlogs {
                combiners.push(CachePadded::new(AtomicUsize::new(0)));
                pending.push(arr![CachePadded::new(AtomicBool::new(false)); 256]);
            }

            uninit_ptr.write(Replica {
                idx,
                combiners,
                next: CachePadded::new(AtomicUsize::new(1)),
                contexts: Vec::with_capacity(MAX_THREADS_PER_REPLICA),
                pending,
                buffer: vec![
                    CachePadded::new(RefCell::new(
                        Vec::with_capacity(
                            MAX_THREADS_PER_REPLICA
                                * Context::<
                                    <D as Dispatch>::WriteOperation,
                                    <D as Dispatch>::Response,
                                >::batch_size(),
                        ),
                    ));
                    nlogs
                ],
                inflight: vec![
                    CachePadded::new(RefCell::new(arr![Default::default(); 256]));
                    nlogs
                ],
                result: vec![
                    CachePadded::new(RefCell::new(
                        Vec::with_capacity(
                            MAX_THREADS_PER_REPLICA
                                * Context::<
                                    <D as Dispatch>::WriteOperation,
                                    <D as Dispatch>::Response,
                                >::batch_size(),
                        ),
                    ));
                    nlogs
                ],
                slog: logs.clone(),
                data: CachePadded::new(D::default()),
            });

            let mut replica = uninit_replica.assume_init();
            // Add `MAX_THREADS_PER_REPLICA` contexts
            for _idx in 0..MAX_THREADS_PER_REPLICA {
                Arc::get_mut(&mut replica)
                    .unwrap()
                    .contexts
                    .push(Default::default());
            }

            replica
        }
    }

    /// Registers a thread with this replica. Returns an idx inside an Option if the registration
    /// was successfull. None if the registration failed.
    ///
    /// # Example
    ///
    /// ```
    /// use cnr::Dispatch;
    /// use cnr::Log;
    /// use cnr::LogMapper;
    /// use cnr::Replica;
    ///
    /// use core::sync::atomic::{AtomicUsize, Ordering};
    /// use std::sync::Arc;
    ///
    /// #[derive(Default)]
    /// struct Data {
    ///     junk: AtomicUsize,
    /// }
    ///
    /// #[derive(Debug


 tipo;
  final int? coo;
  EcfDocumentosEmitidos(
      {this.id,
      this.idPdvMovimento,
      this.dataEmissao,
      this.horaEmissao,
      this.tipo,
      this.coo});
  factory EcfDocumentosEmitidos.fromData(Map<String, dynamic> data,
      {String? prefix}) {
    final effectivePrefix = prefix ?? '';
    return EcfDocumentosEmitidos(
      id: const IntType().mapFromDatabaseResponse(data['${effectivePrefix}ID']),
      idPdvMovimento: const IntType()
          .mapFromDatabaseResponse(data['${effectivePrefix}ID_PDV_MOVIMENTO']),
      dataEmissao: const DateTimeType()
          .mapFromDatabaseResponse(data['${effectivePrefix}DATA_EMISSAO']),
      horaEmissao: const StringType()
          .mapFromDatabaseResponse(data['${effectivePrefix}HORA_EMISSAO']),
      tipo: const StringType()
          .mapFromDatabaseResponse(data['${effectivePrefix}TIPO']),
      coo: const IntType()
          .mapFromDatabaseResponse(data['${effectivePrefix}COO']),
    );
  }
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (!nullToAbsent || id != null) {
      map['ID'] = Variable<int?>(id);
    }
    if (!nullToAbsent || idPdvMovimento != null) {
      map['ID_PDV_MOVIMENTO'] = Variable<int?>(idPdvMovimento);
    }
    if (!nullToAbsent || dataEmissao != null) {
      map['DATA_EMISSAO'] = Variable<DateTime?>(dataEmissao);
    }
    if (!nullToAbsent || horaEmissao != null) {
      map['HORA_EMISSAO'] = Variable<String?>(horaEmissao);
    }
    if (!nullToAbsent || tipo != null) {
      map['TIPO'] = Variable<String?>(tipo);
    }
    if (!nullToAbsent || coo != null) {
      map['COO'] = Variable<int?>(coo);
    }
    return map;
  }

  EcfDocumentosEmitidossCompanion toCompanion(bool nullToAbsent) {
    return EcfDocumentosEmitidossCompanion(
      id: id == null && nullToAbsent ? const Value.absent() : Value(id),
      idPdvMovimento: idPdvMovimento == null && nullToAbsent
          ? const Value.absent()
          : Value(idPdvMovimento),
      dataEmissao: dataEmissao == null && nullToAbsent
          ? const Value.absent()
          : Value(dataEmissao),
      horaEmissao: horaEmissao == null && nullToAbsent
          ? const Value.absent()
          : Value(horaEmissao),
      tipo: tipo == null && nullToAbsent ? const Value.absent() : Value(tipo),
      coo: coo == null && nullToAbsent ? const Value.absent() : Value(coo),
    );
  }

  factory EcfDocumentosEmitidos.fromJson(Map<String, dynamic> json,
      {ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return EcfDocumentosEmitidos(
      id: serializer.fromJson<int?>(json['id']),
      idPdvMovimento: serializer.fromJson<int?>(json['idPdvMovimento']),
      dataEmissao: serializer.fromJson<DateTime?>(json['dataEmissao']),
      horaEmissao: serializer.fromJson<String?>(json['horaEmissao']),
      tipo: serializer.fromJson<String?>(json['tipo']),
      coo: seri


     icon: const Icon(fluent.FluentIcons.settings),
            title: Text('common.settings'.i18n),
            body: const SettingsPage(),
            onTap: () {
              router.go('/settings');
            },
          ),
        ],
        items: [
          fluent.PaneItem(
            icon: const Icon(fluent.FluentIcons.home),
            title: Text('common.home'.i18n),
            body: const HomePage(),
            onTap: () {
              router.go('/');
            },
          ),
          fluent.PaneItem(
            icon: const Icon(fluent.FluentIcons.search),
            title: Text('common.search'.i18n),
            body: const SearchPage(),
            onTap: () {
              router.go('/search');
            },
          ),
          fluent.PaneItem(
            icon: const Icon(fluent.FluentIcons.add_in),
            title: Text('common.extension'.i18n),
            body: const ExtensionPage(),
            onTap: () {
              router.go('/extension');
            },
          ),
        ],
      ),
    );
  }

  @override
  void onWindowResize() {
    WindowManager.instance.getSize().then((value) {
      MiruStorage.setSetting(
        SettingKey.windowSize,
        "${value.width},${value.height}",
      );
    });
  }

  @override
  void onWindowMove() {
    WindowManager.instance.getPosition().then((value) {
      MiruStorage.setSetting(
        SettingKey.windowPosition,
        "${value.dx},${value.dy}",
      );
    });
  }
}

class AndroidMainPage extends fluent.StatefulWidget {
  const AndroidMainPage({super.key});

  @override
  fluent.State<AndroidMainPage> createState() => _AndroidMainPageState();
}

class _AndroidMainPageState extends fluent.State<AndroidMainPage> {
  late MainController c;

  final pages = const [
    HomePage(),
    SearchPage(),
    ExtensionPage(),
    SettingsPage(),
  ];

  @override
  void initState() {
    c = Get.put(MainController());
    logger.info("${MiruStorage.getSetting(SettingKey.firstTimeSetup)}");
    WidgetsBinding.instance.addPostFrameCallback((_) {
      if (MiruStorage.getSetting(SettingKey.firstTimeSetup) ||
          !MiruStorage.getSetting(SettingKey.isNotificationGranted) ||
          MiruStorage.getSetting(SettingKey.downloadPath) == '') {
        Get.to(() => const AndroidWelcomePage());
        MiruStorage.setSetting(SettingKey.firstTimeSetup, false);
      }
    });
    if (MiruStorage.getSetting(SettingKey.autoCheckUpdate)) {
      ApplicationUtils.checkUpdate(context);
    }
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    List<_Destination> destinations = <_Destination>[
      _Destination(Icons.home_outlined, Icons.home, 'common.home'.i18n),
      _Destination(Icons.search_outlined, Icons.search, 'common.search'.i18n),
      _Destination(
          Icons.extension_outlined, Icons.extension, 'common.extension'.i18n),
      _Destination(
          Icons.settings_outlined, Icons.settings, 'common.settings'.i18n),
    ];
    return Obx(
      () => Scaffold(
        body: LayoutUtils.isTablet
            ? Row(
                children: [
                  NavigationRail(
                    groupAlignment: 0,
                    labelType: NavigationRailLabelType.all,
                    destinations: destinations
                        .map((e) => NavigationRailDestination(
                              icon: Icon(e.icon),
                              selectedIcon: Icon(e.selectedIcon),
                              label


 "Conditional";

  constructor(
    public readonly cond: Var<boolean, T>,
    public readonly actionThen: Action<T>[],
    public readonly actionElse: Action<T>[],
  ) {}
}

export class StoreVar<T> {
  public readonly tag: "StoreVar" = "StoreVar";

  constructor(
    public readonly v: Var<number, T>,
    public readonly name: string,
    public readonly count: number,
  ) {}
}

export class ClearVar {
  public readonly tag: "ClearVar" = "ClearVar";

  constructor(
    public readonly name: string,
  ) {}
}

export class RemoveStatus<T> {
  public readonly tag: "RemoveStatus" = "RemoveStatus";

  constructor(
    public readonly sType: StatusType,
    public readonly amount: Var<number, T>,
    public readonly target: T,
  ) {}
}

export class ActionFrom<T> {
  public readonly tag: "ActionFrom" = "ActionFrom";

  constructor(
    public readonly from: "up" | "down" | "left" | "right",
    public readonly target: T,
  ) {}
}

export class ChangeTo<T> {
  public readonly tag: "ChangeTo" = "ChangeTo";

  constructor(
    public readonly name: Ability["name"],
    public readonly target: T,
  ) {}
}

export class RegenAllStatuses<T> {
  public readonly tag: "RegenAllStatuses" = "RegenAllStatuses";

  constructor(
    public readonly value: Var<number, T>,
  ) {}
}

export class MoveDir<T> {
  public readonly tag: "MoveDir" = "MoveDir";

  constructor(
    public readonly dir: Dir,
    public readonly target: T,
  ) {}
}

export class GoTo<T> {
  public readonly tag: "GoTo" = "GoTo";

  constructor(
    public readonly i: number,
    public readonly target: T,
  ) {}
}

export type Action<T>
  = Regen<T>
  | Summon
  | Damage<T>
  | Cost<T>
  | Lower<T>
  | ChangeShield<T>
  | AddStatus<T>
  | Death<T>
  | NoAction
  | EndTurn<T>
  | Conditional<T>
  | StoreVar<T>
  | ClearVar
  | RemoveStatus<T>
  | ActionFrom<T>
  | ChangeTo<T>
  | RegenAllStatuses<T>
  | MoveDir<T>
  | GoTo<T>
  ;
import IDisciplina from '../interfaces/disciplinaInterface'
import PostgresClient from '../providers/postgresClient'

export default class DisciplinaRepository {
  static selectList = 'id, codigo, nome, criado_em AS "criadoEm", atualizado_em AS "atualizadoEm"'

  static async findOneById(id: string): Promise<IDisciplina> {
    const sql = `
    SELECT
      ${DisciplinaRepository.selectList}
    FROM
      disciplina
    WHERE
      excluido_em IS NULL
      AND id = :id`

    const binds = { id }

    const result = await PostgresClient.query(sql, binds)

    return result.rows[0]

  }

  static async findAll(): Promise<IDisciplina[]> {
    const sql = `
    SELECT
      ${DisciplinaRepository.selectList}
    FROM
      disciplina
    WHERE
      excluido_em IS NULL`
    const result = await PostgresClient.query(sql)
    return result.rows
  }

  static async save(disciplina: any): Promise<IDisciplina> {
    const sql = `
    INSERT INTO
      disciplina (
        codigo, nome
      )
    VALUES (
      :codigo, :nome
    )
    RETURNING id`
    const result = await PostgresClient.query(sql, disciplina)
    return DisciplinaRepository.findOneById(result.rows[0].id)
  }

  static async update(id: string, disciplina: any): Promise<IDisciplina> {
    const values: string[] = []

    if (disciplina.codigo) {
      val


(progressbar) == "table" then
		for i=1,#progressbar do
			dgsProgressBarSetStyle(progressbar[i],style,settingTable)
		end
		return true
	end
	if not dgsIsType(progressbar,"dgs-dxprogressbar") then error(dgsGenAsrt(progressbar,"dgsProgressBarSetStyle",1,"dgs-dxprogressbar")) end
	if ProgressBarStyle[style] then
		dgsSetData(progressbar,"style",style)
		local eleData = dgsElementData[progressbar]
		for k,v in pairs(eleData.elements or {}) do
			destroyElement(v)
		end
		if style == "ring-round" then
			eleData.elements = {}
			eleData.elements.circleShader = dxCreateShader(ProgressBarShaders["ring-round"])
			eleData.elements.circleShaderBG = dxCreateShader(ProgressBarShaders["ring-round"])
			eleData.isClockwise = false
			eleData.antiAliased = 0.005
			eleData.rotation = 0
			eleData.radius = 0.2
			eleData.thickness = 0.02
			eleData.bgRotation = nil
			eleData.bgRadius = nil
			eleData.bgThickness = nil
			eleData.bgProgress = nil
		elseif style == "ring-plain" then
			eleData.elements = {}
			eleData.elements.circleShader = dxCreateShader(ProgressBarShaders["ring-plain"])
			eleData.elements.circleShaderBG = dxCreateShader(ProgressBarShaders["ring-plain"])
			eleData.isClockwise = false
			eleData.rotation = 0
			eleData.antiAliased = 0.005
			eleData.radius = 0.2
			eleData.thickness = 0.02
			eleData.bgRotation = nil
			eleData.bgRadius = nil
			eleData.bgThickness = nil
			eleData.bgProgress = nil
		end
		for k,v in pairs(settingTable or {}) do
			dgsElementData[progressbar][k] = v
		end
		return true
	end
	return false
end

function dgsProgressBarGetStyle(progressbar)
	if not dgsIsType(progressbar,"dgs-dxprogressbar") then error(dgsGenAsrt(progressbar,"dgsProgressBarGetStyle",1,"dgs-dxprogressbar")) end
	return dgsElementData[progressbar].style
end

function dgsProgressBarGetProgress(progressbar,isAbsolute)
	if not dgsIsType(progressbar,"dgs-dxprogressbar") then error(dgsGenAsrt(progressbar,"dgsProgressBarGetProgress",1,"dgs-dxprogressbar")) end
	local progress = dgsElementData[progressbar].progress
	local scaler = dgsElementData[progressbar].map
	if not isAbsolute then
		progress = progress/100*(scaler[2]-scaler[1])+scaler[1]
	end
	return progress
end

function dgsProgressBarSetProgress(progressbar,progress,isAbsolute)
	if not dgsIsType(progressbar,"dgs-dxprogressbar") then error(dgsGenAsrt(progressbar,"dgsProgressBarSetProgress",1,"dgs-dxprogressbar")) end
	local scaler = dgsElementData[progressbar].map
	if progress < 0 then progress = 0 end
	if progress > 100 then progress = 100 end
	if not isAbsolute then
		progress = (progress-scaler[1])/(scaler[2]-scaler[1])*100
	end
	if progress < 0 then progress = 0 end
	if progress > 100 then progress = 100 end
	if dgsElementData[progressbar].progress ~= progre


         * Exception vectors initialization.
         */
        .align      4
_ivinit:
        /* MSR initialization.*/
        e_lis       r3, BOOT_MSR_DEFAULT@h
        e_ori       r3, r3, BOOT_MSR_DEFAULT@l
        mtMSR       r3

        /* IVPR initialization.*/
        e_lis       r3, __ivpr_base__@h
        e_or2i      r3, __ivpr_base__@l
        mtIVPR      r3

        /* IVORs initialization.*/
        e_lis       r3, _unhandled_exception@h
        e_or2i      r3, _unhandled_exception@l

        mtspr       400, r3        /* IVOR0-15 */
        mtspr       401, r3
        mtspr       402, r3
        mtspr       403, r3
        mtspr       404, r3
        mtspr       405, r3
        mtspr       406, r3
        mtspr       407, r3
        mtspr       408, r3
        mtspr       409, r3
        mtspr       410, r3
        mtspr       411, r3
        mtspr       412, r3
        mtspr       413, r3
        mtspr       414, r3
        mtspr       415, r3
        mtspr       528, r3        /* IVOR32-34 */
        mtspr       529, r3
        mtspr       530, r3

        se_blr

#endif /* !defined(__DOXYGEN__) */

/** @} */


1152921504606846976u).createDigest() }, "0001020304050607ff7f3f1f0f0810204080fefcf8f0e0c0fdfbf7efdfbf55aa0b1113171d252a2b6162636465666768696a6b6c6d6e6f707172737475", "035CFE67F89E709B")
        testKatHex({ Algorithm.T1ha2_Stream(2305843009213693952u).createDigest() }, "0001020304050607ff7f3f1f0f0810204080fefcf8f0e0c0fdfbf7efdfbf55aa0b1113171d252a2b6162636465666768696a6b6c6d6e6f70717273747576", "89F06AB6464A1B9D")
        testKatHex({ Algorithm.T1ha2_Stream(4611686018427387904u).createDigest() }, "0001020304050607ff7f3f1f0f0810204080fefcf8f0e0c0fdfbf7efdfbf55aa0b1113171d252a2b6162636465666768696a6b6c6d6e6f7071727374757677", "8EFF58F3F7DEA758")
        testKatHex({ Algorithm.T1ha2_Stream(18446744073709551614u).createDigest() }, "01020304050607ff7f3f1f0f0810204080fefcf8f0e0c0fdfbf7efdfbf55aa0b1113171d252a2b6162636465666768696a6b6c6d6e6f707172737475767778", "8B54AC657902089F")
        testKatHex({ Algorithm.T1ha2_Stream(18446744073709551612u).createDigest() }, "020304050607ff7f3f1f0f0810204080fefcf8f0e0c0fdfbf7efdfbf55aa0b1113171d252a2b6162636465666768696a6b6c6d6e6f707172737475767778", "C6C4F1F9F8DA4D64")
        testKatHex({ Algorithm.T1ha2_Stream(18446744073709551608u).createDigest() }, "0304050607ff7f3f1f0f0810204080fefcf8f0e0c0fdfbf7efdfbf55aa0b1113171d252a2b6162636465666768696a6b6c6d6e6f707172737475767778", "BDB729048AAAC93A")
        testKatHex({ Algorithm.T1ha2_Stream(18446744073709551600u).createDigest() }, "04050607ff7f3f1f0f0810204080fefcf8f0e0c0fdfbf7efdfbf55aa0b1113171d252a2b6162636465666768696a6b6c6d6e6f707172737475767778", "EA76BA628F5E5CD6")
        testKatHex({ Algorithm.T1ha2_Stream(18446744073709551584u).createDigest() }, "050607ff7f3f1f0f0810204080fefcf8f0e0c0fdfbf7efdfbf55aa0b1113171d252a2b6162636465666768696a6b6c6d6e6f707172737475767778", "742159B728B8A979")
        testKatHex({ Algorithm.T1ha2_Stream(18446744073709551552u).createD


g to send data to the peer. Request failed.
		/// </summary>
		SocketSendError,
		/// <summary>
		/// An error was encountered when attempting to receive data from the peer. Request failed.
		/// </summary>
		SocketReceiveError,
		/// <summary>
		/// Request has been terminated by the user.
		/// </summary>
		Terminated,
		/// <summary>
		/// No data was received from the peer
		/// </summary>
		NoDataReceived,
		/// <summary>
		/// Authentication error
		/// </summary>
		AuthenticationError,
		/// <summary>
		/// Privacy error
		/// </summary>
		PrivacyError,
		/// <summary>
		/// Error encoding SNMP packet
		/// </summary>
		EncodeError,
		/// <summary>
		/// Error decoding SNMP packet
		/// </summary>
		DecodeError
	}
}


, so the tree dies.
    if (waterNeighbours < MIN_NEEDED_WATER) {
        return CreateEmptyCell();
    }

    if (cell.age == REPRODUCE_AGE) {
        if (random(50)) {
            cell.icon = evergreen;
        } else {
            cell.icon = decidious;
        }
    }

    // No Change happenend according to the rules for this cell.
    return cell;
};
declare module "game/visual" {
  import { RoomPosition } from "game/prototypes";

  export function line(
    pos1: RoomPosition,
    pos2: RoomPosition,
    style?: LineStyle
  ): void;
  export function circle(pos: RoomPosition, style?: CircleStyle): void;
  export function rect(
    topLeftPos: RoomPosition,
    width: number,
    height: number,
    style?: PolyStyle
  ): void;
  export function poly(points: RoomPosition[], style?: PolyStyle): void;
  export function text(msg: string, pos: RoomPosition, style?: TextStyle): void;
}

interface LineStyle {
  /**
   * Line width, default is 0.1.
   */
  width?: number;
  /**
   * Line color in any web format, default is #ffffff(white).
   */
  color?: string;
  /**
   * Opacity value, default is 0.5.
   */
  opacity?: number;
  /**
   * Either undefined (solid line), dashed, or dotted.Default is undefined.
   */
  lineStyle?: "dashed" | "dotted" | undefined;
}

interface PolyStyle {
  /**
   * Fill color in any web format, default is undefined (no fill).
   */
  fill?: string | undefined;
  /**
   * Opacity value, default is 0.5.
   */
  opacity?: number;
  /**
   * Stroke color in any web format, default is #ffffff (white).
   */
  stroke?: string;
  /**
   * Stroke line width, default is 0.1.
   */
  strokeWidth?: number;
  /**
   * Either undefined (solid line), dashed, or dotted. Default is undefined.
   */
  lineStyle?: "dashed" | "dotted" | "solid" | undefined;
}

interface CircleStyle extends PolyStyle {
  /**
   * Circle radius, default is 0.15.
   */
  radius?: number;
}

interface TextStyle {
  /**
   * Font color in any web format, default is #ffffff(white).
   */
  color?: string;
  /**
   * Either a number or a string in one of the following forms:
   * 0.7 - relative size in game coordinates
   * 20px - absolute size in pixels
   * 0.7 serif
   * bold italic 1.5 Times New Roman
   */
  font?: number | string;
  /**
   * Stroke color in any web format, default is undefined (no stroke).
   */
  stroke?: string | undefined;
  /**
   * Stroke width, default is 0.15.
   */
  strokeWidth?: number;
  /**
   * Background color in any web format, default is undefined (no background).When background is enabled, text vertical align is set to middle (default is baseline).
   */
  backgroundColor?: string | undefined;

  /**
   * Background rectangle padding, default is 0.3.
   */
  backgroundPadding?: number;
  align?: "center" | "left" | "right";
  /**
   * Opacity value, default is 1.0.
   */
  opacity?: number;
}
import { ComponentModel } from '@/models/component-model';
import { ResponsiveSizes, CssModel, Dictionary } from '@/models';
import { addComponent } from './add-component';

export function fromStateJson(root: ComponentModel, currentState: any, counter: Dictionary<string, number>) {
  applyProperties(root, currentState.props);
  applyCss


"""Modified k_charges

Revision ID: 9dbb2931da09
Revises: 66e022919043
Create Date: 2021-08-23 06:34:54.284876

"""
from alembic import op
import sqlalchemy as sa
from sqlalchemy.dialects import postgresql

# revision identifiers, used by Alembic.
revision = '9dbb2931da09'
down_revision = '66e022919043'
branch_labels = None
depends_on = None

def upgrade():
    # ### commands auto generated by Alembic - please adjust! ###
    op.add_column('k_charges', sa.Column('jail_unsuspended_years', sa.Integer(), nullable=True))
    op.add_column('k_charges', sa.Column('jail_unsuspended_months', sa.Integer(), nullable=True))
    op.add_column('k_charges', sa.Column('jail_unsuspended_days', sa.Integer(), nullable=True))
    op.add_column('k_charges', sa.Column('jail_unsuspended_hours', sa.Integer(), nullable=True))
    op.drop_column('k_charges', 'jail_suspend_all_but_months')
    op.drop_column('k_charges', 'jail_suspend_all_but_years')
    op.drop_column('k_charges', 'jail_suspend_all_but_days')
    op.drop_column('k_charges', 'jail_suspend_all_but_hours')
    # ### end Alembic commands ###

def downgrade():
    # ### commands auto generated by Alembic - please adjust! ###
    op.add_column('k_charges', sa.Column('jail_suspend_all_but_hours', sa.INTEGER(), autoincrement=False, nullable=True))
    op.add_column('k_charges', sa.Column('jail_suspend_all_but_days', sa.INTEGER(), autoincrement=False, nullable=True))
    op.add_column('k_charges', sa.Column('jail_suspend_all_but_years', sa.INTEGER(), autoincrement=False, nullable=True))
    op.add_column('k_charges', sa.Column('jail_suspend_all_but_months', sa.INTEGER(), autoincrement=False, nullable=True))
    op.drop_column('k_charges', 'jail_unsuspended_hours')
    op.drop_column('k_charges', 'jail_unsuspended_days')
    op.drop_column('k_charges', 'jail_unsuspended_months')
    op.drop_column('k_charges', 'jail_unsuspended_years')
    # ### end Alembic commands ###


1, .L3842+4
	mov	r0, #2
	bl	dprint_vfmw
	ldrb	r3, [r6, #211]	@ zero_extendqisi2
	mov	r2, #0
	str	r2, [r5, #1116]
	cmp	r3, #5
	ldr	r3, [r5, #1100]
	mov	r0, r4
	streq	r3, [r5, #1112]
	add	r3, r3, #1
	str	r3, [r5, #1100]
	ldrb	r3, [r7, #1739]	@ zero_extendqisi2
	cmp	r3, r2
	ldreq	r3, [r5, #1104]
	ldrne	r3, [r5, #1108]
	addeq	r3, r3, #1
	addne	r3, r3, #1
	streq	r3, [r5, #1104]
	strne	r3, [r5, #1108]
	bl	InitPic
	cmn	r0, #2
	beq	.L3792
	cmp	r0, #0
	bne	.L3841
	mov	r0, r4
	bl	WritePicMsg
	b	.L3809
.L3835:
	ldr	r1, .L3842+8
	mov	r0, #1
	bl	dprint_vfmw
	ldr	r3, .L3842+12
	ldr	ip, [r3]
	cmp	ip, #0
	beq	.L3833
	sub	r2, fp, #44
	mvn	r1, #0
	ldr	r0, [r5, #1136]
	mov	r3, #4
	str	r1, [r2, #-8]!
	mov	r1, #100
	blx	ip
.L3833:
	mov	r0, r4
	bl	ClearCurrSlice
	mvn	r0, #0
	b	.L3792
.L3806:
	str	r1, [sp]
	mov	r0, #0
	ldr	r1, .L3842+16
	bl	dprint_vfmw
	ldr	r2, [r8, #1284]
	ldr	r3, [r5, #1060]
	cmp	r3, r2
	bcc	.L3808
	ldr	r1, .L3842+12
	ldr	ip, [r1]
	cmp	ip, #0
	beq	.L3808
	str	r3, [fp, #-52]
	mov	r1, #108
	str	r2, [fp, #-48]
	mov	r3, #8
	sub	r2, fp, #52
	ldr	r0, [r5, #1136]
	blx	ip
.L3808:
	ldr	r1, .L3842+20
	mov	r0, #1
	bl	dprint_vfmw
	mov	r0, r4
	bl	H264_ClearCurrPic
	mvn	r0, #0
	b	.L3792
.L3839:
	mov	r2, r0
	ldr	r1, .L3842+24
	mov	r0, #1
	bl	dprint_vfmw
	mvn	r0, #0
	b	.L3792
.L3840:
	ldr	r1, .L3842+28
	mov	r0, #1
	bl	dprint_vfmw
	b	.L3833
.L3841:
	ldr	r1, .L3842+32
	mov	r0, #1
	bl	dprint_vfmw
	mvn	r0, #0
	b	.L3792
.L3843


border: 1px solid var(--in-content-border-color);
  color: var(--in-content-text-color);
  float: right;
  margin-top: 2em;
  margin-bottom: 20px;
  margin-inline-start: 20px;
  margin-inline-end: 0;
  padding: 16px;
  width: 30%;
}

#action-box:dir(rtl) {
  float: left;
}
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*** View and outer controls ***/

#downloadsRichListBox {
  /** The default listbox appearance comes with an unwanted margin. **/
  -moz-appearance: none;
  margin: 0;
}

/*** List items ***/

#downloadsRichListBox > richlistitem.download {
  height: var(--downloads-item-height);
}

.downloadTypeIcon {
  margin: 8px 13px;
  width: 32px;
  height: 32px;
}

.downloadBlockedBadge {
  margin: 0 5px;
  background: url("chrome://browser/skin/downloads/download-blocked.svg") top right / 16px no-repeat;
}

.downloadBlockedBadge:-moz-locale-dir(rtl) {
  background-position-x: left;
}

richlistitem.download[verdict="PotentiallyUnwanted"] .downloadBlockedBadge {
  background-image: url("chrome://browser/skin/warning.svg");
}

richlistitem.download[verdict="Uncommon"] .downloadBlockedBadge {
  background-image: url("chrome://browser/skin/info.svg");
}

richlistitem.download > toolbarseparator {
  display: none;
}

.downloadTarget {
  margin: 0;
}

.downloadDetails {
  opacity: 0.7;
  font-size: 95%;
  /* Use calc() to keep the height consistent with .downloadTarget, so that the
     progress bar can be vertically centered. */
  margin: 4px 0 calc(1em / 0.95 - 1em);
}

.downloadButton {
  -moz-appearance: none;
  -moz-box-align: center;
  background: transparent;
  min-width: 0;
  min-height: 0;
  margin: 0;
  border: none;
  color: inherit;
  padding: 0 18px;
}

.downloadButton > .button-box {
  -moz-appearance: none;
  padding: 2px !important;
  border-radius: 50%;
}

.downloadButton > .button-box > .button-icon {
  width: 16px;
  height: 16px;
  margin: 0;
  filter: url("chrome://global/skin/filters.svg#fill");
  fill: currentColor;
}

.downloadButton > .button-box > .button-text {
  display: none;
}

.downloadButton:hover > .button-box {
  background-color: graytext;
  color: -moz-field;
}

.downloadButton:hover:active > .button-box {
  background-color: -moz-fieldtext;
}

richlistitem.download[selected] > .downloadButtonArea > .downloadButton:hover > .button-box {
  background-color: HighlightText;
  color: Highlight;
}

richlistitem.download[selected] > .downloadButtonArea > .downloadButton:hover:active > .button-box {
  background-color: -moz-field;
  color: -moz-fieldtext;
}

/*** Button icons ***/

.downloadIconCancel > .button-box > .button-icon {
  list-style-image: url("chro


ngAttribute = "".concat(DATA_FA_PSEUDO_ELEMENT_PENDING).concat(position.replace(':', '-'));
    return new picked(function (resolve, reject) {
      if (node.getAttribute(pendingAttribute) !== null) {
        // This node is already being processed
        return resolve();
      }

      var children = toArray(node.children);
      var alreadyProcessedPseudoElement = children.filter(function (c) {
        return c.getAttribute(DATA_FA_PSEUDO_ELEMENT) === position;
      })[0];
      var styles = WINDOW.getComputedStyle(node, position);
      var fontFamily = styles.getPropertyValue('font-family').match(FONT_FAMILY_PATTERN);
      var fontWeight = styles.getPropertyValue('font-weight');
      var content = styles.getPropertyValue('content');

      if (alreadyProcessedPseudoElement && !fontFamily) {
        // If we've already processed it but the current computed style does not result in a font-family,
        // that probably means that a class name that was previously present to make the icon has been
        // removed. So we now should delete the icon.
        node.removeChild(alreadyProcessedPseudoElement);
        return resolve();
      } else if (fontFamily && content !== 'none' && content !== '') {
        var _content = styles.getPropertyValue('content');

        var prefix = ~['Solid', 'Regular', 'Light', 'Duotone', 'Brands', 'Kit'].indexOf(fontFamily[2]) ? STYLE_TO_PREFIX[fontFamily[2].toLowerCase()] : FONT_WEIGHT_TO_PREFIX[fontWeight];
        var hexValue = toHex(_content.length === 3 ? _content.substr(1, 1) : _content);
        var iconName = byUnicode(prefix, hexValue);
        var iconIdentifier = iconName; // Only convert the pseudo element in this :before/:after position into an icon if we haven't
        // already done so with the same prefix and iconName

        if (iconName && (!alreadyProcessedPseudoElement || alreadyProcessedPseudoElement.getAttribute(DATA_PREFIX) !== prefix || alreadyProcessedPseudoElement.getAttribute(DATA_ICON) !== iconIdentifier)) {
          node.setAttribute(pendingAttribute, iconIdentifier);

          if (alreadyProcessedPseudoElement) {
            // Delete the old one, since we're replacing it with a new one
            node.removeChild(alreadyProcessedPseudoElement);
          }

          var meta = blankMeta();
          var extra = meta.extra;
          extra.attributes[DATA_FA_PSEUDO_ELEMENT] = position;
          findIcon(iconName, prefix).then(function (main) {
            var abstract = makeInlineSvgAbstract(_objectSpread2(_objectSpread2({}, meta), {}, {
              icons: {
                main: main,
                mask: emptyCanonicalIcon()
              },
              prefix: prefix,
              iconName: iconIdentifier,
              extra: extra,
              watchable: true
            }));
            var element = DOCUMENT.createElement('svg');

            if (position === ':before') {
              node.insertBefore(element, node.firstChild);
            } else {
              node.appendChild(element);
            }

            element.outerHTML = abstract.map(function (a) {
              return toHtml(a);
            }).join('\n');
            node.removeAttribute(pendingAttribute);
            resolve();
          }).catch(reject);
        } else {
          resolve();
        }
      } else {
        resolve();
      }
    });
  }

  function replace(node) {
    return picked.all([replaceForPosition(node, ':before'), replaceForPosition(node, ':after')]);
  }

  function processable(node) {
    return node.parentNode !== document


ized = serialize(0xffa);
		const deserialized = deserialize<number>(serialized);
		expect(typeof deserialized).toBe('number');
		expect(deserialized).toBe(0xffa);
	});

	test('Deserialize SignedInt32', () => {
		expect.assertions(2);

		const serialized = serialize(-0xffa);
		const deserialized = deserialize<number>(serialized);
		expect(typeof deserialized).toBe('number');
		expect(deserialized).toBe(-0xffa);
	});

	test('Deserialize PFloat64', () => {
		expect.assertions(2);

		const value = 0xffffffff + 0.1;
		const serialized = serialize(value);
		const deserialized = deserialize<number>(serialized);
		expect(typeof deserialized).toBe('number');
		expect(deserialized).toBe(value);
	});

	test('Deserialize NFloat64', () => {
		expect.assertions(2);

		const value = -0xffffffff - 0.1;
		const serialized = serialize(value);
		const deserialized = deserialize<number>(serialized);
		expect(typeof deserialized).toBe('number');
		expect(deserialized).toBe(value);
	});

	test('Deserialize NaN', () => {
		expect.assertions(2);

		const serialized = serialize(NaN);
		const deserialized = deserialize<number>(serialized);
		expect(typeof deserialized).toBe('number');
		expect(Number.isNaN(deserialized)).toBeTruthy();
	});

	test('Deserialize Infinity', () => {
		expect.assertions(2);

		const serialized = serialize(Infinity);
		const deserialized = deserialize<number>(serialized);
		expect(typeof deserialized).toBe('number');
		expect(deserialized).toBe(Infinity);
	});

	test('Deserialize Unsafe Float', () => {
		expect.assertions(2);

		const serialized = serialize(Number.MAX_VALUE);
		const deserialized = deserialize<number>(serialized);
		expect(typeof deserialized).toBe('number');
		expect(deserialized).toBe(Number.MAX_VALUE);
	});

	test('Deserialize Array (Empty)', () => {
		expect.assertions(2);

		const serialized = serialize([]);
		const deserialized = deserialize<never[]>(serialized);
		expect(Array.isArray(deserialized)).toBeTruthy();
		expect(deserialized.length).toBe(0);
	});

	test('Deserialize Array (UnsignedInt32)', () => {
		expect.assertions(3);

		const serialized = serialize([4]);
		const deserialized = deserialize<number[]>(serialized);
		expect(Array.isArray(deserialized)).toBeTruthy();
		expect(deserialized.length).toBe(1);
		expect(deserialized[0]).toBe(4);
	});

	test('Deserialize Array (Holey)', () => {
		expect.assertions(3);

		// eslint-disable-next-line no-sparse-arrays, array-bracket-spacing
		const serialized = serialize([,]);
		const deserialized = deserialize<never[]>(serialized);
		expect(Array.isArray(deserialized)).toBeTruthy();
		expect(deserialized.length).toBe(1);
		expect(0 in deserialized).toBeFalsy();
	});

	test('Deserialize Array (Circular)', () => {
		expect.assertions(3);

		const array: unknown[] = [];
		array.push(array);
		const serialized = serialize(array);
		const deserialized = deserialize<unknown[]>(serialized);
		expect(Array.isArray(deserialized)).toBeTruthy();
		expect(deserialized.length).toBe(1);
		expect(deserialized[0]).toBe(deserialized);
	});

	test('Deserialize Object (Empty)', () => {
		expect.assertions(1);

		const serialized = serialize({});
		const des


.withSha512sum("sha-512-checksum")
            .build();

    @Test
    public void testEmptyDockerfile()   {
        Build connectBuild = new BuildBuilder()
                .withPlugins(emptyList())
                .build();

        KafkaConnectDockerfile df = new KafkaConnectDockerfile("myImage:latest", connectBuild, SHARED_ENV_PROVIDER);

        assertThat(df.getDockerfile(), isEquivalent("FROM myImage:latest",
                "USER root:root",
                "USER 1001"));
    }

    @Test
    public void testNoArtifacts()   {
        Build connectBuild = new BuildBuilder()
                .withPlugins(new PluginBuilder()
                        .withName("my-connector-plugin")
                        .withArtifacts(emptyList())
                        .build())
                .build();

        KafkaConnectDockerfile df = new KafkaConnectDockerfile("myImage:latest", connectBuild, SHARED_ENV_PROVIDER);

        assertThat(df.getDockerfile(), isEquivalent("FROM myImage:latest",
                "USER root:root",
                "USER 1001"));
    }

    @Test
    public void testNoChecksumJarArtifact()   {
        Build connectBuild = new BuildBuilder()
                .withPlugins(new PluginBuilder()
                        .withName("my-connector-plugin")
                        .withArtifacts(jarArtifactNoChecksum)
                        .build())
                .build();

        KafkaConnectDockerfile df = new KafkaConnectDockerfile("myImage:latest", connectBuild, SHARED_ENV_PROVIDER);

        assertThat(df.getDockerfile(), isEquivalent("FROM myImage:latest",
                "USER root:root",
                "RUN 'mkdir' '-p' '/opt/kafka/plugins/my-connector-plugin/51e5038c' \\",
                "      && 'curl' '-f' '-L' '--output' '/opt/kafka/plugins/my-connector-plugin/51e5038c/51e5038c.jar' 'https://mydomain.tld/my.jar'",
                "USER 1001"));
    }

    @Test
    public void testChecksumJarArtifact()   {
        Build connectBuild = new BuildBuilder()
                .withPlugins(new PluginBuilder()
                        .withName("my-connector-plugin")
                        .withArtifacts(jarArtifactWithChecksum)
                        .build())
                .build();

        KafkaConnectDockerfile df = new KafkaConnectDockerfile("myImage:latest", connectBuild, SHARED_ENV_PROVIDER);

        assertThat(df.getDockerfile(), isEquivalent("FROM myImage:latest",
                "USER root:root",
                "RUN 'mkdir' '-p' '/opt/kafka/plugins/my-connector-plugin/0df6d15c' \\",
                "      && 'curl' '-f' '-L' '--output' '/opt/kafka/plugins/my-connector-plugin/0df6d15c/0df6d15c.jar' 'https://mydomain.tld/my2.jar' \\",
                "      && 'echo' 'sha-512-checksum /opt/kafka/plugins/my-connector-plugin/0df6d15c/0df6d15c.jar' > '/opt/kafka/plugins/my-connector-plugin/0df6d15c/0df6d15c.jar.sha512' \\",
                "      && 'sha512sum' '--check' '/opt/kafka/plugins/my-connector-plugin/0df6d15c/0df6d15c.jar.sha512' \\",
                "      && 'rm' '-f' '/opt/kafka/plugins/my-connector-plugin/0df6d15c/0df6d15c.jar.sha512'",
                "USER 1001"));
    }

    @Test
    public void testNoChecksumOtherArtifact()   {
        Build connectBuild = new BuildBuilder()
                .with


selectedCategory == category),
			            																					'deactive-tweet-template-category': (selectedCategory != category)}">
			            				{{ category }}

 Select Template

				                 		 {{ tweetTemplate.template_name }}

	               							{{ tweetTemplate.text }}

			  `

})

export class TweetTemplatesComponent implements OnInit {
	@Input()  tweetTemplates: TweetTemplate[];

	public objectKeys: 					any 	= Object.keys;
	public selectedCategory: 			String 	= "";
	public tweetTemplatesByCategory: 	any 	= {};
	public initialized: 				Boolean = false;

	@Output() selectedTweetTemplate: EventEmitter<TweetTemplate> = new EventEmitter<TweetTemplate>();
	constructor() {

	}
	selectTweetTemplate(tweetTemplate) {
		this.selectedTweetTemplate.emit(tweetTemplate);
	}

	ngOnInit() {
		// Find out about tweetTemplateCategory
		this.tweetTemplates.forEach((tweetTemplate) => {
			// Add tweetTemplate
			if (!(tweetTemplate.category in this.tweetTemplatesByCategory)) {
				this.tweetTemplatesByCategory[tweetTemplate.category] = [tweetTemplate];
			}
			else {
				let tweetTemplates = this.tweetTemplatesByCategory[tweetTemplate.category];
				tweetTemplates.push(tweetTemplate);
				this.tweetTemplatesByCategory[tweetTemplate.category] = tweetTemplates;
			}
		});
		 // initialize category for now
		this.selectedCategory = this.tweetTemplates[0].category;
		this.initialized = true;
	}
}
namespace Utils {
    /**
     * Referrence class entity
     */
    export abstract class REntity {
        /**
         * Entity id
         */
        id : number;

        /**
         * Entity name
         */
        name : string;

        /**
         * Constructor
         */
        constructor() {

        }
    }

    /**
     * Referrence class entity
     */
    export class RClass extends REntity {
        /**
         * Constructor
         */
        constructor() {
            super();
        }
    }

    /**
     * Referrence instance entity
     */


2-.015 1.246-.043 1.625-.03.437-.1.77-.217 1.024a1.294 1.294 0 01-.68.674c-.214.087-.506.154-.896.206a.44.44 0 00-.227.089.64.64 0 00-.178.251c-.06.135-.086.282-.086.45 0 .268.066.45.212.571.174.144.458.218.843.218.917 0 1.62-.254 2.155-.776.534-.522.802-1.205.822-2.091.023-1.095.046-2.007.064-2.735.02-.777.079-1.355.184-1.766.12-.46.333-.854.638-1.168.273-.28.684-.587 1.254-.938.254-.157.368-.385.368-.746 0-.35-.077-.483-.11-.524-.119-.143-.316-.298-.589-.463a4.268 4.268 0 01-.975-.794c-.3-.334-.515-.784-.66-1.377-.051-.213-.114-.885-.174-4.23-.007-.568-.138-1.072-.39-1.503a2.524 2.524 0 00-1.02-.984c-.443-.235-.968-.356-1.567-.356z"
                    id="path163" fill="#fff" fill-opacity="1" stroke-width="1.57" />
            </g>
            <path
                d="M28.621 31.422c.224-.102.208 1.099.208-15.49 0-16.588.016-15.388-.208-15.49-.144-.065-24.6-.065-24.744 0-.223.102-.207-1.1-.206 15.498.001 12.58.01 15.259.052 15.334.112.203-.702.19 12.515.192 9.446.001 12.307-.01 12.383-.044zm-9.415-1.705c-.283-.11-.57-.4-.678-.687a1.216 1.216 0 011.131-1.655c.669 0 1.213.544 1.213 1.213 0 .853-.862 1.437-1.666 1.129zm-8.337-1.054v-.757H9.353v-1.668h1.516V24.723H12.536V26.238h1.516v1.668h-1.516V29.42H10.869zm10.99-1.22c-.284-.109-.57-.399-.678-.686a1.204 1.204 0 01.276-1.298c.762-.762 2.067-.222 2.067.855 0 .854-.862 1.438-1.666 1.13zM4.765 23.475l-.111-.11V1.377l.11-.111.111-.11h22.746l.11.11.112.11V23.366l-.111.11-.11.111H4.875z"
                id="path4210" fill="#fff" fill-opacity="1" />
        </svg>

        Manual
        Edit
        <a target="blank" rel="nofollow noopener" href="https://github.com/{{


    }
    GUIFreeAllControls( wnd, dialog );
    for( curr_child = wnd->child; curr_child != NULL; curr_child = next_child ) {
        next_child = curr_child->sibling;
        if( curr_child != NULL ) {
            GUIEVENT( curr_child, GUI_DESTROY, NULL );
            GUIFreeWindowMemory( curr_child, true, dialog );
        }
    }
    if( IS_HSCROLL_ON( wnd ) ) {
        uifinigadget( wnd->hgadget );
        GUIMemFree( wnd->hgadget );
    }
    if( IS_VSCROLL_ON( wnd ) ) {
        uifinigadget( wnd->vgadget );
        GUIMemFree( wnd->vgadget );
    }
    GUIFreeMenus( wnd );
    GUIFreeHint( wnd );
    GUIMemFree( wnd->icon_name );
    if( !dialog ) {
        uivshow( &wnd->vs );
        wnd->vs.open = true;
        uivclose( &wnd->vs );
    }
    if( GUICurrWnd == wnd ) {
        GUICurrWnd = NULL;
    }
    if( wnd->vs.dynamic_title ) {
        GUIMemFree( (void *)wnd->vs.title );
        wnd->vs.title = NULL;
        wnd->vs.dynamic_title = false;
    }
    GUIFreeColours( wnd );
    GUIMemFree( wnd );
}

static void DoDestroy( gui_window *wnd, bool dialog )
{
    if( wnd != NULL ) {
        GUIEVENT( wnd, GUI_DESTROY, NULL );
        GUIFreeWindowMemory( wnd, false, dialog );
    } else {
        while( (wnd = GUIGetFront()) != NULL ) {
            DoDestroy( wnd, GUI_IS_DIALOG( wnd ) );
        }
    }
}

void GUIDestroyDialog( gui_window *wnd )
{
    DoDestroy( wnd, true );
}

bool GUICloseWnd( gui_window *wnd )
{
    if( wnd != NULL ) {
        if( GUIEVENT( wnd, GUI_CLOSE, NULL ) ) {
            GUIDestroyWnd( wnd );
            return( true );
        }
    }
    return( false );
}

/*
 * GUIDestroyWnd
 */

void GUIAPI GUIDestroyWnd( gui_window *wnd )
{
    DoDestroy( wnd, false );
}


//
//  RankViewModel.h
//  喜马拉雅FM(高仿品)
//
//  Created by apple-jd33 on 15/11/17.
//  Copyright © 2015年 HansRove. All rights reserved.
//

#import "BaseViewModel.h"

@interface RankViewModel : BaseViewModel

/**  返回分组数 */
@property (nonatomic,assign) NSInteger sectionNumber;
/**  通过分组数返回行数 */
- (NSInteger)rowNumberForSection:(NSInteger)section;
/**  通过分组数返回主标题 */
- (NSString *)mainTitleForSection:(NSInteger)section;

/**  通过分组和行数, 返回图标URL */
- (NSURL *)coverURLForSection:(NSInteger)section row:(NSInteger)row;
/**  通过分组和行数, 返回URL */
- (NSString *)titleForSection:(NSInteger)section row:(NSInteger)row;
/**  通过分组和行数, 返回URL */
- (NSString *)firstTitleForSection:(NSInteger)section row:(NSInteger)row;
/**  通过分组和行数, 返回URL */
- (NSString *)secondTitleForSection:(NSInteger)section row:(NSInteger)row;

/**  是否 存在头部滚动视图 */
/** 头部滚动视图 图片总数 */
@property (nonatomic,assign) NSInteger focusImgNumber;
/** 头部滚动视图 图片URL */
- (NSURL *)focusImgURLForIndex:(NSInteger)index;
@end


_LEAVES[..index],
        )?;

        assert!(write_results
            .iter()
            .all(|result| *result == WriteResult::AlreadyExists));

        // Check that the expected set of leaves is in the trie at every state reference
        for (num_leaves, state) in states[..index].iter().enumerate() {
            check_leaves::<_, _, _, _, E>(
                correlation_id,
                environment,
                store,
                state,
                &TEST_LEAVES[..num_leaves],
                &[],
            )?
        }

        Ok(())
    }

    #[test]
    fn lmdb_noop_writes_to_n_leaf_full_trie_had_expected_results() {
        let correlation_id = CorrelationId::new();
        let context = LmdbTestContext::new(EMPTY_HASHED_TEST_TRIES).unwrap();
        let mut states: Vec<Blake2bHash> = Vec::new();

        for (index, generator) in TEST_TRIE_GENERATORS.iter().enumerate() {
            let (root_hash, tries) = generator().unwrap();
            context.update(&tries).unwrap();
            states.push(root_hash);

            noop_writes_to_n_leaf_full_trie_had_expected_results::<_, _, error::Error>(
                correlation_id,
                &context.environment,
                &context.store,
                &states,
                index,
            )
            .unwrap();
        }
    }

    #[test]
    fn in_memory_noop_writes_to_n_leaf_full_trie_had_expected_results() {
        let correlation_id = CorrelationId::new();
        let context = InMemoryTestContext::new(EMPTY_HASHED_TEST_TRIES).unwrap();
        let mut states: Vec<Blake2bHash> = Vec::new();

        for (index, generator) in TEST_TRIE_GENERATORS.iter().enumerate() {
            let (root_hash, tries) = generator().unwrap();
            context.update(&tries).unwrap();
            states.push(root_hash);

            noop_writes_to_n_leaf_full_trie_had_expected_results::<_, _, in_memory::Error>(
                correlation_id,
                &context.environment,
                &context.store,
                &states,
                index,
            )
            .unwrap();
        }
    }

    fn update_writes_to_n_leaf_full_trie_had_expected_results<'a, R, S, E>(
        correlation_id: CorrelationId,
        environment: &'a R,
        store: &S,
        states: &[Blake2bHash],
        num_leaves: usize,
    ) -> Result<(), E>
    where
        R: TransactionSource<'a, Handle = S::Handle>,
        S: TrieStore<TestKey, TestValue>,
        S::Error: From<R::Error>,
        E: From<R::Error> + From<S::Error> + From<types::bytesrepr::Error>,
    {
        let mut states = states.to_vec();

        // Check that the expected set of leaves is in the trie at every state reference
        for (state_index, state) in states.iter().enumerate() {
            check_leaves::<_, _, _, _, E>(
                correlation_id,
                environment,
                store,
                state,
                &TEST_LEAVES[..state_index],
                &[],
            )?;
        }

        // Write set of leaves to the trie
        let hashes = write_leaves::<_, _, _, _, E>(
            correlation_id,
            environment,
            store,
            states.last().unwrap(),
            &TEST_LEAVES_UPDATED[..num_leaves],
        )?
        .iter()
        .map(|result| match result {
            WriteResult::Written(root_hash) => *root_hash,


ardUntilNoTasksRemain();

  // Only valid for instances with a MOCK_TIME MainThreadType.  Returns a
  // TickClock whose time is updated by FastForward(By|UntilNoTasksRemain).
  const TickClock* GetMockTickClock();
  std::unique_ptr<TickClock> DeprecatedGetMockTickClock();

  // Only valid for instances with a MOCK_TIME MainThreadType.
  // Returns the number of pending tasks of the main thread's TaskRunner.
  size_t GetPendingMainThreadTaskCount() const;

  // Only valid for instances with a MOCK_TIME MainThreadType.
  // Returns the delay until the next delayed pending task of the main thread's
  // TaskRunner.
  TimeDelta NextMainThreadPendingTaskDelay() const;

 private:
  class TestTaskTracker;

  const ExecutionMode execution_control_mode_;

  // Exactly one of these will be non-null to provide the task environment on
  // the main thread. Users of this class should NOT rely on the presence of a
  // MessageLoop beyond (Thread|Sequenced)TaskRunnerHandle and RunLoop as
  // the backing implementation of each MainThreadType may change over time.
  const std::unique_ptr<MessageLoop> message_loop_;
  const scoped_refptr<TestMockTimeTaskRunner> mock_time_task_runner_;

  // Non-null in MOCK_TIME, where an explicit SequenceLocalStorageMap needs to
  // be provided. TODO(gab): This can be removed once mock time support is added
  // to MessageLoop directly.
  const std::unique_ptr<internal::SequenceLocalStorageMap> slsm_for_mock_time_;
  const std::unique_ptr<
      internal::ScopedSetSequenceLocalStorageMapForCurrentThread>
      slsm_registration_for_mock_time_;

#if defined(OS_POSIX)
  // Enables the FileDescriptorWatcher API iff running a MainThreadType::IO.
  const std::unique_ptr<FileDescriptorWatcher> file_descriptor_watcher_;
#endif

  const TaskScheduler* task_scheduler_ = nullptr;

  // Owned by |task_scheduler_|.
  TestTaskTracker* const task_tracker_;

  // Ensures destruction of lazy TaskRunners when this is destroyed.
  internal::ScopedLazyTaskRunnerListForTesting
      scoped_lazy_task_runner_list_for_testing_;

  DISALLOW_COPY_AND_ASSIGN(ScopedTaskEnvironment);
};

}  // namespace test
}  // namespace base

#endif  // BASE_TEST_SCOPED_ASYNC_TASK_SCHEDULER_H_


e 36, /Users/jamieavins/git/SDK/touch/resources/themes/stylesheets/sencha-touch/base/src/layout/_Box.scss */
.x-layout-box.x-align-end {
  -webkit-box-align: end;
  -ms-flex-align: end;
  align-items: flex-end;
}
/* line 40, /Users/jamieavins/git/SDK/touch/resources/themes/stylesheets/sencha-touch/base/src/layout/_Box.scss */
.x-layout-box.x-align-stretch {
  -webkit-box-align: stretch;
  -ms-flex-align: stretch;
  align-items: stretch;
}
/* line 44, /Users/jamieavins/git/SDK/touch/resources/themes/stylesheets/sencha-touch/base/src/layout/_Box.scss */
.x-layout-box.x-pack-start {
  -webkit-box-pack: start;
  -ms-flex-pack: start;
  justify-content: flex-start;
}
/* line 48, /Users/jamieavins/git/SDK/touch/resources/themes/stylesheets/sencha-touch/base/src/layout/_Box.scss */
.x-layout-box.x-pack-center {
  -webkit-box-pack: center;
  -ms-flex-pack: center;
  justify-content: center;
}
/* line 52, /Users/jamieavins/git/SDK/touch/resources/themes/stylesheets/sencha-touch/base/src/layout/_Box.scss */
.x-layout-box.x-pack-end {
  -webkit-box-pack: end;
  -ms-flex-pack: end;
  justify-content: flex-end;
}
/* line 56, /Users/jamieavins/git/SDK/touch/resources/themes/stylesheets/sencha-touch/base/src/layout/_Box.scss */
.x-layout-box.x-pack-justify {
  -webkit-box-pack: justify;
  -ms-flex-pack: justify;
  justify-content: space-between;
}

/* line 62, /Users/jamieavins/git/SDK/touch/resources/themes/stylesheets/sencha-touch/base/src/layout/_Box.scss */
.x-layout-box-item.x-sized > .x-inner, .x-layout-box-item.x-sized > .x-body, .x-layout-box-item.x-sized > .x-dock-outer {
  width: auto;
  height: auto;
  position: absolute;
  top: 0;
  right: 0;
  bottom: 0;
  left: 0;
}

/* line 71, /Users/jamieavins/git/SDK/touch/resources/themes/stylesheets/sencha-touch/base/src/layout/_Box.scss */
.x-webkit .x-layout-box.x-horizontal > .x-layout-box-item.x-flexed {
  width: 0 !important;
}
/* line 75, /Users/jamieavins/git/SDK/touch/resources/themes/stylesheets/sencha-touch/base/src/layout/_Box.scss */
.x-webkit .x-layout-box.x-vertical > .x-layout-box-item.x-flexed {
  height: 0 !important;
}

/* line 84, /Users/jamieavins/git/SDK/touch/resources/themes/stylesheets/sencha-touch/base/src/layout/_Box.scss */
.x-firefox .x-stretched.x-dock-horizontal > .x-dock-body {
  width: 0;
}
/* line 90, /Users/jamieavins/git/SDK/touch/resources/themes/stylesheets/sencha-touch/base/src/layout/_Box.scss */
.x-firefox .x-stretched.x-dock-vertical > .x-dock-body {
  height: 0;
}
/* line 98, /Users/jamieavins/git/SDK/touch/resources/themes/stylesheets/sencha-touch/