/*
**   ZLIB JavaScript Function Library.
**   Written by Zsolt N. Perry in Pensacola, Fla.
**   April 2023 Edition
**
**   This script can be used either as part of a HTML document
**   or as a stand-alone JS script on Windows. Both applications
**   will have different environments, and some functions will
**   only work in one specific environment.
**
*******************************************************/

INIT();

ALERT(LocalTimeD());

EXIT();

function KEYPRESS(K)
{
  if (K == 113) // F2 was pressed
  {}

  if (K == 114) // F3 was pressed
  {}

  if (K == 119) // F8 was pressed
  {}
  window.status = K;
}

//////////////////////////////////////////////////
//
// This function runs some tests and
// initializes a bunch of global variables.
//
function INIT()
{
  var $, W1, W2, W3, W4, W5, H1, H2, H3, H4, H5;

  T1 = TIME();

  HTML = [];
  LANDSCAPE = 1;
  LANGUAGE = 'ENUS';
  ONLINE = MOBILE = BROWSER_VERSION = X64 = WX = HX = Wx = Hx = 0;
  MSIE = OPERA = FIREFOX = SAFARI = CHROME = EDGE = SEAMONKEY = 0;  
  FILESYS = COOKIES = STORAGE = 0;
  JAVA = WASM = CANVAS = FATARROW = FUNCDEF = EXPORT = ASYNC = LET = BIGINT = 0;
  BROWSER_NAME = PF = UA = DEVICE = '';
  SEED = 1;
  RANDOM = [];
  RND = [55];

  // String testing functions require this line:
  CX = [512,0,0,0,0,0,0,0,0,520,520,0,512,520,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,632,9464,1192,1272,1257,1272,1264,1240,9464,9464,13560,7416,1272,13560,13560,15608,14840,14840,14840,14840,14840,14840,14840,14840,14840,14840,9464,1144,1264,1144,1264,9464,1256,47613,31229,31229,31229,47613,31229,30973,30973,47357,30973,30973,30973,30973,30973,47357,30973,30973,30973,30973,30973,47357,30973,30973,30973,30973,30973,9464,1160,9464,1272,9465,1272,47611,31227,31227,31227,47611,31227,30971,30971,47355,30971,30971,30971,30971,30971,47355,30971,30971,30971,30971,30971,47355,31483,30971,30971,30971,30971,9464,1272,9464,1272,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,5,5,5,5,5,5,1,1,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,1,3,3,3,3,3,3,1,3,3,3,3,3,3,0,3];
  ALLCHARS = CharRange(0, 255, 1);   // DO NOT CHANGE THIS LINE! This function creates an array of characters from 0 to 255.

  // SET UP SOME GLOBAL VARIABLES
  $ = BROWSER = typeof(document) == 'undefined' || typeof(window) == 'undefined' ? 0 : 1;
  SELF = BROWSER ? location.href : WScript.ScriptFullName;
  DOMAIN = BROWSER ? document.domain : '';
  CURDIR = GetCurrentDirectory();

  // Initialize Str2Txt() and Txt2Str() lookup tables
  TX = Hex2Str('47696F3164497142674F626534726153486E43636B3875456D57554E54684D767C746C70463641373220392F782E7752664479507330334C35595E0A804B3B277E860D882D60897A584A295D243A237B847D2C8B8540268E82515A216A005B5C1B223E2881833F875F2A093D252B568C8A3C04A98D8F08A71D129593A3A29A0B989F1A0E9E1C1F160F9611170119079997A69B101505A09C7F0C1E90181406139DA59194AA0302A1A492A8BDB2E3C7B7D4DFC8ADD0ACCBCDC9D7D9CAC5BCD6B4CCB9BEE0DAB8D5C0BBB5E2C1CED1ABDED3BFDBB3CFAFD8BADCAEB0C3C4C2D2C6DDE1B6B1F7F6FFFCE9E8EEEDEFF4F3E4F5E5EAFAECF2F8F0E7FBFEEBE6FDF1F95D8CA6A572959E8E766A3B7F99428388938A799F9D94878B9C8D826085789A86295B614E4C6C563F634A696D52442D2B350328360C382527152A4D3E716B626655260712311724001005493D371E1B0933592F0F1C1A6E1948395A5E5F4B3A68450E0A13040B30081D015C142218110223060D3421161F2E2C32474F205140983C64586550544167434670536F7457759BA2A97BA37A8990808F7E9297A0848196A77D7CA8A19177AA73A4CEB5B3D9D5DAE3ACD3BFC9E2AFC5C1D7C8BDABC2D1C7CBDDDBDCBCDFAEB2B8BBB6C0B7CCD4B4CDDED0B0C6BEB9D6BAC4D2D8E0CFB1C3E1CAADEFF1FCF8E9E8F2FBF4EBEAECF7FEF5EEEDF0E5E4F6FFF3F9E7FDFAE6000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000263706110C0F3102072500000000000000130E3C1D011A031C050A2F172B142718152100293A302D0820320000000000001028193D0D16342E380B3912232C2A1F332236041B0924353B1E0000000000534537477449323858764A6A3465423561336C414E51664C5063467548447A705952726D7739304F62546F4D6E57684B56365A7167787331696B55794364');

  if (BROWSER)
  {
    // PREVENT PAGE HIJACKING
    if (top.location != self.location) top.location = self.location;

    // HOOK KEYPRESS
    document.onkeydown = function(e) { e = e ? e:typeof event != 'undefined' ? event : null; if (!e) return 0; KEYPRESS(e.keyCode); }

    // DETECT MOBILE DEVICE
    PF = navigator.platform;
    UA = navigator.userAgent;
    DEVICE = UA + ' ' + PF;
    MOBILE = /PHONE|MOBILE|TABLET|IPOD|IPAD|BLACKBERRY|LUMIA|ANDROID|WEBOS|PLAYBOOK|BB10|MINI|CRMO|OPERA MINI|OPERA MOBI|PALM|WINDOWS CE|XOOM|SCH-I800|KINDLE/i.test(DEVICE) | 0;
    ONLINE = (location.href.substr(0, 4).toUpperCase() == 'HTTP') | 0;

    // DETECT 64-BIT CPU
    X64 = /X86_64|X86-64|WIN64|X64|AMD64|WOW64|IA64|SPARC64|PPC64/i.test(DEVICE) | 0;

    // SETUP FORM, CANVAS TEST, SLIDE, AND PIX IMAGE FOR PAGE COUNTER.
    document.write("<FORM NAME=MAIN onSubmit='return false;'><IMG BORDER=0 WIDTH=1 HEIGHT=1 NAME=PIX STYLE='POSITION:ABSOLUTE; TOP:0; LEFT:0;'><CANVAS BORDER=0 WIDTH=1 HEIGHT=1 ID=CVTEST STYLE='POSITION:ABSOLUTE; TOP:0; LEFT:0;'></CANVAS> <IMG BORDER=0 WIDTH=1 HEIGHT=1 NAME=PIX STYLE='POSITION:ABSOLUTE; TOP:0; LEFT:0;'><DIV ID=SLIDE><B>&nbsp;</B></DIV>");

    // DETECT WEB BROWSER
    // Opera 8.0+ / Firefox 0.8+ / Safari 3+ / GoogleChrome 1+ / IE6 / Edge 20+
    function testCSS(prop) { return prop in document.documentElement.style; }
    if (!!(window.opera && window.opera.version) || (!!window.opr && !!opr.addons) || /OPERA|OPR\//i.test(UA)) { $ = "OPERA"; OPERA = 2; }
    else if (Object.prototype.toString.call(window.HTMLElement).indexOf('Constructor') > 0) { $ = "SAFARI"; SAFARI = 4; }
    else if ((testCSS('MozBoxSizing') || typeof InstallTrigger !== 'undefined')) { $ = "FIREFOX"; FIREFOX = 8; }
    else if (testCSS('WebkitTransform') || (!!window.chrome && !!window.chrome.webstore)) { $ = "CHROME"; CHROME = 16; }
    else if (/*@cc_on!@*/false || testCSS('msTransform') || !!document.documentMode) { $ = "MSIE"; MSIE = 32; }
    else if (!!window.StyleMedia) { $ = "EDGE"; EDGE = 64; }
    if (/SEAMONKEY/i.test(UA)) { $ = "SEAMONKEY"; SEAMONKEY = 128; }
    BROWSER |= OPERA | SAFARI | FIREFOX | CHROME | MSIE | EDGE | SEAMONKEY;
    BROWSER_NAME = $;

    // EXTRACT BROWSER VERSION
    if (SAFARI) $ = "VERSION";
    BROWSER_VERSION = ExtractVersion(UA, $);

    // DETECT OS
    OS = PF;
    if (PF == "") OS = "FirefoxOS";
    if (PF == null) OS = "Android";
    if (($ = ExtractVersion(UA, "WINDOWS NT")))
    {      if ($ == 5)   $ = 2000;
      else if ($ == 5.1) $ = "XP";
      else if ($ == 6.0) $ = "Vista";
      else if ($ == 6.1) $ = 7;
      else if ($ == 6.2) $ = 8;
      else if ($ == 6.3) $ = 8;
      OS = "Win" + $;
    }

    // DETECT STORAGE
    COOKIES = TestCookies();
    STORAGE = TestLocalStorage();

    // GET SCREEN RESOLUTION
    Wx = WX = screen.width;
    Hx = HX = screen.height;
    RES = WX * HX;
    LANDSCAPE = (WX > HX) ? 1 : 0;
    ASPECT_RATIO = (HX == 0) ? 1 : WX / HX;
    W1 = W2 = W3 = W4 = W5 = H1 = H2 = H3 = H4 = H5 = 0;
    try { W1 = window.innerWidth; H1 = window.innerHeight; } catch (e) {}
    try { W2 = window.outerWidth; H2 = window.outerHeight; } catch (e) {}
    try { W3 = document.body.offsetWidth; H3 = document.body.offsetHeight; } catch (e) {}
    try { W4 = document.body.clientWidth; H4 = document.body.clientHeight; } catch (e) {}
    try { W5 = document.documentElement.offsetWidth; H5 = document.documentElement.offsetHeight; } catch (e) {}
    Wx = FindLowest(WX, W1, W2, W3, W4, W5);
    Hx = FindLowest(HX, H1, H2, H3, H4, H5);
    if (!LANDSCAPE) { $ = HX; HX = WX; WX = $; $ = Hx; Hx = Wx; Wx = $; }
    SMALL_SCREEN = (WX < 640) ? 1 : 0;   // smartphone display detected
    HIGH_RES = (RES >= 1920000) ? 1 : 0;  // 1600x1200 or higher
    WIDE_SCREEN = (WX > 1000 && ASPECT_RATIO >= 1.6) ? 1 : 0;
    if (SMALL_SCREEN || !LANDSCAPE) MOBILE = 1;

    // DETERMINE BROWSER WINDOW SIZE
    Wx = FindLowest(screen.width, window.innerWidth, window.outerWidth, document.body.offsetWidth, document.body.clientWidth, document.documentElement.offsetWidth);
    Hx = FindLowest(screen.height, window.innerHeight, window.outerHeight, document.body.offsetHeight, document.body.clientHeight, document.documentElement.offsetHeight);

    // GET BROWSER LANGUAGE
    LANGUAGE = (navigator.userLanguage || navigator.language).toUpperCase().replace(/[^A-Z]/g, '');

    // DETECT JAVASCRIPT FEATURES
    JAVA = navigator.javaEnabled() ? 256 : 0;
    WASM = 0; try { if (typeof(WebAssembly) === "object" && typeof(WebAssembly.instantiate) === "function") { M = new WebAssembly.Module(Uint8Array.of(0, 0x61, 0x73, 0x6d, 0x01, 0, 0, 0)); WASM = (M instanceof WebAssembly.Module) ? 2 : 1; } } catch (e) {}
    CANVAS = 0; try { var C = document.getElementById("CVTEST").getContext("2d"); CANVAS = 4; } catch (e) {}
    FATARROW = 0; try { eval("const MUL$$2 = (x, y) => x * y;"); FATARROW = 8; } catch (e) {}
    FUNCDEF = 0; try { eval("MM = function _$Mul(x, y) { return x * y; };"); FUNCDEF = 16; } catch (e) {}
    EXPORT = 0; try { eval("export const XXXTESTXXX = 1;"); EXPORT = 32; } catch (e) {}
    ASYNC = 0; try { eval("async function _$BTEST() { return; }"); ASYNC = 64; } catch (e) {}
    BIGINT = 0; try { eval("sx$ = 999999999999999999999n;"); BIGINT = 128; } catch(e) {}
    LET = 0; try { eval("let _$TEST = 4;"); LET = 256; } catch (e) {}
  }
  else
  {
    MSIE = 32;
    BROWSER_VERSION = 6;
    BROWSER_NAME = 'MSIE';
    try { FSO = WScript.CreateObject("Scripting.FileSystemObject"); FILESYS = 1; }
    catch (e) { EXIT("Cannot access File System."); }
    try { WordObj = WScript.CreateObject("Word.Application"); } catch (e) {}
    try { WshShell = WScript.CreateObject("WScript.Shell"); } catch (e) {}
    ReadDeviceDetails();
  }

  // GET TIMEZONE
  TIMEZONE = Math.round((new Date().getTimezoneOffset() / 60));

  NUM = "0123456789";
  HEX = "0123456789ABCDEF".split("");
  ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  B64 = ABC + NUM + '/+';
  VOWELS = "AEIOUaeiou";
  CONSONANTS = "BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz";
  WHITESPACE = " \t\r\n\0";
  BIN4 = "0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111".split(" ");
  B64SET = "?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
  URLSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz|_";

  // The following characters can be used in a cookie name or value:
  COOKIEJAR = "^0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz$@!?*|#&%~+:-., []{}()_/\\><\"'`";
}
//////////////////////////////////////////////////
//
//
//           GENERAL BASIC FUNCTIONS
//
//

// Displays an alert message box.
function ALERT(S) { if (typeof(document) == 'undefined') WScript.Echo(S); else alert(S); }

// Returns the number of milliseconds since Jan 1 1970.
function TIME() { return (new Date()).getTime(); }

// This function suspends execution of the script for N milliseconds.
function WAIT(N) { if (BROWSER == 0) WScript.Sleep(N); }

// This function displays an error message and terminates the script.
function EXIT(MSG) { if (typeof(MSG) != "undefined") ALERT(MSG); if (BROWSER) return; WordObj.Quit(); WScript.Quit(0); }

// Extracts a version number from string S starting after pattern A
function ExtractVersion(S, A) { var i, C, P = S.indexOf(A); if (P < 0) return ""; P += A.length + 1; for (i = P; i < S.length; i++) { C = S.charCodeAt(i); if (C < 46 || C > 57) break; } return S.substring(P, i); }

function Abort_Script_If_Numlock_Is_OFF() { if (BROWSER) return; if (GetNumlockState() == 0) EXIT(); }

//////////////////////////////////////////////////
//
//
//               HTML FUNCTIONS
//
//

function CLS() { HTML = ['<B>&nbsp;</B>']; RENDER(); }
function PRINT(X) { HTML.push(X); }
function FLUSH() { if (BROWSER) document.write(HTML.join('')); HTML = []; }
function RENDER() { if (BROWSER) document.getElementById('SLIDE').innerHTML = HTML.join(''); HTML = []; }

//////////////////////////////////////////////////
//
//
//         ARGUMENT PROCESSING FUNCTIONS
//
//

function DebugURL() {var i,X=[],L="SELF PATH FILE HOST BOOKMARK ONLINE ARGS ARGC ARGN ARGV".split(" ");for(i=0;i<L.length;i++)X[i]=L[i]+" = "+eval(L[i]);Alert(X.join("\n"));}
function SplitURL(URL){BOOKMARK="";ARGC=0;ARGN=[];ARGV=[];ARGS="";SELF=URL;ONLINE=(URL.substr(0,4).toUpperCase()=="HTTP")?1:0;var i,A,P=URL.lastIndexOf("#");if(P>=0){BOOKMARK=URL.slice(P+1);SELF=URL.substr(0,P);}P=SELF.indexOf("?");if(P>=0){ARGS=SELF.slice(P+1);SELF=SELF.substr(0,P);A=unescape(ARGS).split("&");for(i=0;i<A.length;i++){P=A[i].indexOf("=");if(P>=0){ARGN[ARGC]=A[i].substr(0,P).toUpperCase();ARGV[ARGC++]=A[i].slice(P+1);}}}SELF=SELF.split("\\").join("/");P=SELF.lastIndexOf("/");PATH=SELF.substr(0,P+1);FILE=SELF.slice(P+1);P=PATH.indexOf(":///");if(P>=0)PATH=PATH.slice(P+4);P=PATH.indexOf("://");if(P>=0)PATH=PATH.slice(P+3);PATH=unescape(PATH);P=PATH.indexOf("/");if(ONLINE){HOST=(P>0)?PATH.substr(0,P):PATH;if(HOST.substr(0,4).toUpperCase()=="WWW.")HOST=HOST.slice(4);}else HOST="localhost";}

SplitURL(location.href);

/*
ARGC = 0; ARGN = []; ARGV = []; ARGS = "";
LastSplitAB(location.href, "#"); SELF = $A; BOOKMARK = $B;
if (SplitAB(SELF, "?")) { SELF = $A; ARGS = $B; A = unescape(ARGS).split("&"); for (i = 0; i < A.length; i++) if (SplitAB(A[i], "=")) { ARGN.push($A.toUpperCase()); ARGV.push($B); ARGC++; } }
SELF = StrReplace(SELF, "\\", "/");
LastSplitAB(SELF, "/"); PATH = $A; FILE = $B;
P = PATH.indexOf(":///"); if (P >= 0) PATH = PATH.slice(P+4);
P = PATH.indexOf("://"); if (P >= 0) PATH = PATH.slice(P+3);
PATH = unescape(PATH);
*/

// BOOKMARK holds whatever comes after the # sign in the URL
// ARGS holds location.search without the ? mark
// ARGC holds the argument count (number of values)
// ARGN holds the names for each value
// ARGV holds the corresponding values
// FILE holds the name of the current web page (file name only)
// SELF holds the URL of the current web page without arguments
// PATH holds the current working directory, always ending with a /
// HOST holds the hostname of the current domain without the www. part

// This function returns the value of the named argument. If undefined, DEFAULT is returned.
function GetArgStr(NAME, DEFAULT) { NAME = NAME.toUpperCase(); for (var i = 0; i < ARGC; i++) if (ARGN[i] == NAME) return ARGV[i]; return DEFAULT; }

// This function returns the named argument as an integer. If undefined, DEFAULT is returned. If two more optional arguments are provided, the return value will be an integer between those two values.
function GetArgInt(NAME, DEFAULT) { var MAX = 0x7FFFFFFF; var MIN = -MAX; if (arguments.length > 2) MIN = arguments[2]; if (arguments.length > 3) MAX = arguments[3]; var P = "_TRUE_YES_ALL_ON_", $ = GetArgStr(NAME, DEFAULT); if (isNaN($)) if (P.indexOf(("_"+$.toUpperCase()+"_")) >= 0) $ = 1; if (isNaN($)) $ = 0; $ = Math.round($); if ($ < MIN) $ = MIN; if ($ > MAX) $ = MAX; return $|0; }

//function GetArgInt(ARGS,NAME,DEFAULT){if(typeof(DEFAULT)==="undefined")DEFAULT=0;var VALUE=GetArgStr(ARGS,NAME);return(isNaN(VALUE)||VALUE=="")?DEFAULT:Math.round(VALUE);}
//function GetArgStr(ARGS,NAME,DEFAULT){if(typeof(DEFAULT)==="undefined")DEFAULT="";ARGS=cut(ARGS,"?",0x0101);ARGS=cut(ARGS,"#",0x1110);ARGS=cut("&"+ARGS+"&","&"+NAME+"=",1);if(ARGS.length==0)return DEFAULT;return cut(ARGS,"&",0x10);}

// This function returns a string argument from the provided URL. If the argument is missing, an empty string is returned.
// function GetArgStr(ARGS, NAME) { ARGS = cut(ARGS, "?", 0x0101); ARGS = cut(ARGS, "#", 0x1110); ARGS = cut("&" + ARGS, "&" + NAME + "=", 1); if (ARGS.length == 0) return ""; return cut(ARGS, "&", 0x110); }
//
// This function returns the named integer argument from the provided URL. If the argument is missing, zero is returned.
// function GetArgInt(ARGS, NAME, MAXVALUE) { return toInt(GetArgStr(ARGS, NAME), MAXVALUE); }

//////////////////////////////////////////////////
//                                      v2021.2.10
// This function expects to receive a full URL,
// and it returns the web address only without
// the arguments and bookmark.
// Usage: STRING = GetWebAddressOnly(URL)
//
function GetWebAddressOnly(URL)
{
  URL = cut(URL, "?", 0x0110);  // Cut the first "?" and everything after it if it's found
  URL = cut(URL, "#", 0x1110);  // Cut the last "#" and everything after it if it's found
  return URL;
}

//////////////////////////////////////////////////
//
//
//               EXCEL FUNCTIONS
//
//

//////////////////////////////////////////////////
//                                CSV | v2021.4.22
// Splits a single line of a CSV file into an array.
// Each column will be a separate array element.
//
// Usage: ARRAY = SplitCSV(LINE)
//
function SplitCSV(LINE)
{
  if (typeof(LINE) == 'undefined' || LINE == null) return [];
  LINE += ",";
  if (LINE.length < 2) return [];
  var i, c, QT = 0, START = -1, A = [];
  for (i = 0; i < LINE.length; i++)
  {
    c = LINE.charCodeAt(i);
    if (c == 44)       // Comma
    {
      if (QT < 3)
      {
        c = (START < 0) ? "" : LINE.substring(START, i);
        if (QT == 2)
        {
          START = c.indexOf('"') + 1;
          c = c.slice(START);
          START = c.lastIndexOf('"');
          c = c.substr(0, START);
          c = c.replace(/\"\"/g, '"');
        }
        else
          c = Trim(c);
        A.push(c);
        START = -1;
        QT = 0;
      }
    }
    else
    {
      if (c == 34) QT = (QT & 1) ? 2 : 3;  // Double quote
      if (START < 0) START = i;
    }
  }
  if (QT == 3)
  {
    // WE GET HERE IF THERE IS AN UNEXPECTED END OF LINE
    // BECAUSE OF AN UNMATCHED " CHARACTER:
    // Try to make sense of this mess
    QT = 0;
    var SAVE = [];
    for (var END = i = LINE.length - 1; i > START; i--)
    {
      c = LINE.charCodeAt(i);
      if (c == 44)       // Comma
      {
        if (QT < 3)
        {
          c = LINE.substring(i, END);
          if (QT == 2)
          {
            END = c.indexOf('"') + 1;
            c = c.slice(END);
            END = c.lastIndexOf('"');
            c = c.substr(0, END);
            c = c.replace(/\"\"/g, '"');
          }
          else
            c = Trim(c);
          SAVE.push(c);
          END = i - 1;
          QT = 0;
        }
      }
      else if (c == 34)
        QT = (QT & 1) ? 2 : 3;  // Double quote
    }
    while (SAVE.length)
      A.push(SAVE.pop());
  }
  return A;
}
//////////////////////////////////////////////////
//                                      v2021.4.26
// If the first argument is a letter, this function
// returns the column number. If the first argument
// is a number, then it returns the column letter.
// Usage: INTEGER = Column(STRING)
//         STRING = Column(INTEGER)
//
function Column(c)
{
  return (typeof(c) == "string") ? GetColumnNumber(c) : GetColumnLetter(c);
}
//////////////////////////////////////////////////
//                                      v2021.4.25
// This function returns the previous column label
// when the current one is already known.
// Spreadsheet columns are usually labeled as
// A, B, C, ... AA, AB, ... AAA, AAB, etc, so for
// example, PrevColumn("ABC") returns => "ABB"
// After this function is down to "A",
// it returns an empty string.
// Usage: STRING = PrevColumn(STRING)
//
function PrevColumn(LETTER)
{
  if (typeof(LETTER) === "undefined" || LETTER == null) return "A";
  LETTER = (LETTER + "").toUpperCase().split("");
  var i = LETTER.length, CARRY = 0, SUB = 1;
  while (i--)
  {
    c = LETTER[i].charCodeAt(0) - CARRY - SUB;
    if (c >= 65)
    {
      LETTER[i] = String.fromCharCode(c);
      CARRY = 0;
    }
    else if (c == 64)
    {
      LETTER[i] = (i) ? String.fromCharCode(90) : "";
      CARRY = 1;
    }
    SUB = 0;
  }
  return LETTER.join("");
}
//////////////////////////////////////////////////
//                                      v2021.4.25
// This function returns the next column label
// when the previous one is already known.
// Spreadsheet columns are usually labeled as
// A, B, C, ... AA, AB, ... AAA, AAB, etc.
// Usage: STRING = NextColumn(STRING)
//
function NextColumn(LETTER)
{
  if (typeof(LETTER) === "undefined" || LETTER == null) return "A";
  LETTER = (LETTER + "").toUpperCase().split("");
  var i = LETTER.length, CARRY = 0, ADD = 1;
  while (i--)
  {
    c = LETTER[i].charCodeAt(0) + CARRY + ADD;
    if (c > 90) { c = 65; CARRY = 1; } else { CARRY = 0; }
    LETTER[i] = String.fromCharCode(c);
    ADD = 0;
  }
  return (CARRY ? "A" : "") + LETTER.join("");
}
//////////////////////////////////////////////////
//                                      v2021.4.25
// This function converts an integer (0-18278) to
// a column letter. Spreadsheet columns are usually
// labeled as A, B, C, ... AA, AB, ... AAA, AAB, etc.
// If N is negative or NaN, the letter "A" is returned.
// Usage: STRING = GetColumnLetter(INTEGER)
//
function GetColumnLetter(N)
{
  N |= 0;
  if (N < 1) return "A";
  if (N < 26) return String.fromCharCode(N + 65);
  if (N < 702) return String.fromCharCode(((N / 26) | 0) + 64) + String.fromCharCode(N % 26 + 65);
  if (N < 18278)
  {
    var prev = 702;
    var LIMIT = 1378;
    for (var i = 0; i < 26; i++)
    {
      if (N < LIMIT)
      {
        N -= prev;
        return String.fromCharCode(i + 65) + String.fromCharCode(((N / 26) | 0) + 65) + String.fromCharCode(N % 26 + 65);
      }
      prev = LIMIT;
      LIMIT += 676;
    }
  }
  return "AAAA";
}
//////////////////////////////////////////////////
//                                      v2021.4.25
// This function converts a column letter to a
// numeric value. A=0 B=1 C=2 AA=26 AB=27 etc...
// If the letter turns out to be an invalid
// character, then zero is returned.
// Usage: INTEGER = GetColumnNumber(LETTER)
//
function GetColumnNumber(LETTER)
{
  if (typeof(LETTER) === "undefined" || LETTER == null) return 0;
  LETTER = (LETTER + "").toUpperCase();
  var c, i, V = [], MUL = 1, RET = 0;
  if (LETTER.length <= 1)
  {
    c = LETTER.charCodeAt(0);
    return (c > 64 && c < 91) ? c - 65 : 0;
  }
  for (i = 0; i < LETTER.length; i++)
  {
    c = LETTER.charCodeAt(i);
    if (c > 64 && c < 91) V.push(c - 65);
  }
  if (V.length) V[0]++;
  if (V.length > 2) V[1]++;
  if (V.length > 3) V[2]++;
  for (i = V.length - 1; i >= 0; i--)
  {
    RET += V[i] * MUL;
    MUL *= 26;
  }
  return RET;
}
//////////////////////////////////////////////////
//                                CSV | v2023.3.13
// This function joins an array to form a single
// line of a CSV file. Elements will be separated
// with a comma.
// Usage: STRING = JoinCSV(ARRAY)
//
function JoinCSV(A)
{
  var i;
  var $ = [];
  for (i = 0; i < A.length; i++)
  {
    if (typeof(A[i]) === "undefined" || A[i] == null) { A[i] = ""; continue; }
    $[i] = A[i] + "";
    if ($[i].indexOf(",") >= 0 || $[i].indexOf('"') >= 0)
      $[i] = '"' + $[i].split('"').join('""') + '"';
  }
  return $.join(",");
}

//////////////////////////////////////////////////
//
//
//              COOKIE FUNCTIONS
//
//

// This function saves a cookie that expires in 5 years (if the expiration is not specified). The expiration must be given in seconds, which tells the browser how long the cookie will exist. This function returns 1 on success. Returns 0 if the cookie could not be saved.
function SetCookie(NAME, VALUE, EXPIRATION) { var DATE = new Date(); var COOKIE = NAME + "=" + (typeof(VALUE) === "undefined" ? "" : VALUE); DATE.setTime(DATE.getTime() + 1000 * (typeof(EXPIRATION) === "undefined" ? 157680000 : EXPIRATION)); document.cookie = COOKIE + ";Expires=" + DATE.toGMTString() + ";"; return document.cookie.indexOf(COOKIE) < 0 ? 0 : 1; }

// Returns the value of a cookie. If the cookie could not be found, an empty string is returned.
function GetCookie(NAME) { var i, s, COOKIE = document.cookie.split(";"); for (i = 0; i < COOKIE.length; i++) if ((s = COOKIE[i].indexOf(NAME + "=")) >= 0) return COOKIE[i].slice(s + NAME.length + 1); return ""; }

// Deletes a cookie from the browser's storage.
function DeleteCookie(NAME) { document.cookie = NAME + "=;Expires=Jan 01 1970 01:01:01 GMT"; }

// Returns the names of all saved cookies.
function GetCookieNames() { var i, P, COOKIE = document.cookie.split(";"), A = []; for (i = 0; i < COOKIE.length; i++) if ((P = COOKIE[i].indexOf("=")) >= 0) A.push(Trim(COOKIE[i].substr(0, P))); return A; }

// Erases all cookies, and returns the number of cookies deleted.
function DeleteAllCookies() { var i, COOKIE = GetCookieNames(); for (i = 0; i < COOKIE.length; i++) DeleteCookie(COOKIE[i]); return COOKIE.length; }

// This function returns 0 when cookies are disabled. Returns 1 when cookies are enabled yet new cookies cannot be saved. Returns 2 when cookies can be saved and retrieved without a problem.
function TestCookies() { var TEST_NAME = "XXTEST123XX"; var TEST_VALUE = "Blessed are the pure in heart, for they shall see God. Matthew 5:8 (NKJV)"; SetCookie(TEST_NAME, TEST_VALUE); if (GetCookie(TEST_NAME) == TEST_VALUE) { DeleteCookie(TEST_NAME); return 2; } return navigator.cookieEnabled ? 1 : 0; }

//////////////////////////////////////////////////
//
//
//            LOCALSTORAGE FUNCTIONS
//
//

// This function saves a string in localStorage. Returns 1 if the value could not be saved. Returns 0 on success.
function SetItem(NAME, VALUE) { if (typeof(VALUE) === "undefined" || VALUE == null) VALUE = ""; try { with(window.localStorage) { setItem(NAME, VALUE); if (getItem(NAME) == VALUE) return 0; } } catch(e) {} return 1; }

// Retrieves a string from localStorage. If the named value is not found, an empty string is returned.
function GetItem(NAME) { try { var X = localStorage.getItem(NAME); return (X == null) ? "" : X; } catch(e) {} return ""; }

// This function returns the names of values saved in localStorage.
function GetItemNames() { var i, A = []; try { for (i = 0; i < localStorage.length; i++) A[i] = localStorage.key(i); } catch(e) {} return A; }

// Deletes one item from localStorage. Returns 1 on success. Returns 0 if the operation failed.
function DeleteItem(NAME) { try { with(window.localStorage) { setItem(NAME, ""); removeItem(NAME); } return 1; } catch(e) {} return 0; }

// Completely erases all values from localStorage. On success, returns the number of items removed. On failure, returns -1.
function DeleteAllItems() { try { var L = window.localStorage.length; window.localStorage.clear(); return L; } catch(e) {} return -1; }

// This function returns 2 when localStorage is enabled and values can be saved and retrieved with no problem. Returns 1 when localStorage is enabled, yet for some reason new values cannot be saved. Returns 0 when localStorage is not supported.
function TestLocalStorage() { var STATUS = 0; var TEST_NAME = "XXTEST123XX"; var TEST_VALUE = "Blessed are the peacemakers, for they shall be called sons of God. Matthew 5:9 (NKJV)"; try { localStorage.setItem(TEST_NAME, TEST_VALUE); STATUS = 1; if (localStorage.getItem(TEST_NAME) == TEST_VALUE) { localStorage.removeItem(TEST_NAME); STATUS = 2; }} catch (e) {} return STATUS; }

//////////////////////////////////////////////////
//
//
//            OS DEPENDENT FUNCTIONS
//
//

// This function positions our window in the center of the screen.
function PRESS(KEYCODE) { if (BROWSER) return; WAIT(100); try { var WSH = new ActiveXObject("WScript.Shell"); WSH.SendKeys(KEYCODE); } catch (e) {} }
function PlayMP3(FILENAME) { if (BROWSER) return; RUN(QUOTE("C:\\BIN\\COMMAND\\PLAYMP3.EXE") + " " + QUOTE(FILENAME)); }
function WinFocus(W) { if (BROWSER) return; try { var WSH = new ActiveXObject("WScript.Shell"); WSH.AppActivate(W); } catch (e) {} }
function RunPerl(FILE, ARGS) { if (BROWSER) return; RUN("C:\\BIN\\PERL\\PERL.BAT PAUSE! \"" + FILE + "\" " + EscapeString(ARGS, '#0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!?*-._')); }
function RunNotepad(NAME) { RUN("C:\\WINDOWS\\NOTEPAD.EXE \"" + NAME + '"'); }
function RUN(CMD) { if (BROWSER) return; try { var WSH = new ActiveXObject("WScript.Shell"); WSH.Run(CMD); } catch (e) {} }
function TYPE(TEXT) { if (BROWSER) return; var i, t; for (i = 0; i < TEXT.length; i++) { t = TEXT.charAt(i); WAIT(20); if (i > 5) { t = TEXT.slice(i); i = TEXT.length; } PRESS(t); } }
function ShortAlert(MSG) { WshShell.Popup(MSG, 3, "Alert", 0); }

function OpenBasicUserAccounts()   { ShellApp.ControlPanelItem('NUSRMGR.CPL'); }
function OpenSystemProperties()    { ShellApp.ControlPanelItem('SYSDM.CPL'); }
function OpenWindowsUserAccounts() { RUN('C:\\WINDOWS\\SYSTEM32\\RUNDLL32.EXE C:\\WINDOWS\\SYSTEM32\\NETPLWIZ.DLL,UsersRunDll'); }
function OpenWindowsUserManager()  { RUN('LUSRMGR.MSC'); }
function OpenWindowsComponents()   { RUN('C:\\WINDOWS\\SYSTEM32\\RUNDLL32.EXE SHELL32.DLL,Control_RunDLL APPWIZ.CPL,,2'); }
function OpenScreenSaverSettings() { RUN('C:\\WINDOWS\\SYSTEM32\\RUNDLL32.EXE SHELL32.DLL,Control_RunDLL DESK.CPL,,1'); }
function OpenBgPictureSettings()   { RUN('C:\\WINDOWS\\SYSTEM32\\RUNDLL32.EXE SHELL32.DLL,Control_RunDLL DESK.CPL,,0'); }
function OpenMouseSettings()       { RUN('C:\\WINDOWS\\SYSTEM32\\RUNDLL32.EXE SHELL32.DLL,Control_RunDLL MAIN.CPL,,1'); }
function OpenKeyboardSettings()    { RUN('C:\\WINDOWS\\SYSTEM32\\RUNDLL32.EXE SHELL32.DLL,Control_RunDLL MAIN.CPL @1'); }
function OpenSoundsSettings()      { RUN('C:\\WINDOWS\\SYSTEM32\\RUNDLL32.EXE SHELL32.DLL,Control_RunDLL MMSYS.CPL,,1'); }
function OpenFoldersSettings()     { RUN('C:\\WINDOWS\\SYSTEM32\\CONTROL.EXE folders'); }

function RegRead(REGKEY) { try { return WshShell.RegRead(REGKEY); } catch(e) { return ""; } }
function RegWrite(REGKEY, VALUE, TYPE) { try { WshShell.RegWrite(REGKEY, VALUE, TYPE); } catch(e) {} }
function RegDelete(REGKEY) { try { WshShell.RegDelete(REGKEY); } catch(e) {} }

function GetReg(r) { try { return WshShell.RegRead(ExpandRegPath(r)); } catch(e) {} return ""; }
function DelReg(r) { try { WshShell.RegDelete(ExpandRegPath(r)); } catch(e) {} }
function SetReg(r) { r = r.split("|"); var PATH = ExpandRegPath(r[0]); var TYPE = r[1].toUpperCase(); var VALUE = r[2]; try { WshShell.RegWrite(PATH, VALUE, TYPE); } catch(e) {} }

//////////////////////////////////////////////////
function ExpandRegPath(r)
{
  r = r.split("/").join("\\");
  var $ = r.slice(4);
  var X = r.substr(0, 4).toUpperCase();
  if (X == "HKCU") return "HKEY_CURRENT_USER" + $;
  if (X == "HKCR") return "HKEY_CLASSES_ROOT" + $;
  if (X == "HKLM") return "HKEY_LOCAL_MACHINE" + $;
  if (X == "HKCC") return "HKEY_CURRENT_CONFIG" + $;
  return r;
}
//////////////////////////////////////////////////
function DIR(p)
{
  var FILES = [];
  var PATH_LENGTH = p.length + ((p.slice(-1) == '\\') ? 0 : 1);
  var F = FSO.GetFolder(p), FC, File, FullName;
  function DateOf(f) { return ('0000000000' + (f.DateLastModified * 1)).slice(-13).substr(0, 10) + ' '; }
  function SizeOf(f) { return ('00000000000' + f.Size + ' ').slice(-12); }
  function Shorten(n) { return (n + '').slice(PATH_LENGTH); }
  for (FC = new Enumerator(F.SubFolders); !FC.atEnd(); FC.moveNext())
  {
    FullName = FC.item();
    File = FSO.GetFolder(FullName);
    FILES.push('+' + DateOf(File) + Shorten(FullName));
  }
  for (FC = new Enumerator(F.files); !FC.atEnd(); FC.moveNext())
  {
    FullName = FC.item();
    File = FSO.GetFile(FullName);
    FILES.push(SizeOf(File) + DateOf(File) + Shorten(FullName));
  }
  return FILES;
}
//////////////////////////////////////////////////
// This function tries to detect the Windows version.
// Returns 0 = Unknown
//         1 = Windows 95
//         2 = Windows 98
//         3 = Windows Me
//         4 = Windows 2000
//         5 = Windows XP
//         6 = Windows Vista
//         7 = Windows 7
//         8 = Windows 8
//        10 = Windows 10
//
function WinVer()
{
  var X = GetReg("HKLM/SOFTWARE/Microsoft/Windows/CurrentVersion/VersionNumber");
  if (X.indexOf("4.00.950") >= 0) return 1;
  var V = GetReg("HKLM/SOFTWARE/Microsoft/Windows/CurrentVersion/Version").toUpperCase();
  if (V.indexOf("MILLENNIUM") >= 0) return 3;
  if (X || V) return 2;
  V = GetReg("HKLM/SOFTWARE/Microsoft/Windows NT/CurrentVersion/CurrentVersion");

  if (V == "5.0") return 4;
  if (V == "5.1" || V == "5.2") return 5;
  if (V == "6.0") return 6;
  if (V == "6.1") return 7;
  if (V == "6.2" || V == "6.3") return 8;
  if (V == "10.0") return 10;

  return 0;
}
//////////////////////////////////////////////////
function BrowseForFile(DIR)
{
  var FBROWSER, SELECTION = false;
  try
  {
    FBROWSER = new ActiveXObject("UserAccounts.CommonDialog");
    FBROWSER.Filter = "All Files|*.*";
    FBROWSER.FilterIndex = 1;
    FBROWSER.InitialDir = DIR;
    SELECTION = FBROWSER.ShowOpen();
  }
  catch (e)
  {
    ALERT("Sorry, the \"Browse\" button doesn't work.\n\nYou must type or paste the directory path.");
    return "";
  }

  // User must have canceled.
  if (SELECTION = false) return "";
  var F = FBROWSER.FileName;
  if (F == "") return "";
  return F;
}
//////////////////////////////////////////////////
// This function opens a Browse for Folder window
// and allows the user to select a folder and returns the selected folder...
function BrowseForFolder(SEARCHING_FOR)
{
  try
  {
    var SHELL = new ActiveXObject("Shell.Application");
    var F = SHELL.BrowseForFolder(0, "You are looking for : " + SEARCHING_FOR + "\nDid you know, you can move folders by simply pulling them onto another folder?", 1);
  }
  catch (e) { return ""; }  // Error. Didn't work.
  if (F == null) return ""; // ESC or CANCEL
  return F.self.Path;       // SUCCESS
}
//////////////////////////////////////////////////
function OpenFileDialog()
{
  var InitFSO = 0, U, FILENAME = '';
  try
  {
    // create an instance of the File Browser
    U = new ActiveXObject("UserAccounts.CommonDialog");

    // setup the File Browser specifics
    U.Filter = "All Files|*.*";
    U.FilterIndex = 3;
    U.InitialDir = PATH;

    // Show the file browser and return the selection (or lack of) to InitFSO
    InitFSO = U.ShowOpen();
  } catch (e) {}

  if (InitFSO) FILENAME = U.FileName + "";
  return FILENAME;
}
//////////////////////////////////////////////////
function RequireWindowsXP_or_Exit()
{
  try
  {
    // If this is not Windows XP, then quit.
    if (RegRead("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ProductName") != "Microsoft Windows XP")
      Quit("This program will only work with Windows XP.");
  }
  catch (e) {}
}
//////////////////////////////////////////////////
//                                      v2021.3.16
// This function reads the screen width and height
// and sets certain global variables:
// Usage: ReadDeviceDetails()
//
function ReadDeviceDetails()
{
  var MSIE = WScript.CreateObject("InternetExplorer.Application");
  MSIE.Visible = 0;
  MSIE.Navigate("about:blank");
  WScript.Sleep(10);
  WX = MSIE.document.parentWindow.screen.width;
  HX = MSIE.document.parentWindow.screen.height;
  CC = MSIE.document.parentWindow.screen.colorDepth;
  LANDSCAPE = WX > HX ? 1 : 0;
  var _WX = WX, _HX = HX;
  if (!LANDSCAPE) { _WX = HX; _HX = WX; }
  ASPECT_RATIO = Math.round(_WX / _HX * 100) / 100;
  MSIE.Quit();
}
//////////////////////////////////////////////////
/* The MsgBox() function displays a popup message box
regardless of which host executable file is running
(WScript.exe or CScript.exe). If DELAY is 0 or undefined,
the pop-up message box remains visible until closed by
the user. If DELAY is greater than zero, the pop-up
message box closes after that many seconds.
If you do not supply the argument TITLE, the title of
the pop-up message box defaults to "Windows Script Host."
The following tables shows the values and their
meanings for TYPE. You can combine values in these tables.

Type Values:
--------------------------------------
0 = Show OK button.
1 = Show OK and Cancel buttons.
2 = Show Abort, Retry, and Ignore buttons.
3 = Show Yes, No, and Cancel buttons.
4 = Show Yes and No buttons.
5 = Show Retry and Cancel buttons.
--------------------------------------
16 = Show "Stop Mark" icon.
32 = Show "Question Mark" icon.
48 = Show "Exclamation Mark" icon.
64 = Show "Information Mark" icon.
--------------------------------------

Possible return values:
--------------------------------------
1 = OK button
2 = Cancel button
3 = Abort button
4 = Retry button
5 = Ignore button
6 = Yes button
7 = No button
--------------------------------------
*/

function MsgBox(Msg, Title, Expire, Type)
{
  var A = -1;
  if (typeof(WshShell) == "undefined") { ALERT(Msg); return -1; }
  if (typeof(Type) == "undefined") Type = 0;
  if (typeof(Title) == "undefined") Title = "Windows Script Host";
  if (typeof(Expire) == "undefined") Expire = 0;
  try { A = WshShell.Popup(Msg, Expire, Title, Type); } catch (e) {}
  return A;
}
//////////////////////////////////////////////////
//                                      v2021.1.18
// This function resizes the main window
// and positions it in the center of the screen.
// Usage: CENTER(WINDOW_WIDTH, WINDOW_HEIGHT)
//
function CENTER(W, H)
{
  if (BROWSER) return;
  var WinNT = RegRead("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\CurrentVersion");
  // Some earlier versions of Windows will say,
  // "Runtime Error: Access is Denied" if we try to
  // resize the window immediately when it pops up,
  // so we'll wait a little if necessary...
  if (WinNT < 6) WAIT(300);
  var X = Math.round((screen.width - W) / 2 - 15);
  var Y = Math.round((screen.height - H) / 2 - 60);
  if (X < 0) X = 0;
  if (Y < 0) Y = 0;
  self.moveTo(X, Y);
  self.resizeTo(W, H);
}
//////////////////////////////////////////////////
//                                      v2021.3.16
// This function copies all text from the clipboard.
// This is done by creating an Internet Explorer
// document in the background that contains a form
// and a textbox for input. After pasting whatever
// is on the clipboard into the textarea, we can
// reads its contents and return the string.
// This takes about 200ms.
//
// Usage: STRING = ReadClipboardText()
// 
function ReadClipboardText()
{
  var MSIE = WScript.CreateObject("InternetExplorer.Application");
  MSIE.Visible = 0;
  MSIE.ToolBar = 0;
  MSIE.StatusBar = 0;
  MSIE.FullScreen = 1;
  MSIE.Navigate("about:blank");
/*
  MSIE.RegisterAsDropTarget = 0;
  WScript.Sleep(100);
  MSIE.Width = 600;
  MSIE.Height = 400;
  MSIE.Left = (MSIE.document.parentWindow.screen.availWidth - MSIE.Width) / 2;
  MSIE.Top = (MSIE.document.parentWindow.screen.availHeight - MSIE.Height) / 2;
*/
  var HTML = "<HTML><HEAD><TITLE></TITLE></HEAD><BODY onLoad='Init();' SCROLL=NO><FORM NAME=MAIN><TEXTAREA NAME=INPUT COLS=20 ROWS=5></TEXTAREA><SCRIPT> function Init() { document.MAIN.INPUT.focus(); } \x3C/SCRIPT>";
  WScript.Sleep(100);
  MSIE.Document.open();
  MSIE.Document.write(HTML);
  MSIE.Document.close();
  WScript.Sleep(100);
  PRESS("+{INSERT}");
  WScript.Sleep(150);
  var TEXT = MSIE.Document.MAIN.INPUT.value + "";
  WScript.Sleep(50);
  MSIE.Quit();
  return TEXT;
}
//////////////////////////////////////////////////
//                                      v2021.3.15
// This function returns 1 when Numlock is ON.
// Returns 0 when Numlock is OFF.
// Usage: INTEGER = GetNumlockState()
//
function GetNumlockState() { return (WordObj.NumLock) & 1; }
//////////////////////////////////////////////////
//                             Voice | v2020.12.13
// This function will cause the computer to read some English
// text in audible human voice if the volume is turned up.
// If the voice service is unavailable, then the
// words will be displayed in a text box.
//
function Say(TEXT)
{
  try
  {
    var Audio = new ActiveXObject("SAPI.SpVoice");
    Audio.Volume = 100;
    Audio.Speak(TEXT);
  }
  catch (e) { ALERT(TEXT); }
}

//////////////////////////////////////////////////
//
//
//             FILE I/O FUNCTIONS
//
//

function GetCurrentDirectory()
{
  var PATH;
  if (typeof(window) == 'undefined') return cut(WScript.ScriptFullName, '\\', 0x10110);
  PATH = location.href.replace(/^file:[\/]+/i, '');
  PATH = PATH.replace(/^(ftp|http|https)(:[\/\\]+[^\?\&\/]+)([^\?\&\#]+).*/i,
    function (a, b, c, d) { return b + c + cut(d, '/', 0x10110); });
  return PATH.replace(/(.*)\/[a-zA-Z0-9\-\_]+\.[a-zA-Z0-9\-\_]+$/i,
    function (a, b) { return b; });
}
//////////////////////////////////////////////////
//                                      v2021.4.30
// Returns the path of a file always followed by a
// separator character. The separator will be changed
// to a backslash unless otherwise specified.
// Usage: STRING = GetPath(FULLNAME, [SEPARATOR])
//
function GetPath(FULLNAME, SEPARATOR)
{
  if (typeof(SEPARATOR) === "undefined") SEPARATOR = "\\"; else SEPARATOR += "";
  FULLNAME = FULLNAME.replace(/[\/\\]/g, SEPARATOR);
  var P = FULLNAME.lastIndexOf(SEPARATOR);
  return ((P < 0) ? "." : FULLNAME.substr(0, P)) + SEPARATOR;
}
//////////////////////////////////////////////////
//
// This function joins two names into a single path by
// adding / in between the names. It also simplifies the
// resulting path by removing repeated \\ // characters,
// and tries to resolve the "." and ".." in a path name
// to literal names only.
// Usage: STRING = JoinPath(STRING, STRING, [STRING]...)
//
function JoinPath(PATH)
{
  var A = [], i;
  for (i = 0; i < arguments.length; i++)
  {
    if (arguments[i].length)
      A.push(Trim(arguments[i].split("/").join("\\")));
  }

  // Remove prefix
  if (PATH.substr(0, 8).toUpperCase() == "FILE:///")
    PATH = PATH.slice(8);

  // Detect drive letter / start point
  var DRIVE = "";
  var BACKSLASH = "";
  if (PATH.charAt(1) == ":")
  {
    DRIVE = PATH.substr(0, 2);
    PATH = PATH.slice(2);
  }
  if (PATH.charAt(0) == "\\")
  {
    BACKSLASH = "\\";
    PATH = PATH.slice(1);
  }
  A[0] = PATH;

  // Process each section of path
  for (i = 0; i < A.length; i++)
  {
    // Remove leading and trailing slashes
    A[i] = TrimChar(A[i], "/\\");

    // Remove "." or zero-length string
    if (A[i] == "." || A[i].length == 0)
    { A.splice(i--, 1); continue; }

    // Resolve ".."
    if (A[i] == "..")
    {
      if (i > 0)
      { A.splice(--i, 2); i--; }
      else
      { A.splice(i, 1); i--; }
    }
  }
  return DRIVE + BACKSLASH + A.join("\\");
}
//////////////////////////////////////////////////
//                                      v2020.2.18
// This function takes a full path or URL of a
// file name and returns the protocol, drive,
// path, file name and extension, arguments,
// and bookmarks in an array.
//
function SplitPath(FULLPATH)
{
  var PROTOCOL = "";
  var P = FULLPATH.indexOf("://");
  if (P >= 0)
  {
    PROTOCOL = FULLPATH.substr(0, P);
    FULLPATH = FULLPATH.slice(P + 3);
    while (FULLPATH.charAt(0) == "/")
      FULLPATH = FULLPATH.slice(1);
  }
  var DRIVE_ONLY = "";
  var PATH_ONLY = "";
  var PATH = FULLPATH;
  var NAME = "";
  var EXT = "";
  var ARGS = "";
  var BOOKMARK = "";
  if (PATH.charAt(1) == ":")
  {
    DRIVE_ONLY = PATH.charAt(0).toUpperCase();
    PATH_ONLY = PATH.slice(2);
  }
  P = PATH.indexOf("?") + 1;
  if (P)
  {
    ARGS = PATH.slice(P);
    PATH = PATH.substr(0, P-1);
    P = ARGS.lastIndexOf("#") + 1;
    if (P)
    {
      BOOKMARK = ARGS.slice(P);
      ARGS = ARGS.substr(0, P-1);
    }
  }
  else
  {
    P = PATH.lastIndexOf("#") + 1;
    if (P)
    {
      BOOKMARK = PATH.slice(P);
      PATH = PATH.substr(0, P-1);
    }
  }
  P = PATH.lastIndexOf("\\") + 1;
  if (P)
  {
    NAME = PATH.slice(P);
    PATH = PATH.substr(0, P-1);
  }
  P = NAME.lastIndexOf(".") + 1;
  if (P)
  {
    EXT = NAME.slice(P);
    NAME = NAME.substr(0, P-1);
  }
  PATH = PATH.replace(/\//g, "\\");
  return [PROTOCOL, DRIVE_ONLY, PATH_ONLY, PATH, NAME, EXT, ARGS, BOOKMARK];
}
//////////////////////////////////////////////////
//                                      v2021.4.24
// Displays the description of this script.
// Usage: About()
//
function About()
{
  if (ONLINE || BROWSER) return;
  ALERT(Trim(cut(ReadFile(SELF, 0, 2000), "////", 0x10).replace(/\/\/[ \t]*/g, "")));
}
//////////////////////////////////////////////////
//                                      v2021.3.15
// This function returns 1 if the file exists.
// Returns 0 if the file doesn't exist.
// Usage: INTEGER = FileExists(FILENAME)
//
function FileExists(FILENAME)
{
  var FSO, E = 0;
  try
  {
    FSO = new ActiveXObject("Scripting.FileSystemObject");
    E = FSO.FileExists(FILENAME);
  }
  catch (e) {}
  return E;
}
//////////////////////////////////////////////////
//
// This function clears a file's attributes to Archive.
// Writes error message in global variable $a.
// Returns: 0=Success 1=Failure
// Usage: INTEGER = ResetFileAttrib(FILENAME, [NEW_ATTRIBUTES])
//
function ResetFileAttrib(FILENAME, NEW_ATTRIBUTES)
{
  // Set Archive attribute and clear S-H-R attributes by default.
  if (typeof(NEW_ATTRIBUTES) === "undefined") NEW_ATTRIBUTES = 32;

  $a = "";
  try
  {
    var FSO = new ActiveXObject("Scripting.FileSystemObject");
    var F = FSO.GetFile(FILENAME);
    F.Attributes = NEW_ATTRIBUTES;
    $a = "SUCCESS";
    return 0;
  }
  catch (e) { $a = e.message; }
  return 1;
}
//////////////////////////////////////////////////
// This is probably not the best solution.
// Create a BAT script with copy commands and
// execute it rather than doing it this way:
function CopyFile(SRC, DST) { var F = FSO.GetFile(SRC); F.Copy(DST); }
//////////////////////////////////////////////////
//                               File | v2021.4.24
// This function reads a text file in its entirety
// and returns it as an array. Each line of the
// file will be an array element.
//
// Usage: ARRAY = ReadTextFile(FILENAME)
//
function ReadTextFile(F)
{
  try
  {
    var FSO = new ActiveXObject('Scripting.FileSystemObject');
    // Open text file for read only in ASCII format.
    // And don't create file if it doesn't exist.
    var File = FSO.OpenTextFile(F, 1, 0, 0);
    var DATA = File.ReadAll();
    File.Close();
    return DATA.split("\r\n");
  } catch (e) {}
  return [];
}
//////////////////////////////////////////////////
//                               File | v2023.3.13
// Creates and overwrites a text file in ASCII format.
// The input array will be converted to lines using
// CR+LF, and each line will be written to the file.
// Returns 0 on success or 1 if an error occurred.
//
// Usage: INTEGER = CreateTextFile(FILENAME, ARRAY)
//
function CreateTextFile(F, A)
{
  try
  {
    var FSO = new ActiveXObject('Scripting.FileSystemObject');
    F = FSO.CreateTextFile(F, 1, 0);
    F.Write(A.join("\r\n"));
    F.Close();
    return 0;
  }
  catch (e) {}
  return 1;
}
//////////////////////////////////////////////////
//                                     v2020.01.27
// This function creates a file or overwrites an
// existing file with a Unicode string. Returns 0 on
// success, or returns an error message (string).
//
function CreateUnicodeFile(FILENAME, CONTENT)
{
  try
  {
    var F = FSO.CreateTextFile(FILENAME, true, true);
    F.Write(CONTENT);
    F.Close();
  }
  catch (e) { return e; }
  return 0;
}
//////////////////////////////////////////////////
//                                      v2021.4.24
// Reads a binary file and returns its contents as a string.
// START: Start reading at file pointer or line pointer
// LENGTH: 0=Read entire file +VALUE=Read only certain number of bytes -VALUE=Read only one line
// FORMAT: 0=ASCII -1=UNICODE
// Usage: STRING = ReadFile(FILENAME, [START, [LENGTH, [FORMAT]]])
//
function ReadFile(FILENAME, START, LENGTH, FMT)
{
  if (TERMINATED) return "";
  FMT |= 0;
  START |= 0;
  LENGTH |= 0;
  var FILE_IS_OPEN = 0, DATA = "";
  try
  {
    var FSO = new ActiveXObject("Scripting.FileSystemObject");
    var F = FSO.OpenTextFile(FILENAME, 1, 0, FMT);
    FILE_IS_OPEN = 1;
    if (LENGTH == 0)
      DATA = F.ReadAll();
    else if (LENGTH > 0)
    {
      if (START) F.Skip(START);
      DATA = F.Read(LENGTH);
    }
    else
    {
      while (START--) F.ReadLine();
      DATA = F.ReadLine();
    }
    F.Close();
    return DATA;
  }
  catch (e) {}
  if (FILE_IS_OPEN) try { F.Close(); } catch(e) {}
  return "";
}
//////////////////////////////////////////////////
//                                      v2021.4.20
// Creates and overwrites a file and with a string.
// Return 0 on success or 1 if an error occurred.
// FILE FORMAT:
//   0=ASCII (default)
//   1=UNICODE
// Usage: INTEGER = CreateFile(FILENAME, STRING, [FORMAT])
//
function CreateFile(FILENAME, STRING, FMT)
{
  if (TERMINATED) return 1;
  FMT |= 0;
  var BAKFILE = SetFileExtension(FILENAME, "BAK");
  DeleteFile(BAKFILE);
  RenameFile(FILENAME, BAKFILE);
  try
  {
    var FSO = new ActiveXObject("Scripting.FileSystemObject");
    F = FSO.CreateTextFile(FILENAME, 1, FMT);
    F.Write(STRING);
    F.Close();
    return 0;
  }
  catch (e) {}
  return 1;
}
//////////////////////////////////////////////////
//                                      v2021.4.30
// Deletes a file.
// Returns 0 on success.
// Returns 1 if something went wrong.
// Usage: INTEGER = DeleteFile(FILENAME, [FORCE])
//
function DeleteFile(FILENAME, FORCE)
{
  if (TERMINATED) return 1;
  FORCE |= 0;
  try
  {
    var FSO = new ActiveXObject("Scripting.FileSystemObject");
    var F = FSO.GetFile(FILENAME);
    F.Delete(FORCE);
    return 0;
  }
  catch (e) {}
  return 1;
}
//////////////////////////////////////////////////
//                                      v2021.4.30
// Renames a file.
// Returns 0 on success.
// Returns 1 if something went wrong.
// Usage: INTEGER = RenameFile(FULLNAME, NEWNAME)
//
function RenameFile(FULLNAME, NEWNAME)
{
  if (TERMINATED) return 1;
  try
  {
    var FSO = new ActiveXObject("Scripting.FileSystemObject");
    var F = FSO.GetFile(FULLNAME);
    F.Move(NEWNAME);
    return 0;
  }
  catch (e) {}
  return 1;
}
//////////////////////////////////////////////////
//                                      v2021.4.30
// This function changes the extension of a file name.
//
// Usage: STRING = SetFileExtension(FILENAME, NEW_EXTENSION)
//
function SetFileExtension(FILENAME, EXT)
{
  FILENAME = cutchr(FILENAME, "\\/", 0x51221);
  PATH = $a + $c;
  P = FILENAME.lastIndexOf(".");
  return PATH + ((P > 0) ? FILENAME.substr(0, P + 1) : FILENAME + ".") + EXT;
}
//////////////////////////////////////////////////
//                                      v2021.4.20
// Adds a string to the end of a file. Return 0 on
// success or 1 if something went wrong.
//
// Usage: INTEGER = AppendFile(FILENAME, STRING, [CREATE, [FORMAT]])
//
// CREATE is either 0 or 1 and it determines whether
// the file should be created if it doesn't already exist.
//   1=Create file if it doesn't exist (default)
//   0=Don't create it.
// Note: If the string to be written is empty or undefined
// or null and the file doesn't exist, the function will
// return with zero and the file will not be created.
// FILE FORMAT:
//   0=ASCII (default)
//  -1=UNICODE
//
function AppendFile(FILENAME, STRING, CREATE, FMT)
{
  if (TERMINATED) return 1;
  if (typeof(STRING) === "undefined" || STRING == null) return 0;
  if (typeof(STRING) != "string") STRING += "";
  if (STRING.length == 0) return 0;
  if (typeof(CREATE) === "undefined") CREATE = 1; else CREATE |= 0;
  FMT |= 0;
  try
  {
    var FSO = new ActiveXObject("Scripting.FileSystemObject");
    var F = FSO.OpenTextFile(FILENAME, 8, CREATE, FMT);
    F.Write(STRING);
    F.Close();
    return 0;
  }
  catch (e) {}
  return 1;
}
//////////////////////////////////////////////////
//                                      v2021.4.20
// Writes a string to a file and may overwrite
// part of the file and/or increase its size.
// Returns 0 on success or 1 if something went wrong.
// FILE FORMAT: 0=ASCII (default) -1=UNICODE
// Usage: INTEGER = WriteFile(FILENAME, STRING, [FILE_POINTER, [FORMAT]])
//
function WriteFile(FILENAME, STRING, FILE_PTR, FMT)
{
  if (TERMINATED) return 1;
  FMT |= 0;
  var FILE_IS_OPEN = 0;
  try
  {
    var FSO = new ActiveXObject("Scripting.FileSystemObject");
    var F = FSO.OpenTextFile(FILENAME, 4, 1, FMT);
    FILE_IS_OPEN = 1;
    if (FILE_PTR) F.Skip(FILE_PTR);
    F.Write(STRING);
    F.Close();
    return 0;
  }
  catch (e) {}
  if (FILE_IS_OPEN) try { F.Close(); } catch (e) {}
  return 1;
}
//////////////////////////////////////////////////
function SetFileSize(FILENAME, SIZE, PAD)
{
  if (TERMINATED) return 1;
  var FILE_IS_OPEN = 0;
  if (typeof(PAD) === "undefined" || PAD == null) PAD = "\0";
  else if (typeof(PAD) == "number") PAD = String.fromCharCode(PAD & 255);
  else { PAD += ""; PAD = (PAD.length < 1) ? "\0" : PAD.charAt(0); }
  SIZE |= 0;
  try
  {
    var FSO = new ActiveXObject("Scripting.FileSystemObject");
    var F = FSO.GetFile(FILENAME);
    if (F.Size == SIZE) return 0;
    if (F.Size > SIZE) { F.Size = SIZE; return 0; }
    var GROW = SIZE - F.Size();
    F = FSO.OpenTextFile(FILENAME, 8, 1, 0);
    FILE_IS_OPEN = 1;
    var FILL = (new Array(GROW + 1)).join(PAD);
    F.Write(FILL);
    F.Close();
    return 0;
  }
  catch (e) {}
  if (FILE_IS_OPEN) try { F.Close(); } catch (e) {}
  return 1;
}
//////////////////////////////////////////////////
//                                      v2021.4.11
// Creates and overwrites a file in binary mode.
// Returns 0 on success or 1 if an error occurred.
// Usage: INTEGER = CreateBinaryFile(FILENAME, STRING)
//
function CreateBinaryFile(FILENAME, STRING)
{
  var LEN = STRING.length;
  var ASCII_Format = 0, UNICODE_Format = 1, CreateNew = 1, DoNotCreateNew = 0;
  try
  {
    var FSO = new ActiveXObject("Scripting.FileSystemObject");
    var F = FSO.CreateTextFile(FILENAME, CreateNew, ASCII_Format);
    FILE.Write(ConvertFileString(STRING, 'WRITE'));
    FILE.Close();
    FILE = FSO.GetFile(FILENAME);     // Double-check what we have done.
    return (FILE.Size == LEN) ? 0 : 1
  } catch (e) {}
  return 1;
}
//////////////////////////////////////////////////
//                                      v2022.7.30
// Reads an entire binary file or part of a file and
// returns its contents as a string.
//
// The second argument (START) moves the file pointer
// before reading. The third argument (LENGTH) tells
// how many bytes to read. When LENGTH is zero,
// it reads the entire file.
//
// Usage: STRING = ReadBinaryFile(FILENAME, [START, [LENGTH]])
//
function ReadBinaryFile(FILENAME, START, LENGTH)
{
  START |= 0;
  LENGTH |= 0;
  var FSO, FILE, SIZE, DATA = '';
  try
  {
    FSO = new ActiveXObject('Scripting.FileSystemObject');
    if (!FSO.FileExists(FILENAME)) return '';
    SIZE = FSO.GetFile(FILENAME).Size;
    if (START < 0) START = 0;
    if (START >= SIZE) return '';
    if (LENGTH <= 0) LENGTH = SIZE;
    // Usage: FileObject = FSO.OpenTextFile(FILENAME, MODE, [CREATE, [FORMAT]])
    //     MODE : 1=Reading 2=Writing 8=Appending
    //   FORMAT : 0=Open as ASCII -1=Open as Unicode
    //   CREATE : 0=Don't create file 1=Create file if it doesn't exist yet
    FILE = FSO.OpenTextFile(FILENAME, 1, 0, 0);
    if (START) FILE.Skip(START);
    DATA = FILE.Read(LENGTH);      // Read all the data we need.
    FILE.Close();                  // Close file.
  } catch (e) {}
  return ConvertFileString(DATA, 'READ');
}
//////////////////////////////////////////////////
//                                      v2022.7.30
// The FSO.OpenTextFile() and FileObject.Read()
// functions are specifically designed to work with
// text files and will produce "garbage" when
// trying to read binary files.
//
// In reality, what happens is certain bytes are
// converted into 16-bit characters. And in order to
// get normal data that makes sense, we have to
// convert these 16-bit characters back to normal
// 8-bit ASCII character set.
// This conversion has to occur both after we read
// binary files and before we write them.
//
// The MODE argument must contain the words
// "READ" OR "WRITE":
//
// Trying to write certain binary characters to a
// file using the FileObject.Write() will throw an
// error unless the characters are first converted.
// So, the MODE argument should be "WRITE" when
// preparing a binary string for writing.
//
// After a string is read from a binary file, it needs
// to be converted back into 8-bit characters. The MODE
// argument needs contain the word "READ"
// when we want to do that.
//
// Usage: STRING = ConvertFileString(STRING, MODE)
//
function ConvertFileString(STR, MODE)
{
  MODE += '';
  var ASCII_Table = ".\x8c\x8a\x9a\x9f\x8e\x9e\x9c\x83\x88\x98\x96\x97\x91\x92\x82\x93\x94\x84\x86\x87\x95\x85\x89\x8b\x9b\x80\x99", i, c,
    Unicode_Table = "\u0152\u0160\u0161\u0178\u017D\u017E\u0153\u0192\u02C6\u02DC\u2013\u2014\u2018\u2019\u201A\u201C\u201D\u201E\u2020\u2021\u2022\u2026\u2030\u2039\u203A\u20AC\u2122";
  STR = STR.split('');  // Convert string to an array
  if (MODE.indexOf('READ') >= 0)
  {
    for (i = 0; i < STR.length; i++)
      if (STR[i].charCodeAt(0) > 255)
        STR[i] = ASCII_Table.charAt(Unicode_Table.indexOf(STR[i].charAt(0)) + 1);
  }
  else
    for (i = 0; i < STR.length; i++)
    {
      c = STR[i].charCodeAt(0);
      if (c > 127 && c < 160)
        if ((c = ASCII_Table.indexOf(STR[i].charAt(0))) > 0)
          STR[i] = Unicode_Table.charAt(c - 1);
    }
  return STR.join('');
}

//////////////////////////////////////////////////
//
//
//                MATH FUNCTIONS
//
//

function VAL(n) { return n * 1; }
function SGN(n) { return (n > 0) ? 1 : (n < 0) ? -1 : 0; }
function ABS(n) { return Math.abs(n); }
function INT(n) { return Math.floor(n); }
function LOG(n) { return Math.log(x); }
function EXP(n) { return Math.exp(x); }
function SQR(n) { return Math.sqrt(n); }
function ATN(n) { return Math.atan(x); }
function TAN(n) { return Math.tan(x); }
function SIN(n) { return Math.sin(x); }
function COS(n) { return Math.cos(x); }
function CINT(n) { return Math.round(n); }
function CLNG(n) { return Math.round(n); }
function CSNG(n) { return Math.round(n * 10000) / 10000; }
function CDBL(n) { return Math.round(n * 10000000) / 10000000; }

// These functions force a number to have 2, 3 or 4 digits:
function NN(n) { n = isNaN(n) ? 0 : Math.round(n); if (n < 1) return '00'; if (n > 98) return '99'; return (n > 9) ? n : '0' + n; }
function NNN(n) { n = isNaN(n) ? 0 : Math.round(n); if (n < 1) return '000'; if (n > 998) return '999'; if (n > 99) return n; return (n > 9 ? "0" : "00") + n; }
function NNNN(n) { n = isNaN(n) ? 0 : Math.round(n); if (n < 1) return '0000'; if (n > 9998) return '9999'; if (n > 999) return n; if (n > 99) return "0" + n; return (n > 9 ? "00" : "000") + n; }

// This function extracts the last whole number from string s and returns that number
function lastNumber(s) { var i, c, L = 0, p = -1; for (i = s.length - 1; i >= 0; i--) { c = s.charCodeAt(i); if (c > 47 && c < 58) { if (p < 0) p = i; L++; } else { if (L > 0) break; } } return s.substr(p - L + 1, L); }

// This function converts number N to a positive integer that is exactly X number of bytes long. It does that by either chopping off some of the first few digits or putting some zeros in the front.
function FIX(X, N) { if (isNaN(N) || N == null) N = "0"; else N = Math.floor(Math.abs(N)) + ""; if (N.length > X) return N.substr(N.length - X, X); while (N.length < X) N = "0" + N; return N; }
//function FIX(n) { n += "."; return n.substr(0, n.indexOf(".")) * 1; }

//////////////////////////////////////////////////
//                                      v2021.3.29
// This function returns a string representation
// of number(s) in decimal format with all digits
// written out as opposed to scientific notation.
// Usage: STRING = toDecimal(NUMBER_OR_STRING)
//
function toDecimal(N)
{
  N = TrimNumber(N);
  return TrimNumber(N.replace(/([\-\+]?)([0-9,]*)\.([0-9]*)[e|E]([\-\+]*[0-9]*)/g,
  function(match, Sign, Integer, Decimal, Exp)
  {
    var Number = (Integer + "." + Decimal).replace(/[^0-9.]/g, "");
    return Sign + MovePattern(Number, ".", Exp * 1, "0");
  }));
}
//////////////////////////////////////////////////
//                                      v2019.9.27
// This function adds two large positive integers.
//
// Both numbers must be in base 10. The numbers may
// not contain any character other than digits (0-9).
// Two additional arguments may be provided to shift
// the input numbers left or right before being added.
// A negative shift moves digits to the right
// discaring the least significant digits, while
// a positive shift moves digits to the left
// (it's the same as multiplying by 10, 100, or 1000).
// Usage: STRING = ADD(STRING, STRING, [INTEGER, [INTEGER]])
// Example: ADD('1111', '222', -1, 2) --> '22311'
//
function ADD($A, $B, $AL, $BL)
{
  $A += "";
  $B += "";
  if (typeof($AL) === "undefined") $AL = 0; $AL += $A.length;
  if (typeof($BL) === "undefined") $BL = 0; $BL += $B.length;
  var $i = ($AL > $BL) ? $AL : $BL;
  var $CARRY = 0;
  var $SUM = '0';
  var $X;
  while ($i-- > 0)
  {
    $X  =  $AL ? $A.charCodeAt(--$AL) : 48;
    $X += ($BL ? $B.charCodeAt(--$BL) : 48) + $CARRY;
    $CARRY = $X > 105 ? 1 : 0;
    $SUM = vec($SUM, $i, $X - ($CARRY ? 58 : 48));
  }
  return ($CARRY ? '1' : '') + $SUM;
}
// SHORT VERSION:
// function ADD($A,$B,$AL,$BL) {$A+="";$B+="";if(typeof($AL)==="undefined")$AL=0;$AL+=$A.length;if(typeof($BL)==="undefined")$BL=0;$BL+=$B.length;var $i=($AL>$BL)?$AL:$BL;var $CARRY=0;var $SUM='0';var $X;while($i-- >0){$X=$AL?$A.charCodeAt(--$AL):48;$X+=($BL?$B.charCodeAt(--$BL):48)+$CARRY;$CARRY=$X>105?1:0;$SUM=vec($SUM,$i,$X-($CARRY?58:48));}return($CARRY?'1':'')+$SUM;}
//////////////////////////////////////////////////
//                                       v2019.9.27
// This function returns the difference between two
// large positive integers in base 10. These
// "large integers" are strings that hold digits
// only (0-9) and nothing else. No spaces, tabs,
// line breaks, or letters allowed! The return value
// of this function will always be a string
// containing a positive integer.
// Tested with TinyPerl 5.8.0 and Perl 5.004 for DOS.
// Usage: STRING = DIFF(STRING, STRING)
//
function DIFF($A, $B)
{
  $A += "";
  $B += "";
  var $T;
  var $AL = $A.length;
  var $BL = $B.length;
  var $DIFF = 0;
  var $i = 0;

// Swap A and B if B is greater

  if ($AL == $BL)
  {
    if ($A == $B) return '0';
    while ($DIFF == 0)		// Check if B is greater
    {
      $DIFF = $B.charCodeAt($i) - $A.charCodeAt($i++);
    }
  }
  if ($BL > $AL || $DIFF > 0)
  {
    $T = $A;
    $A = $B;
    $B = $T;    // Swap A and B
  }

// At this point, we know that $A > $B

  var $AX;		// Current digit from integer A
  var $BX = 0;		// Current digit from integer B + carry
  var $START = 0;	// Start trim
  $DIFF = '';		// This will be our return value
  $AL = $A.length;
  $BL = $B.length;
  var $MAXLEN = ($AL > $BL) ? $AL : $BL;
  $i = $MAXLEN;
  while ($i--)					// Loop until max($AL, $BL)
  {
    $AX  = $AL ? $A.charCodeAt(--$AL) : 48;
    $BX += $BL ? $B.charCodeAt(--$BL) : 48;	// Get new digit + Add carry
    $AX -= $BX;					// Subtract
    $BX = $AX < 0 ? 1 : 0;			// Carry 1 or 0
    $AX += $BX ? 58 : 48;			// Convert digit to ASCII code '0' - '9'
    $DIFF = vec($DIFF, $i, $AX);			// Write digit
    if ($AX != 48) $START = $i;			// Keep track of last non-zero digit
  }
  return $DIFF.slice($START);			// Remove initial zeros
}
// SHORT VERSION:
// function DIFF($A,$B) {$A+="";$B+="";var $T;var $AL=$A.length;var $BL=$B.length;var $DIFF=0;var $i=0;if($AL==$BL){if($A==$B)return'0';while($DIFF==0){$DIFF=$B.charCodeAt($i)-$A.charCodeAt($i++);}}if($BL>$AL||$DIFF>0){$T=$A;$A=$B;$B=$T;}var $AX;var $BX=0;var $START=0;$DIFF='';$AL=$A.length;$BL=$B.length;var $MAXLEN=($AL>$BL)?$AL:$BL;$i=$MAXLEN;while($i--){$AX=$AL?$A.charCodeAt(--$AL):48;$BX+=$BL?$B.charCodeAt(--$BL):48;$AX-=$BX;$BX=$AX<0?1:0;$AX+=$BX?58:48;$DIFF=vec($DIFF,$i,$AX);if($AX!=48)$START=$i;}return $DIFF.slice($START);}
//////////////////////////////////////////////////
//                                      v2020.06.30
// Compares two large positive integers.
// The integers can be binary, octal,
// decimal, or hexadecimal.
//
// NOTE: Both numbers must be in the same base.
//
// Returns: 0 if they are equal
//          1 if the first one is greater
//          2 if the second one is greater
//
// Special cases:
// * When comparing an undefined value against
//   an empty string or zero, they will be equal.
// * Minus signs are ignored, therefore
//   -5 and +5 are treated as equal.
//
// Usage: INTEGER = CMP(STRING, STRING)
//
function CMP($A, $B)
{
  $A2 = $A.length;
  $B2 = $B.length;
  var $A1 = 0, $B1 = 0, $CA = 48, $CB = 48, $DIFF = 0;

  // SHOW WHAT'S HAPPENING:
  //print "\n\nString1=|$A|\nString2=|$B|  RET=";

  // Find the first significant digit or starting pointer for each string.
  // We will call this A1 and B1. In case the string starts with zeros,
  // spaces, tabs, new line characters, - and + signs, or other special
  // characters, we skip through those. We ignore them.
  while ($A1 < $A2 && $A.charCodeAt($A1) < 49) { $A1++; }
  while ($B1 < $B2 && $B.charCodeAt($B1) < 49) { $B1++; }

  // Find last significant digit or ending pointer for each string.
  // We will call this A2 and B2.
  while ($A2 > $A1 && $A.charCodeAt(--$A2) < 48) {} $A2++;
  while ($B2 > $B1 && $B.charCodeAt(--$B2) < 48) {} $B2++;

  // Calculate the number of digits in each number.
  var $AL = $A2 - $A1;
  var $BL = $B2 - $B1;

  // Are both numbers the same length?
  if ($AL == $BL)
  {
    // Compare from left to right, incrementing
    // pointers A1 and B1 as we walk through all the digits.
    while ($A1 < $A2)
    {
      $CA = $A.charCodeAt($A1++);    // Get digit from string A
      $CB = $B.charCodeAt($B1++);    // Get digit from string B
      $DIFF = $CA - $CB;
      if ($DIFF) { return $DIFF < 0 ? 2 : 1; }
    }
    return 0;
  }
  if ($AL > $BL) return 1;
  if ($AL < $BL) return 2;
  return 0;
}
// SHORT VERSION:
// function CMP($A,$B) {$A2=$A.length;$B2=$B.length;var $A1=0,$B1=0,$CA=48,$CB=48,$DIFF=0;while($A1<$A2&&$A.charCodeAt($A1)<49){$A1++;}while($B1<$B2&&$B.charCodeAt($B1)<49){$B1++;}while($A2>$A1&&$A.charCodeAt(--$A2)<48){}$A2++;while($B2>$B1&&$B.charCodeAt(--$B2)<48){}$B2++;var $AL=$A2-$A1;var $BL=$B2-$B1;if($AL==$BL){while($A1<$A2){$CA=$A.charCodeAt($A1++);$CB=$B.charCodeAt($B1++);$DIFF=$CA-$CB;if($DIFF){return $DIFF<0?2:1;}}return 0;}if($AL>$BL)return 1;if($AL<$BL)return 2;return 0;}
//////////////////////////////////////////////////
//                                       v2022.8.3
// Converts a number to Roman numerals (1-3999).
// Usage: STRING = Romanize(INTEGER)
//
function Romanize(N)
{
  N = (N | 0) + '';
  var c, i = N.length, PTR, OUTPUT = [], VALUES = [
    "","I","II","III","IV","V","VI","VII","VIII","IX",
    "","X","XX","XXX","XL","L","LX","LXX","LXXX","XC",
    "","C","CC","CCC","CD","D","DC","DCC","DCCC","CM",
    "","M","MM","MMM"];
  while (i--)
  {
    c = N.charCodeAt(i);
    if (c < 48 || c > 57) continue;
    PTR = (c - 48) + (OUTPUT.length * 10);
    if (PTR >= VALUES.length) break;
    OUTPUT.push(VALUES[PTR]);
  }
  return OUTPUT.reverse().join('');
}
//////////////////////////////////////////////////
//                                       v2022.8.3
// Adds the suffix 'st' 'nd' 'rd' or 'th' to an
// integer to make it an ordinal.
// Usage: STRING = Nth(STRING)
//
function Nth(N)
{
  N = (N | 0) + '';
  var c = N.charAt(N.length - 1);
  if (c == 1) return N + 'st';
  if (c == 2) return N + 'nd';
  if (c == 3) return N + 'rd';
  return N + 'th';
}
//////////////////////////////////////////////////
//                                      v2021.2.10
// Takes any value and returns an integer.
// Usage: INTEGER = toInt(STRING, [MAXVALUE])
//
function toInt(X, MAXVALUE)
{
  X += "";
  X = X.replace(/[^[0-9]/g, "");
  if (X.length == 0) return 0;
  X = X.substr(0, 15) * 1;
  if (typeof(MAXVALUE) != "undefined")
    if (X > MAXVALUE)
      return MAXVALUE;
  return X;
}
//////////////////////////////////////////////////
//
//
//        CONVERTER / ENCODER FUNCTIONS
//
//

function OCT$(n) { return n.toString(8); }
function HEX$(n) { return n.toString(16); }

//////////////////////////////////////////////////
//                                       v2021.2.4
// This function encodes a binary string to a safe-text
// format that can be used in an URL argument list or
// shell argument or in HTML or enclosed within
// single or double quotes in a JS string.
//
// According to a study at Cornell University, this is the
// English alphabet starting with the most frequently used
// letter to the least frequently used letter:
//     ETAOINSRHDLUCMFYWGPBVKXQJZ
//
// Usage: STRING = Str2Txt(STRING)
//

function Str2Txt(S) { var i, c = -1, P, prev_char, prev_esc, output_char, ESC = 0, REPEAT = 0, OUT = []; for (i = 0; i < S.length; i++) { prev_char = c; c = S.charCodeAt(i); if (c == prev_char) { if (++REPEAT < 2) OUT.push(output_char); else { OUT.length--; OUT.push(TX.charAt(ESC + 697)); REPEAT = 0; } } else { REPEAT = 0; P = TX.charCodeAt(c + 256); if (P < 0) ESC = P = 0; else { prev_esc = ESC; ESC = (P / 57) & 7; P -= ESC * 57; if (ESC != prev_esc) OUT.push(TX.charAt(ESC + 697)); output_char = TX.charAt(P + 640); OUT.push(output_char); } } } return OUT.join(""); }
function Txt2Str(S) { var output_char = '', prev_esc, i, c, P, ESC = 0, OUT = []; for (i = 0; i < S.length; i++) { c = S.charCodeAt(i); P = TX.charCodeAt(c + 512); if (P < 0) { prev_esc = ESC; ESC = 0; c = 0; } if (P >= 57) { prev_esc = ESC; ESC = P - 57; if (prev_esc == ESC) { OUT.push(output_char); OUT.push(output_char); } } else { P = ESC * 57 + P; output_char = (P < 256) ? TX.charAt(P) : " "; OUT.push(output_char); } } return OUT.join(""); }

// Converts an integer to Base64 character(s).
function Int2B64(N) { var B = []; do { B.push(B64.charAt(N & 63)); N >>>= 6; } while (N > 0); return B.reverse().join(""); }

// This function converts a 2-byte string (big endian) to an unsigned int.
function StrInt(S) {return S.charCodeAt(0)<<8|S.charCodeAt(1);}

// This function converts an integer to a 2-byte string (big endian format).
function IntStr(N) {return String.fromCharCode(N>>>8&255)+String.fromCharCode(N&255);}

// This function converts a 4-byte string (big endian) to a long int.
function StrLong(S) {return S.charCodeAt(0)<<24|S.charCodeAt(1)<<16|S.charCodeAt(2)<<8|S.charCodeAt(3);}

// This function converts a 32-bit long to a 4-byte string (big endian format).
function LongStr(N) {return String.fromCharCode(N>>>24&255)+String.fromCharCode(N>>>16&255)+String.fromCharCode(N>>>8&255)+String.fromCharCode(N&255);}

// This function converts a positive integer N to any base using digits listed in string S.
function Num2Set(N, S) {var Z=S.charAt(0);if(typeof(N)==="undefined")return Z;if(isNaN(N))return Z;if(N<1)return Z;N=Math.floor(N);if(N==1)return S.charAt(1);if(N>9007199254740991)N=9007199254740992;var L=S.length;var $=[];while(N>1){C=N%L;$.push(S.charAt(C));N=Math.floor((N-C)/L);}if(N)$.push(S.charAt(N));return $.reverse().join("");}

// This function converts string N from any base to a positive integer. Digit set must be provided in string S.
function Set2Num(N, S) {var D,PWR=1,X=0,i=N.length,L=S.length;while(i--){D=S.indexOf(N.charAt(i));if(D<0)return X;else{if(D)X+=D*PWR;PWR*=L;}}return X;}

// NOTE: The Array2Double() and Double2Array() functions
// will work with Chrome 7, Firefox 4, MSIE10, Edge,
// Safari 5.1, Vivaldi 1, QupZilla 1.8.6, KMeleon 7.5.
// They won't work in Opera 7.54, IE6, and KMeleon 1.5.4.
// To use these functions in older web browsers, try
// using _Float2Array() and _Array2Float() instead.

// This function converts an array of 8 integers between 0-255 to a native JavaScript number (IEEE-754 double format). The input array must have at least 8 elements!!!
function Array2Double(A) { var F = new ArrayBuffer(8); var B = new Uint8Array(F); var N = new Float64Array(F); for (var i = 0; i < 8; i++) B[i] = A[i]; return N[0]; }

// This function converts a JavaScript number to an array of 8 integers between 0-255.
function Double2Array(V) { var F = new ArrayBuffer(8); var B = new Uint8Array(F); var N = new Float64Array(F); N[0] = V; var i, A = []; for (i = 0; i < 8; i++) A[i] = B[i]; return A; }

// This function converts an array of 8 numbers (0-255) to a limited JavaScript float. Note: This function will not work with all double-precision numbers. It will only work when there's no exponent. Use _SmallFloat() to make sure it will work.
function _Array2Float(A) { var N = 0, M = 1, i = 7; while (i) { N += A[i--] * M; M *= 256; } if ((M = A[0] & 127)) { N = "0000000000" + N; N = N.substr(0, N.length - M) + "." + N.substr(N.length - M); } return N * (A[0] & 128 ? -1 : 1); }

// This function converts a JavaScript float number to an array of 8 numbers (0-255). Note: This function will not work with all double-precision numbers. It will only work when there's no exponent. Use _SmallFloat() to make sure it will work.
function _Float2Array(V) { var i = 7, A = [0]; if (V < 0) { A[0] = 128; V = -V; } V = (V+".").split("."); A[0] |= V.length > 2 ? V[1].length : 0; V = V.join(""); while (i) { A[i--] = V & 255; V = Math.floor(V / 256); } return A; }

// This function reduces the size of a double-precision JavaScript number to a safe float that only has 15 significant digits and no exponent.
function _SmallFloat(N) { var S = (N < 0) ? -1 : 1; N += ""; if (S < 0) N = N.slice(1); N = N.split("."); var L = N[0].length; if (L > 15) N[0] = N[0].substr(0, 15); else if (L + N[1].length > 15) N[1] = N[1].substr(0, 15 - L); return S * N.join(".").toUpperCase().split("E")[0]; }

// This function returns 1 if S is a valid hex number.
function isHex(S) { return isFromCharSet(S, "0123456789abcdefABCDEF"); }

// This function returns 1 if S contains digits only.
function isDec(S) { return isFromCharSet(S, "0123456789"); }

// This function returns 1 if string S is a valid binary number.
function isBin(S) { return isFromCharSet(S, "01"); }

// This function returns a hex string.
// It filters string S and only allows hex digits to pass through.
function ForceHex(S) { return tr(S, "0123456789abcdefABCDEF").toUpperCase(); }

// This function filters string S and only allows digits to pass through.
function ForceDec(S) { return tr(S, "0123456789"); }

// This function returns a binary number.
// It filters string S and only allows ones and zeros to pass through.
function ForceBin(S) { return tr(S, "01"); }

// Converts a decimal number to hexadecimal format. Limit: 0 to 255
function toHex(D) { D = Math.round(D); if (isNaN(D) || D < 1) return "00"; if (D > 254) return "ff"; return (D < 16 ? "0" : "") + D.toString(16); }

// Converts string S to a series of hex numbers. Faster than toString(16)
function Str2Hex(S) { var c, i, x = []; for(i = 0; i < S.length; i++) { c = S.charCodeAt(i) & 255; x.push(HEX[c >> 4] + HEX[c & 15]); } return x.join(''); }

// Converts a hex string to binary string. No Limit!
function Hex2Bin(X) { var i, c, B = []; for (i = 0; i < X.length; i++) { c = X.charCodeAt(i); if (c < 48 || c > 102) continue; c |= 32; if (c > 96) c -= 87; else c -= 48; B.push(BIN4[c]); } return B.join(""); }

// Converts a series of hexadecimal numbers to a raw string.
function Hex2Str(X) { var i, $ = []; X += ""; for (i = 0; i < X.length; i += 2) $.push(String.fromCharCode(parseInt(X.substr(i, 2), 16))); return $.join(""); }

// Converts a hexadecimal string to a number.
function Hex2Int(H) { if (H.length < 8) return parseInt(H, 16); H = H.toUpperCase(); var C, D = 0, S = 1, i = H.length; while (i--) { C = "0123456789ABCDEF".indexOf(H.charAt(i)); if (C < 0) return D; else { if (C) D += C * S; S *= 16; } } return D; }
//function Hex2Int(X) { return parseInt(X, 16); }

// Converts a large positive integer to a 14-byte hex string. Valid range: 0 to 9,007,199,254,740,992
function Int2Hex(N) { if (typeof(N)==="undefined") return "0"; if (isNaN(N)) return "0"; if (N < 1) return "0"; N = Math.floor(N); if (N <= 4294967295) return N.toString(16); if (N > 9007199254740991) return "20000000000000"; var LOW = (N & 0x0FFFFFFF).toString(16); if (LOW.length < 7) LOW = "0000000".slice(LOW.length) + LOW; return (Math.floor(N/268435456) & 0x0FFFFFFF).toString(16) + "" + LOW; }

// Encodes a binary string to Base64 string
function EncodeB64(S) { var i, j, k = -4, SHIFT = 6, $ = []; for (i = j = 0; i < S.length; i++, j++) { if (SHIFT > 5) { SHIFT = 0; k += 4; $[k] = 0; j++; } SHIFT += 2; $[j] = S.charCodeAt(i); $[k] += ($[j] & 0xC0) >> SHIFT; $[j] = $[j] & 63; } while (--j >= 0) $[j] = String.fromCharCode($[j] + 63); return $.join(""); }

// Decodes a Base64 string to binary string
function DecodeB64(S) { var i, c, H, $ = []; for (i = 0; i < S.length; i++) { c = S.charCodeAt(i) - 63; c = (c < 0) ? 0 : c & 63; if (i % 4) { H <<= 2; $.push(String.fromCharCode(c + (H & 0xC0))); } else H = c; } return $.join(""); }

// This function converts a 32-bit signed integer to 8-digit hex format.
function toHexLong(N) { N |= 0; var i, X = ""; for (i = 0; i < 32; i += 4) X = "0123456789ABCDEF".charAt((N >> i) & 15) + X; return X; }

// Converts a binary string to a number. Limit: 0xFFFFFFFF
function Bin2Int(B) { var i = B.length, V = 0, N = 1; while (i-- > 0) { V += ((B.charAt(i) == "1") ? N : 0); if (N >= 0x80000000) break; N += N; } return V; }

// Converts a binary string to hex string. No limit.
// This function arranges binary digits into groups of eight
// before converting them. If the last group doesn't have
// eight digits, zeros are added to the end.
function Bin2Hex(B) { var c, i = 0, V = 0, N = 8, X = []; while (i < B.length) { c = B.charCodeAt(i++) & 255; if (c < 48 || c > 49) continue; if (c == 49) V += N; if (N > 1) N >>= 1; else { X.push(HEX[V]); V = 0; N = 8; } } if (N < 8) X.push(HEX[V]); if (X.length & 1) X.push("0"); return X.join(""); }

function Int2Bin(LONG, LENGTH) { var OUTPUT = [], i = (typeof(LENGTH) === "undefined") ? 32 : LENGTH, MASK = [1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000, 0x10000, 0x20000, 0x40000, 0x80000, 0x100000, 0x200000, 0x400000, 0x800000, 0x1000000, 0x2000000, 0x4000000, 0x8000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, 4294967296, 8589934592, 17179869184, 34359738368, 68719476736, 137438953472, 274877906944, 549755813888, 1099511627776, 2199023255552, 4398046511104, 8796093022208, 17592186044416, 35184372088832, 70368744177664, 140737488355328, 281474976710656, 562949953421312]; while (i--) OUTPUT.push((LONG & MASK[i]) ? "1" : "0"); return OUTPUT.join(""); }

//////////////////////////////////////////////////
//                                      v2019.9.27
// This function converts a big integer from base 10
// to base 2. Both the input and the output are strings.
//
// Usage: STRING = BigInt2Bin(STRING)
//
function BigInt2Bin($N)
{
  // Calculate powers of two, as many as we need...

  var $X;		// Power of two
  var $i = 0;		// Ptr to current power of two
  var $BIN = '';	// This will be our return value
  var $PWR = ['1'];	// Powers of two

  while ($i++ < 3000)	// Max digits = 3000
  {
    $X = $PWR[$i - 1];
    $X = $PWR[$i] = ADD($X, $X);
    if (CMP($N, $X) != 1) break;   // $N <= $PWR ?
  }

  // Convert decimal number to binary
  // starting with the most significant digit

  while ($i--)
  {
    if ( CMP($N, $PWR[$i]) == 2)
    {
      $BIN += '0';
    }
    else
    {
      $BIN += '1';
      $N = DIFF($N, $PWR[$i]);
    }
  }
  return $BIN;
}
//////////////////////////////////////////////////
//                            String | v2022.11.13
// This function converts a string to text using the
// standard Base64 encoding algorithm.
//
// The first argument should be a string.
// The second argument MAY contain a custom 65-byte
// character set. The 65th byte will be used for padding.
//
// The second argument MAY also be 0 or 1:
//    0 = Use standard Base64 encoding which ends with +/  (default)
//    1 = Use web-safe Base64 encoding which ends with -_
//
// Usage: STRING = EncodeBase64(STRING, [CHARSET])
//
function EncodeBase64(S, BASE64)
{
  if (typeof(S) == "undefined") return "";
  S += "";

  // Prepare character set.
  var TYPE = 2;
  var PADDING = "=";
  if (typeof(BASE64) == "undefined")
    BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
  else if (BASE64.length >= 65)
    { TYPE = 0; PADDING = BASE64.substr(64, 1); }
  else if (typeof(BASE64) == "number")
    TYPE = BASE64;
  if (TYPE)
    BASE64 += (TYPE == 1) ? "-_" : "+/";

  // Get string reference.
  var i = 0, p = 0, A, B, C, DIFF, OUTPUT = [];
  while (i < S.length)
  {
    // Read 3 bytes.
    A = S.charCodeAt(i++);
    B = S.charCodeAt(i++);
    C = S.charCodeAt(i++);
    // Write 4 bytes.
    OUTPUT[p++] = BASE64.charAt(A >> 2);
    OUTPUT[p++] = BASE64.charAt(((A & 3) << 4) | (B >> 4));
    OUTPUT[p++] = BASE64.charAt(((B & 15) << 2) | ((C >> 6) & 3));
    OUTPUT[p++] = BASE64.charAt(C & 63);
  }
  // Replace last couple of bytes with padding.
  DIFF = i - S.length;
  while (DIFF--)
    OUTPUT[p++] = PADDING;
  return OUTPUT.join("");
}
//////////////////////////////////////////////////
//                             String | v2022.11.4
// This function converts some Base64 text to a string
// using the standard Base64 converter algorithm.
//
// The first argument should be a string.
// The second argument MAY contain a custom 64-byte
// character set.
//
// Usage: STRING = DecodeBase64(STRING, [CHARSET])
//
function DecodeBase64(S, BASE64)
{
  var i = 0, p = 0, A, B, C, D, DIFF, OUTPUT = [], LUT = [];

  // Create lookup table.
  for (i = 0; i < 256; i++)
    LUT[i] = 0;
  if (typeof(BASE64) == "undefined" || BASE64.length < 64)
  {
    BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    LUT[45] = 62;  // Add these two: -_
    LUT[95] = 63;
  }
  for (i = 0; i < BASE64.length; i++)
    LUT[BASE64.charCodeAt(i)] = i;

  // Decode Base64 string.
  i = 0;
  while (i < S.length)
  {
    // Read 4 bytes.
    A = LUT[S.charCodeAt(i++)];
    B = LUT[S.charCodeAt(i++)];
    C = LUT[S.charCodeAt(i++)];
    D = LUT[S.charCodeAt(i++)];
    // Write 3 bytes.
    OUTPUT[p++] = String.fromCharCode(((A << 2) | ((B >> 4) & 3)) & 255);
    OUTPUT[p++] = String.fromCharCode(((B << 4) | (C >> 2)) & 255);
    OUTPUT[p++] = String.fromCharCode((((C & 3) << 6) | D) & 255);
  }
  DIFF = !C + !D;
  OUTPUT.length -= DIFF;
  return OUTPUT.join("");
}

//////////////////////////////////////////////////
//                                      v2021.2.11
// Returns a 4-digit hexadecimal number.
// Usage: STRING = toHexWord(INTEGER)
//
function toHexWord(N)
{
  if (N < 0.5) return "0000";
  if (N >= 65534.5) return "FFFF";
  N = (N & 65535 | 65536).toString(16);
  return N.slice(1).toUpperCase();
}
//////////////////////////////////////////////////
//                                     v2019.12.27
// Converts a long integer to a binary string.
// A number may be provided as a second argument
// to get a custom-length binary string of N digits.
// Usage: STRING = toBin(INTEGER, [LENGTH])
//
function toBin(LONG)
{
  var OUTPUT = [],
  i = (arguments.length > 1) ? arguments[1] : 32,
  MASK = [
  1, 2, 4, 8, 0x10, 0x20,
  0x40, 0x80, 0x100, 0x200,
  0x400, 0x800, 0x1000, 0x2000,
  0x4000, 0x8000, 0x10000, 0x20000, 
  0x40000, 0x80000, 0x100000, 0x200000,
  0x400000, 0x800000, 0x1000000, 0x2000000,
  0x4000000, 0x8000000, 0x10000000, 0x20000000,
  0x40000000, 0x80000000];
  while (i--)
    OUTPUT.push((LONG & MASK[i]) ? "1" : "0");
  return OUTPUT.join("");
}
// SHORT VERSION:
// Converts a 32-bit integer to a custom-length string of 1s and 0s.
// function toBin(LONG) { var OUTPUT = [], i = (arguments.length > 1) ? arguments[1] : 32, MASK = [1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000, 0x10000, 0x20000, 0x40000, 0x80000, 0x100000, 0x200000, 0x400000, 0x800000, 0x1000000, 0x2000000, 0x4000000, 0x8000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000]; while (i--) OUTPUT.push((LONG & MASK[i]) ? "1" : "0"); return OUTPUT.join(""); }
//
//////////////////////////////////////////////////
//                                     v2019.12.27
// Converts a series of binary numbers to a raw string.
// Usage: STRING = Bin2Str(STRING)
//
function Bin2Str(B)
{
  B = Group(B, 8, ".0");
  for (var i = 0; i < B.length; i++)
    B[i] = String.fromCharCode(parseInt(B[i], 2));
  return B.join("");
}
//////////////////////////////////////////////////
//                                     v2019.12.27
// Converts a raw string to series of binary numbers.
// Usage: STRING = Str2Bin(STRING)
//
function Str2Bin(S)
{
  var i = 0, C, OUTPUT = [];
  for (; i < S.length; i++)
  {
    C = S.charCodeAt(i).toString(2);
    OUTPUT[i] = "00000000".slice(C.length) + C;
  }
  return OUTPUT.join("");
}
// SHORT VERSION:
//
// Converts a raw string to a series of binary numbers.
// function Str2Bin(S) { var i = 0, C, OUTPUT = []; for (; i < S.length; i++) { C = S.charCodeAt(i).toString(2); OUTPUT[i] = "00000000".slice(C.length) + C; } return OUTPUT.join(""); }
//
//////////////////////////////////////////////////
//                                       v2021.1.7
// This function compiles a list of positive
// integers and returns a string of 1s and 0s.
// VALUE is the integer to be stored, while
// LENGTH specifies the number of bits
// to use to represent the integer.
// Usage: STRING = PushBits(LENGTH, INT, [LENGTH, INT...])
//
function PushBits(LENGTH, INT)
{
  var i, OUTPUT = [];
  for (i = 0; i < arguments.length; i++)
  {
    LENGTH = arguments[i++];
    INT = arguments[i];
    OUTPUT.push(toBin(INT, LENGTH));
  }
  return OUTPUT.join("");
}
// SHORT VERSION:
// Converts a list of numbers into a string of 1s and 0s.
// function PushBits(LENGTH, INT) { var i, OUTPUT = []; for (i = 0; i < arguments.length; i++) { LENGTH = arguments[i++]; INT = arguments[i]; OUTPUT.push(toBin(INT, LENGTH)); } return OUTPUT.join(""); }
//

//////////////////////////////////////////////////
//
//
//            DATE & TIME FUNCTIONS
//
//

function TimeStamp() { var D = new Date(); return D.getFullYear() + "-" + FIX(2, D.getMonth() * 1 + 1) + "-" + FIX(2, D.getDate()) + " " + FIX(2, D.getHours()) + ":" + FIX(2, D.getMinutes()) + ":" + FIX(2, D.getSeconds()); }

// Returns the number of seconds since Jan 2019 in a 4-byte binary string.
function MakeTimeStamp() {return LongStr(Math.floor(((new Date()).getTime()-1546300800000)/2000));}

// Converts 4-byte TimeStamp string to milliseconds since Jan 1970.
function ReadTimeStamp(S) {return StrLong(S)*2000+1546300800000;}

// This function is called by CreateTimeAgo()
function UpdateTimeAgo(OBJECT_ID, T) { document.getElementById(OBJECT_ID).innerText = TimeAgo(T); }

// This function creates a text label that gets updated every 15 seconds showing how long ago it was created.
function CreateTimeAgo(OBJECT_ID, T) { var DIFF = Math.abs(now() - T); UpdateTimeAgo(OBJECT_ID, T); if (DIFF < 86400000) setInterval("UpdateTimeAgo('" + OBJECT_ID + "', " + T + ");", 15100); }

// Returns the number of seconds since midnight.
function TIMER() { var T = new Date(); return T.getHours() * 3600 + T.getMinutes() * 60 + T.getSeconds(); }

// LocalTime1([ms]) >>>  YYYY-MM-DD HH:MM:SS
function LocalTime1(ms)
{
  var D = (typeof(ms) == 'undefined') ? new Date() : new Date(isNaN(ms) ? 0 : Math.round(ms));
  return D.getFullYear() + '-' + NN(D.getMonth() + 1) + '-' + NN(D.getDate()) + ' ' + NN(D.getHours()) + ':' + NN(D.getMinutes()) + ':' + NN(D.getSeconds());
}

// LocalTime2([ms]) >>>  YYYYMMDDHHMMSS
function LocalTime2(ms)
{
  var D = (typeof(ms) == 'undefined') ? new Date() : new Date(isNaN(ms) ? 0 : Math.round(ms));
  return [D.getFullYear(), NN(D.getMonth() + 1), NN(D.getDate()), NN(D.getHours()), NN(D.getMinutes()), NN(D.getSeconds())].join('');
}

// LocalTime3([ms]) >>>  MM-DD-YYYY HH:MM:SSam (12hr format)
function LocalTime3(ms)
{
  var D = (typeof(ms) == 'undefined') ? new Date() : new Date(isNaN(ms) ? 0 : Math.round(ms));
  var H = D.getHours();
  var A = H > 11 ? 'p' : 'a';
  if (H > 12) H -= 12; else if (H == 0) H = 12;
  return NN(D.getMonth()+1) + '-' + NN(D.getDate()) + '-' + D.getFullYear() + ' ' + NN(H) + ':' + NN(D.getMinutes()) + ':' + NN(D.getSeconds()) + A;
}

// LocalTime4([ms]) >>> 40-digit binary string
function LocalTime4(ms)
{
  var D = (typeof(ms) == 'undefined') ? new Date() : new Date(isNaN(ms) ? 0 : Math.round(ms));
  return [toBin(D.getFullYear(), 14), toBin(D.getMonth() + 1, 4), toBin(D.getMonth() + 1, 4), toBin(D.getDate(), 5), toBin(D.getHours(), 5), toBin(D.getMinutes(), 6), toBin(D.getSeconds(), 6)].join('');
}

// LocalTime5([ms]) >>> 5-byte binary string
function LocalTime5(ms) { return Bin2Str(LocalTime4(ms)); }

// LocalTime6([ms]) >>> 10-digit hexadecimal string
function LocalTime6(ms)
{
  var D = (typeof(ms) == 'undefined') ? new Date() : new Date(isNaN(ms) ? 0 : Math.round(ms));
  return Bin2Hex(LocalTime4(ms));
}

// LocalTime7([ms]) >>> Mmm DD, YYYY  HH:MM:SS
function LocalTime7(ms)
{
  var D = (typeof(ms) == 'undefined') ? new Date() : new Date(isNaN(ms) ? 0 : Math.round(ms));
  return 'JanFebMarAprMayJunJulAugSepOctNovDec'.substr(D.getMonth() * 3, 3) + ' ' + NN(D.getDate()) + ', ' + D.getFullYear() + ' ' + NN(D.getHours()) + ':' + NN(D.getMinutes()) + ':' + NN(D.getSeconds());
}

// LocalTime8([ms]) >>> Www Mmm D YYYY H:MMa
function LocalTime8(ms)
{
  var D = (typeof(ms) == 'undefined') ? new Date() : new Date(isNaN(ms) ? 0 : Math.round(ms));
  var H = D.getHours();
  var A = H > 11 ? 'p' : 'a';
  if (H > 12) H -= 12; else if (H == 0) H = 12;
  return 'SunMonTueWedThuFriSat'.substr(D.getDay() * 3, 3) + ' ' + 'JanFebMarAprMayJunJulAugSepOctNovDec'.substr(D.getMonth() * 3, 3) + ' ' + D.getDate() + ', ' + D.getFullYear() + ' ' + H + ':' + NN(D.getMinutes()) + A;
}

// LocalTime9([ms]) >>> **Seconds**, YYYY-MM-DD HH:MM:SSam
function LocalTime9(ms)
{
  var D = (typeof(ms) == 'undefined') ? new Date() : new Date(isNaN(ms) ? 0 : Math.round(ms));
  var H = D.getHours();
  var A = H > 11 ? 'pm' : 'am';
  if (H > 12) H -= 12; else if (H == 0) H = 12;
  return Math.round(D.getTime() / 1000) + ', ' + D.getFullYear() + '-' + NN(D.getMonth() + 1) + ' ' + NN(D.getDate()) + ' ' + NN(H) + ':' + NN(D.getMinutes()) + ':' + NN(D.getSeconds()) + A;
}

// LocalTimeA([ms]) >>> Mmmmmmm D, YYYY
function LocalTimeA(T)
{
  var D = (typeof(ms) == 'undefined') ? new Date() : new Date(isNaN(ms) ? 0 : Math.round(ms));
  var MO = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
  return MO[D.getMonth()] + ' ' + D.getDate() + ', ' + D.getFullYear();
}

// LocalTimeB([ms]) >>> YYYY-MM-DD
function LocalTimeB(T)
{
  var D = (typeof(ms) == 'undefined') ? new Date() : new Date(isNaN(ms) ? 0 : Math.round(ms));
  return D.getFullYear() + '-' + NN(D.getMonth() + 1) + '-' + NN(D.getDate());
}

// LocalTimeC([ms]) >>> HH:MM (24-hour format)
function LocalTimeC(ms)
{
  var D = (typeof(ms) == 'undefined') ? new Date() : new Date(isNaN(ms) ? 0 : Math.round(ms));
  return NN(D.getHours()) + ':' + NN(D.getMinutes());
}

// LocalTimeD([ms]) >>> YYYY-MM-DD HH:MM:SS mmm
function LocalTimeD(ms)
{
  var D = (typeof(ms) == 'undefined') ? new Date() : new Date(isNaN(ms) ? 0 : Math.round(ms));
  return D.getFullYear() + '-' + NN(D.getMonth() + 1) + ' ' + NN(D.getDate()) + ' ' + NN(D.getHours()) + ':' + NN(D.getMinutes()) + ':' + NN(D.getSeconds()) + ' ' + ((D.getMilliseconds() + 1000) + '').slice(1);
}

//////////////////////////////////////////////////
//                                      v2021.7.30
// This function returns a text string that says
// how long ago time T was recorded. It can also
// describe future times. For example, it can
// return "5 minutes ago" or "3 weeks from now."
// Usage: STRING = TimeAgo(MILLISECONDS)
//
function TimeAgo(T)
{
  var DIFF = TIME() - T;
  var PAST = DIFF < 0 ? 0 : 1;
  var AGO = PAST ? ' ago' : ' from now';
  DIFF = Math.abs(DIFF);
  if (DIFF < 70000) return PAST ? 'just now' : 'about now';
  if (DIFF < 120000) return 'a minute' + AGO;
  if (DIFF < 3000000) return Math.round(DIFF / 60000) + ' minutes' + AGO;
  if (DIFF < 6000000) return 'about an hour' + AGO;
  if (DIFF < 86400000) return Math.floor(DIFF / 3600000) + ' hours' + AGO;
  if (DIFF < 172800000) return PAST ? 'yesterday' : 'tomorrow';
  if (DIFF < 604800000) return Math.floor(DIFF / 86400000) + ' days' + AGO;
  if (DIFF < 950400000) return PAST ? 'last week' : 'next week';
  if (DIFF < 2298240000) return Math.floor(DIFF / 604800000) + ' weeks' + AGO;
  if (DIFF < 3110400000) return PAST ? 'last month' : 'next month';
  if (DIFF < 29462400000) return Math.floor(DIFF / 2635200000) + ' months' + AGO;
  if (DIFF < 59918400000) return 'a year' + AGO;
  if (DIFF < 31536000000) return Math.round(DIFF / 31536000000) + ' years' + AGO;
  if (DIFF < 31851360000) return 'a century' + AGO;
  return Math.round(DIFF / 3153600000000) + ' centuries' + AGO;
}
//////////////////////////////////////////////////
//
// This function says the current time every 20 minutes.
function SayTime()
{
  var T = new Date();
  var HOURS = T.getHours();
  var MINUTES = T.getMinutes();

  if (HOURS == 0)
  {
    if (MINUTES < 15)
      Say("It's midnight.");
    else
      Say("It's " + MINUTES + " minutes past midnight.");
    return;    
  }

  if (HOURS > 12) HOURS -= 12;

  if (MINUTES < 15)
    Say("The time is " + HOURS + " o'clock.");
  else
    Say("The time is " + HOURS + " " + MINUTES + ".");

  // Say time again 20 minutes later
  setTimeout("SayTime();", 1200000);
}

//////////////////////////////////////////////////
//
//
//               COLOR FUNCTIONS
//
//

// Converts 3 decimal numbers to hex color code.
function toColor(R, G, B) { return toHex(R) + toHex(G) + toHex(B); }

// WARNING: This function overwrites global variables: R,G,B
// Converts a hex color code to individual R, G, B numbers.
function GetRGB(C) { C = Hex2Int(C); R = (C & 0xFF0000) >>> 16; G = (C & 0xFF00) >>> 8; B =  C & 0xFF; }

// WARNING: This function overwrites global variables: R,G,B
// This function returns the opposite color of C in hex format
function InvertColor(C) { GetRGB(C); return toColor(255-R, 255-G, 255-B); }

// This function can increase or decrease R-G-B brightness of a color and return a new color.
function ColorGain(C, R_GAIN, G_GAIN, B_GAIN) { GetRGB(C); R += R_GAIN; G += G_GAIN; B += B_GAIN; return toColor(R, G, B); }

// WARNING: This function overwrites global variables: R,G,B,R1,G1,B1,R2,G2,B2,RX,GX,BX
// Returns an array of colors which is a transition from C1 to C2 in N steps
function GetColorShades(C1, C2, N) { var i, A = [C1]; if (N > 2) { CalculateColorGain(C1, C2, N); for (i = 0; i < N-2; i++) { R1 += RX; G1 += GX; B1 += BX; A.push(toColor(R1, G1, B1)); } } A.push(C2); return A; }

// WARNING: This function overwrites global variables: R,G,B,R1,G1,B1,R2,G2,B2,RX,GX,BX
// This function calculates how much R, G, B values need to change
// in order go from color C1 to color C2 in N steps.
// Side effects: C1 -> R,G,B
function CalculateColorGain(C1, C2, N) { GetRGB(C2); R2=R; G2=G; B2=B; GetRGB(C1); R1=R; G1=G; B1=B; RX = (R2 - R1) / (N - 1); GX = (G2 - G1) / (N - 1); BX = (B2 - B1) / (N - 1); }

// WARNING: This function overwrites global variables: R,G,B,R1,G1,B1,R2,G2,B2,RX,GX,BX
// Prints each letter in a different color from C1 to C2.
function WriteInColor(S, C1, C2) { var i, c; CalculateColorGain(C1, C2, S.length); for (i = 0; i < S.length; i++) { c = S.charCodeAt(i); if (c < 33) PRINT("&nbsp;"); else { if (c == 38) c = "&amp;"; else if (c == 60) c = "&lt;"; else if (c == 62) c = "&gt;"; else c = S.charAt(i); PRINT("<FONT COLOR=" + toColor(R, G, B) + ">"+c+"</FONT>"); } R += RX; G += GX; B += BX; } }

//////////////////////////////////////////////////
//
//
//            COMPRESSION FUNCTIONS
//
//

// This function splits binary string S into groups of 8 and removes the first digit of each group and returns a new string. This function can remove the first N digits if a second argument is provided.
// Example:
//  DiscardHighBit("1000000010000000");    -> "00000000000000"
//  DiscardHighBit("1100000011000000", 2); -> "000000000000"
//  DiscardHighBit("1110000011100000", 3); -> "0000000000"
function DiscardHighBit(S) { S = Group(S, 8); var i, N = (arguments.length == 2) ? arguments[1] : 1; for (i = 0; i < S.length; i++) S[i] = S[i].slice(N); return S.join(""); }

// This function is the opposite of DiscardHighBit() function. If a string is provided as a second argument, this string will be inserted at the beginning of every group.
// Example:
//  InsertHighBit("11111111111111");    -> "0111111101111111"
//  InsertHighBit("1111111111", "000"); -> "0001111100011111"
//  InsertHighBit("00000000", "1111");  -> "1111000011110000"
function InsertHighBit(S) { var BITS = (arguments.length > 1) ? arguments[1] : "0"; var N = (8 - BITS.length); S = Group(S, N); for (var i = 0; i < S.length; i++) S[i] = BITS + S[i]; return S.join(""); }

//////////////////////////////////////////////////
//                                     v2019.12.27
// This function compresses a text to binary string
// by removing the highest 0 bit from every byte
// thus shrinking the output by 8:7 ratio.
// Usage: STRING = Compress8to7(TEXT)
//
function Compress8to7(T)
{
  var i, j, L = T.length,
  BINARY = [(((L-1) & 7) == 0) || (((L-2) & 7) == 0) ? '1' : '0'];
  for (i = j = 0; i < L; i++)
    BINARY[++j] = toBin(T.charCodeAt(i) & 127, 7);
  BINARY = BINARY.join("");
  // This line is really unnecessary.
  // It is here just for clarification only:
  // while (BINARY.length & 7) BINARY += '0';
  return Bin2Str(BINARY);
}
//////////////////////////////////////////////////
//                                     v2019.12.27
// This function expands a binary string to a text
// by inserting a '0' in the high bit of each byte,
// thus expanding the output by a 7:8 ratio.
// Usage: TEXT = Expand7to8(STRING)
//
function Expand7to8(S)
{
  var BINARY = Str2Bin(S);
  var L = BINARY.length - 1;
  var OUTPUT = [];
  for (i = 1; i < L; i += 7)
    OUTPUT.push(String.fromCharCode(parseInt(BINARY.substr(i, 7), 2)));
  if (BINARY.charCodeAt(0) == 48)
    OUTPUT.pop();
  return OUTPUT.join("");
}
//////////////////////////////////////////////////
//                                      v2021.7.24
// Compresses a string by discarding the high 2 bits
// in every byte, thus reducing string length by 25%.
// So, from 8 bits, we go to 6 bits.
// Usage: STRING = Compress8to6(STRING)
//
function Compress8to6(S)
{
  // Pack 4 bytes into 3 like this:
  // 11223344 55667788 99AABBCC DDEEFFGG => 22334466 7788AABB CCEEFFGG
  if (typeof(S) === "undefined" || S == null) return ""; S += "";
  var i = 0, j = 0, A, B, C, D, OUTPUT = [];
  while (i < S.length)
  {
    A = S.charCodeAt(i++) & 63;
    B = S.charCodeAt(i++) & 63;
    C = S.charCodeAt(i++) & 63;
    D = S.charCodeAt(i++) & 63;
    OUTPUT[j++] = String.fromCharCode((A << 2) | (B >> 4));
    OUTPUT[j++] = String.fromCharCode(((B & 15) << 4) | ((C >> 2) & 15));
    OUTPUT[j++] = String.fromCharCode(((C & 3) << 6) | D);
  }
  return OUTPUT.join("");
}
//////////////////////////////////////////////////
//                                      v2021.7.24
// Expands a string by adding two zero high bits
// in each byte, increasing string length by 33%.
// Usage: STRING = Expand6to8(STRING)
//
function Expand6to8(S)
{
  // Expand 3 bytes into 4 like this:
  // 11223344 55667788 99AABBCC => 00112233 00445566 00778899 00AABBCC
  if (typeof(S) === "undefined" || S == null) return ""; S += "";
  var i = 0, j = 0, A, B, C, OUTPUT = [];
  while (i < S.length)
  {
    A = S.charCodeAt(i++) & 255;
    B = S.charCodeAt(i++) & 255;
    C = S.charCodeAt(i++) & 255;
    OUTPUT[j++] = String.fromCharCode(A >> 2);
    OUTPUT[j++] = String.fromCharCode(((A & 3) << 4) | (B >> 4));
    OUTPUT[j++] = String.fromCharCode(C = ((B & 15) << 2) | (C >> 6));
    OUTPUT[j++] = String.fromCharCode(C & 63);
  }
  return OUTPUT.join("");
}
//////////////////////////////////////////////////
//
// LZW-compress a string
// [This function was copied from LZ-String.js]
//
function LzwCompress(s)
{
    var dict = {};
    var data = (s + "").split("");
    var out = [];
    var currChar;
    var phrase = data[0];
    var code = 256;
    for (var i=1; i<data.length; i++) {
        currChar=data[i];
        if (dict[phrase + currChar] != null) {
            phrase += currChar;
        }
        else {
            out.push(phrase.length > 1 ? dict[phrase] : phrase.charCodeAt(0));
            dict[phrase + currChar] = code;
            code++;
            phrase=currChar;
        }
    }
    out.push(phrase.length > 1 ? dict[phrase] : phrase.charCodeAt(0));
    for (var i=0; i<out.length; i++) {
        out[i] = String.fromCharCode(out[i]);
    }
    return out.join("");
}
//////////////////////////////////////////////////
//
// Expand an LZW-encoded string.
// [This function was copied from LZ-String.js]
//
function LzwExpand(s)
{
    var dict = {};
    var data = (s + "").split("");
    var currChar = data[0];
    var oldPhrase = currChar;
    var out = [currChar];
    var code = 256;
    var phrase;
    for (var i=1; i<data.length; i++) {
        var currCode = data[i].charCodeAt(0);
        if (currCode < 256) {
            phrase = data[i];
        }
        else {
           phrase = dict[currCode] ? dict[currCode] : (oldPhrase + currChar);
        }
        out.push(phrase);
        currChar = phrase.charAt(0);
        dict[code] = oldPhrase + currChar;
        code++;
        oldPhrase = phrase;
    }
    return out.join("");
}

//////////////////////////////////////////////////
//
//
//             ENCRYPTION FUNCTIONS
//
//

// These two functions encrypt/decrypt string S using passcode P which is an optional argument.
// The encryption algorithm in this function incorporates a random number generator, addition, bit rotate, and CRC check. Decrypt() will return an empty string if the data has been modified or tampered with in any way.
function Encrypt(S,P){if(S=="")return"";var c,i=S.length+4;if(typeof(P)=="undefined")P=0;c=Math.round((new Date()).getMilliseconds()+Math.random()*64536);P+=i+c;S=(S+"7X29"+IntStr(c)).split("");while(i--){P=(P*389+1.1)%2875;c=S[i].charCodeAt(0)-(P&255);c=ROL8(c,(P&0x700)>>8);S[i]=String.fromCharCode(c);}return S.join("");}
function Decrypt(S,P){var c,i,L=S.length-6;if(L<1)return"";if(typeof(P)=="undefined")P=0;i=L+4;P+=StrInt(S.slice(i))+i;S=S.split("");while(i--){P=(P*389+1.1)%2875;c=S[i].charCodeAt(0);c=ROL8(c,8-(P&0x700)>>8);c=(c+(P&255))&255;S[i]=String.fromCharCode(c);}S=S.join("");return(S.substr(L,4)=="7X29")?S.substr(0,L):"";}

// This function returns random numbers between 0 and 255.
function RND(SALT) { SEED = Math.floor(Math.abs(SEED * (SALT + 37719) - 42117361) % 9869513); return Math.floor(SEED / 38703.968); }

// This function returns a 14-digit random number between 0 and 1.
function RNDL(SALT) { var N = []; while (N.length < 4) { RND(SALT); N.push(SEED); } return "0." + N.join("").substr(0, 14).split("").reverse().join(""); }

// This function returns a word-size random number between 0 and 65536.
function RNDW(SALT) { RND(SALT); return Math.floor(SEED / 150.599); }

// This function encrypts a string using the XOR operator.
function XCrypt(S, P) { var i, OUTPUT = []; SEED = CRC(P); for (i = 0; i < S.length; i++) OUTPUT.push(String.fromCharCode(RND(i) ^ S.charCodeAt(i))); return OUTPUT.join(""); }

// This function can shuffle the contents of an array or put the elements back in the original order.
function Shuffle(ARRAY, UNDO) { var i, R = []; var L = ARRAY.length; for (i = 0; i < L; i++) R.push(Math.floor(RNDL(i) * L)); if (UNDO) { for (i = 0; i < L; i++) Swap(ARRAY, R[i], i); } else { for (L--; L >= 0; L--) Swap(ARRAY, R[L], L); } }

// This function doubles the size of input string and returns a new string. The new string will not resemble the input string in any way or form. It will look like a totally mixed up encrypted string.
//function AddSalt(S, SET, N) { var S = S.split(""); while (N-- > 0) S.push(SET.charAt(Math.round(Math.random()*(SET.length-1)))); Shuffle(S, 0); return S.join(""); }
function AddSalt(TEXT) { var i, A, B, C, X = []; for (i = 0; i < TEXT.length; i++) { C = TEXT.charCodeAt(i); A = Math.round(Math.random() * 255); B = (C - A) & 255; X.push(A); X.push(B); } for (i = 0; i < X.length; i++) X[i] = String.fromCharCode(X[i]); return X.join(""); }

// This function removes the extra bytes added to it by AddSalt()
//function RemoveSalt(S, N) { var S = S.split(""); Shuffle(S, 1); S.length -= N; return S.join(""); }
function RemoveSalt(TEXT) { var i, A, B, C, X = []; for (i = 0; i < TEXT.length; i++) { A = TEXT.charCodeAt(i++); B = TEXT.charCodeAt(i); C = (A + B) & 255; X.push(String.fromCharCode(C)); } return X.join(""); }

//////////////////////////////////////////////////
//                                     v2019.12.27
// Returns an encrypted string. The "password" consists
// of four decimal numbers stored in a global array
// named RND[], and RND[0] is the initial seed.
// Usage: STRING = EncryptString(STRING)
//
function EncryptString(S)
{
  var c, L = S.length, OUTPUT = [];
  while (L--)
  {
    RND[0] *= RND[2] + RND[3];
    RND[0] -= RND[4] * Math.floor(RND[0] / RND[4]);
    c = S.charCodeAt(L);
    c = ((c & 3) << 6) | (c >> 2);
    OUTPUT[L] = String.fromCharCode((c ^ RND[1]) - Math.floor(RND[0]) & 255);
  }
  return OUTPUT.join("");
}
//////////////////////////////////////////////////
//                                     v2019.12.27
// Decrypts a string. The "password" consists of
// four decimal numbers stored in a global array
// named RND, and RND[0] is the initial seed.
// Usage: STRING = DecryptString(STRING)
//
function DecryptString(S)
{
  var c, L = S.length, OUTPUT = [];
  while (L--)
  {
    RND[0] *= RND[2] + RND[3];
    RND[0] -= RND[4] * Math.floor(RND[0] / RND[4]);
    c = ((S.charCodeAt(L) + Math.floor(RND[0])) & 255) ^ RND[1];
    OUTPUT[L] = String.fromCharCode(((c & 63) << 2) | (c >> 6));
  }
  return OUTPUT.join("");
}
//////////////////////////////////////////////////

//////////////////////////////////////////////////
//                                     v2020.12.31
// This function returns a simple 16-bit CRC.
// Usage: INTEGER = CRC(STRING)
//
function CRC(S)
{
  var i = S.length, SEED = 43.3991070255 + i;
  while (i--)
    SEED = (SEED * 1852.6785013 + S.charCodeAt(i) + 3917.48511) % 9971;
  return (SEED / 9970 * 0xFFFFFF) & 0xFFFFFF;
}
//////////////////////////////////////////////////
//                                     v2020.12.29
// This function shuffles characters of a string
// in a way that it can be unshuffled later!
// Usage: STRING = ForwardShuffle(STRING, [SEED])
//
function ForwardShuffle(S, SEED)
{
  if (typeof(SEED) === "undefined") SEED = 14.169170531;
  var L = S.length;
  var A = S.split("");
  for (var i = 0; i < L; i++)
  {
    SEED = (SEED * 3771.108376549 + 533.1500429732) % 9177;
    Swap(A, (SEED / 9176 * L) | 0, i);
  }
  return A.join("");
}
// SHORT VERSION:
// Shuffles a string in a way that it can be unshuffled later!
// function ForwardShuffle(S, SEED) { if (typeof(SEED) === "undefined") SEED = 14.169170531; var L = S.length; var A = S.split(""); for (var i = 0; i < L; i++) { SEED = (SEED * 3771.108376549 + 533.1500429732) % 9177; Swap(A, (SEED / 9176 * L) | 0, i); } return A.join(""); }
//
//////////////////////////////////////////////////
//                                     v2020.12.29
// This function unshuffles characters of a string
// that have been shuffled by the ForwardShuffle()
// function. Make sure to use the same SEED value!
// Usage: STRING = BackwardShuffle(STRING, [SEED])
//
function BackwardShuffle(S, SEED)
{
  if (typeof(SEED) === "undefined") SEED = 14.169170531;
  var L = S.length, R = [];
  var A = S.split("");
  for (var i = 0; i < L; i++)
  {
    SEED = (SEED * 3771.108376549 + 533.1500429732) % 9177;
    R[i] = (SEED / 9176 * L) | 0;
  }
  for (L--; L >= 0; L--) Swap(A, R[L], L);
  return A.join("");
}
// SHORT VERSION:
// This function unshuffles a string that has been shuffled by the ForwardShuffle() function.
// function BackwardShuffle(S, SEED) { if (typeof(SEED) === "undefined") SEED = 14.169170531; var L = S.length, R = []; var A = S.split(""); for (var i = 0; i < L; i++) { SEED = (SEED * 3771.108376549 + 533.1500429732) % 9177; R[i] = (SEED / 9176 * L) | 0; } for (L--; L >= 0; L--) Swap(A, R[L], L); return A.join(""); }
//
//////////////////////////////////////////////////
//                                     v2020.12.29
// This function returns the next "random" number
// in a series based on the global variable SEED.
// A SALT value may be passed to modify the series.
// The value returned will always be a number
// betwen 0 and 1. To be more precise,
// it will be:  0 >= RETURNED_VALUE <= 1
// Usage: FLOAT = NextRND([SALT])
//
function NextRND(SALT)
{
  if (typeof(SEED) === "undefined") SEED = 405.229417;
  SALT = (typeof(SALT) === "undefined") ? 533.150029 : SALT + 533.150029;
  SEED = (SEED * 3771.108376559 + SALT) % 9177;
  return SEED / 9176;
}

//////////////////////////////////////////////////
//
//
//              STRING FUNCTIONS
//
//

// FAST STRING MANIPULATION. Prototypes take up to 4-5 times longer
// to execute vs. plain functions. So, these are all plain functions.

//////////////////////////////////////////////////
function _isBin(c)   { return (c < 48 || c > 49) ? 0 : 1; }  // Returns 1 if a character code is either "1" or "0"
function _isOct(c)   { return (c < 48 || c > 55) ? 0 : 1; }  // Returns 1 if a character code is a valid octal digit (0-7).
function _isDec(c)   { return (c < 48 || c > 57) ? 0 : 1; }  // Returns 1 if a character code is a valid decimal digit (0-9).
function _isDigit(c) { return (c < 48 || c > 57) ? 0 : 1; }  // Returns 1 if a character code is a valid decimal digit (0-9).
function _isHex(c)        { return CX[c] & 256 ? 1 : 0; }    // Returns 1 if a character code is a valid hexadecimal digit.
function _isUpperCase(c)  { return CX[c] & 2 ? 0 : 1; }      // Returns 1 if a character code is an uppercase character. (This test includes certain foreign letters too.)
function _isLowerCase(c)  { return CX[c] & 4 ? 0 : 1; }      // Returns 1 if a character code is an lowercase character. (This test includes certain foreign letters too.)
function _isVowel(c)      { return CX[c] & 0x8000 ? 1 : 0; } // Returns 1 if a character code is a vowel in the English language.
function _isConsonant(c)  { return CX[c] & 0x4000 ? 1 : 0; } // Returns 1 if a character code is a consonant in the English language.
function _isLetter(c)     { return CX[c] & 0xC000 ? 1 : 0; } // Returns 1 if a character code refers to one of the letters of the English alphabet.
function _isSymbol(c)     { return CX[c] & 1024 ? 1 : 0; }   // Returns 1 if a character code refers to one of the symbol characters on a keyboard
function _isWhitespace(c) { return CX[c] & 512 ? 1 : 0; }    // Returns 1 if a character code is a whitespace
function _isPrintable(c)  { return CX[c] & 0xFDFF ? 1 : 0; } // Returns 1 if a character is a printable character and won't mess up the screen (this includes TAB, SPACE, CR, LF, but does not include NUL, ESC, BEL...)
function _isVarInitial(c) { return CX[c] & 1; }              // Returns 1 if a character might be the first letter of a variable or function name or keyword in JavaScript. This includes all letters the dollar sign, the underscore character and several characters from the extended ASCII chart.
function _isVarName(c)    { return CX[c] & 257; }            // Returns 1 if a character might be part of a variable or function name or keyword. This group includes numbers too. (But variables names may not start with a number.)
function _isAlphaNumeric(c) { return CX[c] & 0xC100 ? 1 : 0; } // Returns 1 if a character is either a letter or a number
//////////////////////////////////////////////////
function isBin(S)          { return TestString(S, _isBin)               == 100 ? 1 : 0; }
function isOct(S)          { return TestString(S, _isOct)               == 100 ? 1 : 0; }
function isHex(S)          { return TestString(S, _isHex)               == 100 ? 1 : 0; }
function isNumeric(S)      { return TestString(S, _isDec)               == 100 ? 1 : 0; }
function isPrintable(S)    { return TestString(S, _isPrintable,    100) == 100 ? 1 : 0; }
function isSafeHTML(S)     { return TestString(S, _isSafeHTML,     100) == 100 ? 1 : 0; }
function isAlphaNumeric(S) { return TestString(S, _isAlphaNumeric, 100) == 100 ? 1 : 0; }
function isLettersOnly(S)  { return TestString(S, _isLetter,       100) == 100 ? 1 : 0; }
function isUpperCase(S)    { return TestString(S, _isUpperCase,    100) == 100 ? 1 : 0; }
function isLowerCase(S)    { return TestString(S, _isLowerCase,    100) == 100 ? 1 : 0; }

function uc(S) { return S.toUpperCase(); }
function lc(S) { return S.toLowerCase(); }
function LEN(s) { return (s + "").length; }
function ASC(S) { return S.charCodeAt(0); }
function CHR$(C) { return String.fromCharCode(C); }
function STR$(n) { return n + ""; }
function UCASE$(s) { return s.toUpperCase(); }
function LCASE$(s) { return s.toLowerCase(); }
function SPACE$(n) { s = ""; while (s.length < n) s += " "; return s; }
function STRING$(n, x) { s = ""; while (n--) s += x; return s; }
function QUOTE(S) { return '"' + S + '"'; }

function PackInts(LENGTH, INT) { var i, OUTPUT = []; for (i = 0; i < arguments.length; i++) { LENGTH = arguments[i++]; INT = arguments[i]; OUTPUT.push(toBin(INT, LENGTH)); } return OUTPUT.join(""); }
function PackBits() { var $ = ""; for (var i = 0; i < arguments.length; i++) $ += arguments[i] ? '1' : '0'; return $; }

// Capitalizes the first LETTER of string S and returns a new string.
function Capitalize(S) { var i, c; S = S.toLowerCase().split(""); for (i = 0; i < S.length; i++) { c = S[i].charCodeAt(0); if (c > 96 && c < 123) { S[i] = S[i].toUpperCase(); break; } } return S.join(""); }

// Capitalizes the first letter of every word, and returns a new string.
function TitleCase(S) { S = S.toLowerCase().split(""); var i, F = 1, WS = " .,:;!?/\()[]{}<>|-+=\t\n\r\xFF"; for (i = 0; i < S.length; i++) { if (WS.indexOf(S[i]) >= 0) F = 1; else if (F == 1) { S[i] = S[i].toUpperCase(); F = 0; } } return S.join(""); }

// Capitalizes the first letter of each sentence and returns a new string.
function SentenceCase(S) { S = S.toLowerCase().split(""); var i, N = 1, SP = " ,:;/\()[]{}<>|-+=\t\r\n\xFF"; for (i = 0; i < S.length; i++) { if (SP.indexOf(S[i]) >= 0); else if (".!?".indexOf(S[i]) >= 0) N = 1; else if (N) { S[i] = S[i].toUpperCase(); N = 0; } } return S.join(""); }

// Capitalizes every other letter of string S and returns a new string.
function EveryOther(S) { S = S.toLowerCase().split(""); for (var i = 1; i < S.length; i += 2) S[i] = S[i].toUpperCase(); return S.join(""); }

// Reverses uppercase letters with lowercase and vice versa.
function ReverseCase(S) { S = S.split(""); var i, c; for (i = 0; i < S.length; i++) { c = S[i].charCodeAt(0); if (c < 65 || c > 122) continue; if (c > 90 && c < 97) continue; S[i] = String.fromCharCode(c ^ 32); } return S.join(""); }

// Capitalizes each instance of the word W in string S.
function MatchWord(S, W) { return S.toLowerCase().split(W.toLowerCase()).join(W.toUpperCase()); }

// Inserts string B into A starting at offset N.
// If N > 0, then inserts from the beginning of string.
// If N < 0, then inserts from the end of string.
function StrInsert(A, B, N) { A += ""; B += ""; if (A.length == 0) return B; if (B.length == 0) return A; if (N > A.length) N = A.length; if (N < 0) N += A.length; if (N < 0) N = 0; var PART1 = A.substr(0, N); var PART2 = A.slice(N); return PART1 + B + PART2; }

// This function removes all foreign characters from string S
// that are not "allowed" and returns a new string.
function strFilter(S, ALLOWED) { var i, c, $ = []; S += ""; for (i = 0; i < S.length; i++) { c = S.charAt(i); if (ALLOWED.indexOf(c) >= 0) $.push(c); } return $.join(""); }

// This function removes whitespace from the left and returns a new string.
function LTRIM$(T) { T += ""; var i = 0; while (T.charCodeAt(i) < 33) i++; return T.slice(i); }

// This function removes whitespace from the right and returns a new string.
function RTRIM$(T) { T += ""; var i = T.length; while (T.charCodeAt(--i) < 33); return T.substr(0, i+1); }

// Converts all adjacent whitespace characters to a single space.
function CollapseWhitespace(S) { S = S.split(""); var i, x, c = 0; for (i = 0; i < S.length; i++) { x = c; c = S[i].charCodeAt(0); if (c < 14) c = 32; if (c == 32) S[i] = (x == 32) ? "" : " "; } return S.join(""); }

// This function counts how many times each character occurs in a string. Returns a sorted array with statistics. The low 8 bits in each element will hold the character code; the high bits will hold the count.
function CharCount(S) { var i = 0, A = []; while (i < 256) A.push(i++); if (S.length == 0) return A; for (i = 0; i < S.length; i++) A[S.charCodeAt(i)] += 256; return A.sort(function(a, b) {return a-b}); }

// This function prints the results of the CharCount() function.
function ShowCount(S) { var i, C, N, X, HTML = ["<HR><TABLE WIDTH=100% BGCOLOR=006699><TD><CENTER><FONT SIZE=5 COLOR=FFFFFF><B>Character Statistics</TABLE><TABLE BGCOLOR=EEEEEE CELLSPACING=3 CELLPADDING=0 STYLE='FONT-SIZE:15PX;'>"]; var A = CharCount(S); var max = Math.max.apply(0, A) >> 8; A.reverse(); function HTMLCHR(c) { var B = String.fromCharCode(c); if (B == " ") return "&nbsp;"; if (B == "&") return "&amp;"; if (B == "<") return "&lt;"; if (B == ">") return "&gt;"; return (c < 32 || c == 173 || (c > 126 && c < 161)) ? "." : B; } for (i = 0; i < 256; i++) { X = A.shift(); C = X & 0xFF; N = (X & 0xFFFFFF00) >> 8; X = HTMLCHR(C); if (N == 0) break; HTML.push("<TR><TD><NOBR><FONT SIZE=4>0x" + toHex(C).toUpperCase() + " =&nbsp;<TD><CENTER><FONT SIZE=4>" + C + "<TD><FONT SIZE=4>&nbsp;= \"<FONT COLOR=006600><B>" + X + "</B></FONT>\"&nbsp;<TD>:&nbsp;<TD ALIGN=RIGHT><FONT SIZE=4>" + N + "<TD><FONT SIZE=4>&nbsp;" + Repeat("&#x2592;", Math.floor(40 * N / max))); } HTML.push("</TABLE><BR><FONT SIZE=4>The following characters never occur in the string:<BR>"); A.sort(function(a, b) {return a-b}); for (N = 0; i < A.length; i++) { C = A[i] & 0xFF; X = HTMLCHR(C); if (!(N++ % 10)) HTML.push("<BR>"); HTML.push(" 0x" + toHex(C).toUpperCase() + "=<FONT COLOR=RED><B>" + X + "</B></FONT>"); } HTML.push("<P>Length of input string : " + S.length + " bytes<HR>"); document.write(HTML.join("")); }

// This function returns a section of a full character set. A full character set always contains 256 characters from 0 to 255. But this function returns only a certain segment of that set defined by MIN and MAX. If MIN is smaller than MAX, then you get a normal character set starting at MIN and ending at MAX. Example: charSet(97, 99) --> "abc" However, if MIN is greater than MAX, then you get the inverse character set that includes every character EXCEPT those defined by MIN and MAX.
function CharRange(MIN, MAX) { var A = []; if (MIN > MAX) MIN++; else MAX++; MIN &= 255; MAX &= 255; while (MIN != MAX) { A.push(String.fromCharCode(MIN++)); MIN &= 255; } return A.join(""); }

// This function returns the inverse set of characters that are not found anywhere in string S.
// Example: inverseCharSet("YELLOW") will take a 256-byte long character set and remove the letters Y E L O W from the set and return what's left.
function inverseCharSet(S) { var i, A = []; for (i = 0; i < 256; i++) A.push(String.fromCharCode(i)); for (i = 0; i < S.length; i++) A[S.charCodeAt(i)] = ""; return A.join(""); }

// This function lists the characters that are used in string S and returns a sorted string.
function regularCharSet(S) { S += ""; if (S.length == 0) return ""; var A = [], i = S.length; while (i-- > 0) A[S.charCodeAt(i)] = 2; while (i < 256) { A[i] = (A[i] == 2) ? String.fromCharCode(i) : ""; i++; } return A.sort().join(""); }

// This function returns 1 if string S is strictly made up of characters listed in string KNOWN. Returns 0 if string S contains any "unknown" characters.
function isFromCharSet(S, KNOWN) { S += ""; for (var i = 0; i < S.length; i++) if (KNOWN.indexOf(S.charAt(i)) < 0) return 0; return 1; }

// This function translates each character of string S according to new character table NEWSET.
// Example:
//  ConvertCharSet("aacb", "abc", "123") --> "1132"
//  ConvertCharSet("hello", "abcdefghijklmno", "-+0123456789XYZ") --> "5299Z"
function ConvertCharSet(S, OLDSET, NEWSET) { var i, P; S = S.split(""); for (i = 0; i < S.length; i++) { P = OLDSET.indexOf(S[i].charAt(0)); S[i] = (P >= 0) ? NEWSET.charAt(P) : ""; } return S.join(""); }

// Returns the last N bytes of a string.
function sliceLast(S, N) {if(S.length==0)return"";if(typeof(N)=="undefined")return"";if(N<1)return"";if(N>=S.length)return S;return S.substr(S.length-N,N);}

// This function repeats a string N number of times.
function Repeat(S, N) { return (new Array(N+1)).join(S); }

// This function trims text T and removes excess characters from the end and adds "..."
function Truncate(T, MAXLEN) { T = Trim(T); if (T.length <= MAXLEN) return T; return T.substr(0, MAXLEN - 3) + "..."; }

// This function removes all characters found in string L from string S and returns what's left of string S.
function RemoveChars(S, L) { var i, c; for (i = 0; i < L.length; i++) { c = L.charAt(i); S = S.split(c).join(""); } return S; }

// This function calculates a revolver index for strings. A revolver index means it wraps around. For example, if the string is 5 bytes long and you want to grab byte 7, then the index wraps around, so you'll get byte 2. This function returns 2. And if you want to grab the last byte of the string, you simply reach for -1 and this function will return the index to the last byte of string.
function rvx(INDEX, LEN) { INDEX %= LEN; if (INDEX < 0) INDEX += LEN; return INDEX; }

// This function returns a character from string S using revolver index X.
function CharAt(S, X) { return S.charAt(rvx(X, S.length)); }

// This function returns a character at position X. If X is longer than the length of string, it wraps around. If X is a negative index, it will start counting from the end of string S.
function CharCodeAt(S, X) { return S.charCodeAt(rvx(X, S.length)); }

// Returns 1 if the first byte of string S is a letter of the alphabet.
function isLetter(S) { var c = S.charCodeAt(0) & 223; return (c > 64 && c < 91) ? 1 : 0; }

// This function returns a section of string S that comes before the first occurrence of string M. The match is case sensitive.
function StrBefore(S, M) { var E = S.indexOf(M); return (E > 0) ? S.substr(0, E) : ""; }

// This function returns a section of string S that comes after the first occurrence of string M. The match is case sensitive.
function StrAfter(S, M) { var E = S.indexOf(M); return (E > 0) ? S.slice(E + M.length) : ""; }

// This function counts how many times string M occurs in string S and returns an integer.
function StrCount(S, M) { return S.split(M).length - 1; }

// Returns 1 if string S starts with string M.
function StartsWith(S, M) { return (S.indexOf(M) == 0) ? 1 : 0; }

// Returns 1 if string S ends with string M.
function EndsWith(S, M) { return (S.lastIndexOf(M) == S.length - M.length) ? 1 : 0; }

// Ensures string S starts with prefix X.
function EnsureStart(S, X) { S += ""; X += ""; return (S.indexOf(X) == 0) ? S : X + S; }

// Ensures string S ends with suffix X.
function EnsureEnd(S, X) { S += ""; X += ""; return (S.lastIndexOf(M) == S.length - X.length) ? S : S + X; }

// Returns 1 if string S contains letters only.
function isLettersOnly(S) { S += ""; var i, c; for (i = 0; i < S.length; i++) { c = S.charCodeAt(i); if (c < 65 || c > 122) return 0; if (c > 90 && c < 97) return 0; } return 1; }

// Returns 1 if string S contains letters and numbers only.
function isAlphaNumberic(S) { S += ""; var i, c; for (i = 0; i < S.length; i++) { c = S.charCodeAt(i); if (c < 48 || c > 122) return 0; if (c > 90 && c < 97) return 0; if (c > 57 && c < 65) return 0; } return 1; }

// Returns 1 if string S is solely composed of whitespace or is null/undefined.
function isEmpty(S) { if (typeof S === "undefined") return 1; if (S == null) return 1; S += ""; var i, c; for (i = 0; i < S.length; i++) { c = S.charCodeAt(i); if (c < 14 || c == 32); else return 0; } return 1; }

// Returns 1 if string S is lower case only.
function isLower(S) { S += ""; return (S == S.toLowerCase()) ? 1 : 0; }

// Returns 1 if string S is upper case only.
function isUpper(S) { S += ""; return (S == S.toUpperCase()) ? 1 : 0; }

// Returns 1 if string S contains 0123456789 digits only.
function isNumeric(S) { S += ""; var i, c; for (i = 0; i < S.length; i++) { c = S.charCodeAt(i); if (c < 48 || c > 57) return 0; } return 1; }

// This function returns the number of digits that occur in a string.
function DigitCount(S) { S += ""; var i = S.length, N = 0; while (i--) { c = S.charCodeAt(i); if (c < 48 || c > 57) continue; N++; } return N; }

// This function splits string S at pointer X and puts the first half of the string into global variable $A and the second half into $B. When X is a negative index, it starts counting from the end of string S. This function always returns the length of $A.
function SplitAt(S, X) { if (X >= S.length) { $A = S; $B = ""; return S.length; } if (X == 0 || X <= -S.length) { $A = ""; $B = S; return 0; } $A = S.substr(0, (X < 0) ? S.length + X : X); $B = S.slice(X); return $A.length; }

// This function splits string S into two parts along the first occurrence of pattern P. The two parts will be stored in global variables named $A and $B. This function returns 1 if the pattern was found, or zero if it was not found.
function SplitAB(S, P) { var N = S.indexOf(P); if (N < 0) { $A = S; $B = ""; return 0; } $A = S.slice(0, N); $B = S.slice(N + P.length); return 1; }

// This function splits string S into two parts along the last occurrence of pattern P. The two parts will be stored in global variables named $A and $B. This function returns 1 if the pattern was found, or zero if it was not found.
function LastSplitAB(S, P) { var N = S.lastIndexOf(P); if (N < 0) { $A = S; $B = ""; return 0; } $A = S.slice(0, N); $B = S.slice(N + P.length); return 1; }

// This function scans string S and replaces every occurrence of string A with B and returns a new string. Case sensitive search.
function StrReplace(S, A, B) { return S.split(A).join(B); }

// This function uses replace() with RegExp() to run a non-case-sensitive replace.
function StrReplaceAll(S, A, B) { return S.replace(RegExp(A, "gi"), B); }

// This function reverses string S.
function StrReverse(S) { return S.split("").reverse().join(""); }

// This function returns the first N characters of string S.
function StrLeft(S, N) { if (N < 1) return ""; return S.substr(0, N); }

// This function returns the last N characters of string S.
function StrRight(S, N) { if (N < 1) return ""; if (N >= S.length) return S; return S.slice(S.length - N); }

// This function is similar to the original split() method, however this will treat
// space, tab, new line, return, comma, semicolon, and period as separator characters.
// Also, the result will be all uppercase letters!
function Split(TEXT) { var i, A = [], C, START = null; TEXT = TEXT.toUpperCase() + "\n"; for (i = 0; i < TEXT.length; i++) { C = TEXT.charAt(i); if (C == ' ' || C == '\t' || C == '\n' || C == '\r' || C == ',' || C == ';' || C == '.') { if (START != null) A.push(TEXT.substring(START, i)); START = null; } else if (START == null) START = i; } return A; }

// This function splits a string along new-line characters and returns an array.
// Recognizes \r\n \n\n \r\r
function SplitLines(S) { if (S.indexOf("\r") < 0) return S.split("\n"); if (S.indexOf("\n") < 0) return S.split("\r"); return S.split("\r\n"); }

// This function counts the letters in a string.
// If an optional second argument is passed: if it's zero, returns
// the number of vowels, otherwise returns the number of consonants.
function LetterCount(S) { var c, n = 0, v = 0, i = S.length; while (i-- > 0) { c = S.charCodeAt(i) | 32; if (c < 97 || c > 122) continue; if (c == 97 || c == 101 || c == 105 || c == 111 || c == 117) v++; else n++; } if (arguments.length > 1) return (arguments[1]) ? n : v; return n+v; }

// This function encrypts or decrypts a string using a password string, and returns the result.
function StrXOR(STRING, PW) { var i, j, r, OUTPUT = [""]; for (r = i = j = 0; i < STRING.length; i++, j++) { if (j > PW.length) j = 0; OUTPUT[r] += String.fromCharCode(STRING.charCodeAt(i) ^ PW.charCodeAt(j)); if (OUTPUT[r].length > 100) { r++; OUTPUT[r] = ""; } } return OUTPUT.join(""); }

// This function takes any kind of binary string and converts it to a safe string that can be passed as an argument in the URL.
function EncodeURL(S) { return ConvertCharSet(EncodeB64(S), B64SET, URLSET); }

// This function takes an URL-safe string that contains letters and numbers only and returns a binary string.
function DecodeURL(S) { return DecodeB64(ConvertCharSet(S, URLSET, B64SET)); }

// This function converts a binary string (can be HTML or JavaScript) to a safe string that can be used in a HTML file within JavaScript tags.
function EncodeHTML(S) { var i, C; S = S.split(""); for (i = 0; i < S.length; i++) { C = S[i].charCodeAt(0); if (C == 7) S[i] = "\\t"; else if (C == 10) S[i] = "\\r"; else if (C == 13) S[i] = "\\n"; else if (C == 92) S[i] = "\\\\"; else if (C == 34 || C == 38 || C == 39 || C == 60 || C == 62 || C < 32 || C > 126) S[i] = "\\x" + toHex(C); } return '"' + S.join("") + '"'; }

// This function converts a Js safe string with quotation marks around it to its original source. It's the opposite of EncodeHTML()
function DecodeHTML(S) { S += ""; if (S.length > 1) { if (S.charAt(0) == '"' || S.charAt(0) == "'") S = S.slice(1, -1); } S = S.split("\\t").join("\t").split("\\r").join("\r").split("\\n").join("\n").split("\\\\").join("\\").split("\\x"); for (var i = 1; i < S.length; i++) S[i] = String.fromCharCode(parseInt(S[i].substr(0, 2), 16)) + S[i].slice(2); return S.join(""); }

// This function extracts email addresses from a string and returns them in an array.
function ExtractEmails(S) { var A = S.match(/([a-zA-Z0-9._\-+]+@[a-zA-Z0-9._-]+\.[a-zA-Z0-9._-]+)/gi); return A ? A : []; }

// This function returns 1 if the given URL does not contain
// any tabs, spaces, or illegal characters such as É Ñ µ ƒ ¥ £ ¡
function isValidURL(URL) { var c, i = URL.length; while (i-- > 0) { c = URL.charCodeAt(i); if (c < 33 || c > 126) return 0; } return 1; }

// This function returns 1 if the given email address has valid format, otherwise returns 0.
function isValidEmail(E) { var L = E.length; if (L < 3 || L > 253) return 0; var i, c, ATS = 0, DOT = 0, DOTS = 0, LTRS = 0; for (i = 0; i < L; i++) { c = E.charCodeAt(i); if (c > 57 && c < 61) return 0; if (c > 90 && c < 94) return 0; if (c < 33) return 0; if (c == 62 || c == 34 || c == 44) return 0; if (c == 46) { if (DOT == i) return 0; DOT = i+1; DOTS++; continue; } if (c == 64) { if (DOT == i) return 0; DOT = i+1; ATS++; if (i == 0 || ATS > 1) return 0; continue; } LTRS++; } if (ATS != 1 || DOTS == 0 || DOT == i || LTRS < 2) return 0; return 1; }

// This function returns 1 if the person's name provided has valid format, otherwise returns 0.
function isValidName(N) { var L = N.length; if (N < 2 || N > 64) return 0; var i, c; for (i = 0; i < L; i++) { c = N.charCodeAt(i); if (c < 33) return 0; if (c > 33 && c < 38) return 0; if (c > 39 && c < 44) return 0; if (c > 46 && c < 65) return 0; if (c > 90 && c < 97) return 0; if (c > 122 && c < 128) return 0; } return 1; }

// This function replaces each letter, number, $, and _ character with a different character from the same set and returns a new string. Uses the XOR operator. What this function does is more like plain encoding than encryption.
function tXt(S) {var c,P,i=S.length,$=[],A="0123456789$ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_",L=37;while(i--){c=S.charAt(i);P=A.indexOf(c);if(P>=0){P^=((i&3)*77+(i&3)+L++);c=A.charAt(P&63);}$[i]=c;}return $.join("");}

// This function calculates the checksum on a string and returns a 32-bit integer.
function Checksum(S) { var C = 0x55555555, i = S.length; while (i--) { C += ((S.charCodeAt(i) + 1) << ((i & 3) << 3)); C = ((C >> 31) & 1) | ((C << 1) & 0xFFFFFFFe); } return C & 0xFFFFFFFF; }

// This function adds spaces to the end of string S to make sure it will be exactly N characters long. If string S is longer than N, then returns the original string S with no changes.
function RSPACE(S, N) { S += ""; while (S.length < N) S += " "; return S; }

// This function adds spaces to the beginning of string S to make sure it will be exactly N characters long. If string S is longer than N, then returns the original string S with no changes.
function LSPACE(S, N) { S += ""; while (S.length < N) S = " " + S; return S; }

// This function outputs a string. If the input is undefined or null, returns an empty string. (v2021.3.28)
function MakeString(S) { return (typeof(S) == "string") ? S : (typeof(S) === "undefined" || S == null) ? "" : S + ""; }

// This function converts anything to a number. Returns 0 if the input is undefined, null or NaN.
function MakeNumber(S) { if (typeof(S) === "undefined" || S == null || isNaN(S)) return 0; return (typeof(S) == "number") ? S : S * 1; }

//////////////////////////////////////////////////
//                                       v2021.4.4
// This function creates a character lookup table
// to make finding characters in a string faster.
//
// When a function has to use indexOf() function
// to look up the position of a certain character
// in a character list that does not change,
// the process can be streamlined by storing the
// position of each character in a lookup table.
// Thus, CHARACTER_SET.indexOf(CHARACTER)
// becomes LOOKUP_TABLE[CHARACTER.charCodeAt(0)]
// It's a lot faster than using indexOf() repeatedly.
//
// Normally, this function returns a string, but
// when ARRAY_MODE is used, it returns an array
// of numbers.
//
// The return string or array will usually have a
// length of 256 bytes or 256 elements, however
// this can be changed by giving a different value
// in MAXSIZE. For example, MAXSIZE can be 128 when
// the index table is used to look up numbers and
// letters only whose ASCII code is well below 128.
// In this case, if a character is encountered
// whose ASCII code is beyond 128, the index table
// will return "undefined" since the element does
// not exist. If the index table is a string, then
// it will return 0, because String.charCodeAt() will
// always return zero when it is beyond the string's
// length.
//
// ZERO_FILL is an optional argument that allows
// the default what_if_character_is_not_found value
// to be different than zero. Normally, indexOf()
// returns -1 when something is not found, but the
// character index table will yield a zero value
// unless otherwise specified in the ZERO_FILL argument.
//
// Usage: STRING_OR_ARRAY = CreateIndexTable(STRING, MAXSIZE, [ARRAY_MODE, [ZERO_FILL]])
//
function CreateIndexTable(S, MAXSIZE, ARRAY_MODE, ZERO_FILL)
{
  if (typeof(S) === "undefined" || S == null) S = ""; else S += "";
  MAXSIZE &= 65535;
  ARRAY_MODE |= 0;
  ZERO_FILL &= 255;
  if (!ARRAY_MODE) ZERO_FILL = String.fromCharCode(ZERO_FILL);
  var i, T = [];
  for (i = 0; i < MAXSIZE; i++)
    T[i] = ZERO_FILL;
  for (i = 0; i < S.length; i++)
    T[S.charCodeAt(i)] = (ARRAY_MODE) ? i : String.fromCharCode(i);
  return (ARRAY_MODE) ? T : T.join("");
}
//////////////////////////////////////////////////
//                                       v2021.4.3
// This function is similar to indexOf() function,
// but this looks for individual characters rather
// than a whole string match. Returns zero if no
// matches were found, OR returns the position of
// the character right after the match.
//
// START_INDEX is a zero-based string pointer that
// tells this function where to start searching.
//
// NOTE: This function exists only for convenience.
// A simple regex search is slightly faster than calling
// this function, but if you want to look for special
// characters, the regex pattern can look confusing.
// This is nicer:
//   if (FindChars(STRING, "-abc")) ...
// but this does the same:
//   if (/[\-abc]+/.test(STRING) ...
//
// Usage: INTEGER = FindChars(STRING, SUBSTRING, [START_INDEX])
//
function FindChars(S, C, X)
{
  if (typeof(S) === "undefined" || typeof(C) === "undefined" || S == null || C == null) return 0;
  S += "";
  C += "";
  X |= 0;

  // S.search(RegExp("[^" + C.replace(/([^a-zA-Z0-9])/g, "\\$1") + "]+", "g"), "");
  // If we used the regex search solution above, we would have to
  // insert a backslash in front of every special character, which
  // would end up being 3X slower than this solution:
  if (C.length)
    while (X < S.length)
      if (C.indexOf(S.charAt(X++)) >= 0)
        return X;
  return 0;
}
//////////////////////////////////////////////////
//                                       v2021.4.4
// Converts an array of character codes to a string.
// If the array contains any undefined elements,
// those will be skipped.
//
// Usage: STRING = Array2String(ARRAY)
//
function Array2String(A)
{
  if (typeof(A) != "object" || A == null) return [];
  var i, p = 0, S = [];
  if (BROWSER_NAME == "MSIE" || BROWSER_NAME == "SEAMONKEY" || BROWSER_NAME == "SAFARI")
  {
    // MSIE, SeaMonkey and Safari seem to work with
    // arrays more efficiently, so for these browsers,
    // this makes a huge difference in performance.

    for (i = 0; i < A.length; i++)
      if (A[i] | 0 || typeof(A[i]) != "undefined")  // Testing if a number is non-zero takes a lot less time
        S[p++] = ALLCHARS[A[i] & 255];              // than figuring out if it's undefined. So, we first test
                                                    // for non-zero, then we test if it's undefined.
    // ALLCHARS is a global array that contains
    // all 256 characters. For MSIE and SeaMonkey,
    // accessing ALLCHARS is a lot faster than using
    // String.fromCharCode()

    return S.join("");
  }

  // Google Chrome, Firefox and Opera run a lot
  // faster with this code:
  S = "";
  for (i = 0; i < A.length; i++)
    if (A[i] | 0 || typeof(A[i]) != "undefined")
      S += String.fromCharCode(A[i] & 255);
  return S;
}
//////////////////////////////////////////////////
//                                      v2021.3.27
// This function removes whitespace, underscore
// and minus signs from a string and converts
// the following letter to upper case, except the
// first one. If a string starts with a letter,
// the first letter will always be lower case.
// Usage: STRING = camelize(STRING)
//
function Camelize(S)
{
  return MakeString(S).toLowerCase().replace(/^[ \r\n\t\_\-]|[ \r\n\t\_\-]+$/g,
  "").replace(/[-_\s]+(.)/g, function(match, c) { return c.toUpperCase(); } );
}
//////////////////////////////////////////////////
//                                      v2021.3.31
// This function returns the percentage of characters
// in a string that meet a certain criterion.
// Returns 100 if ALL of them meet the criterion.
// Returns 0 if NONE of them meet the criterion.
// Returns a number between 1 and 99 otherwise.
// Returns 0 if the input string is empty (OR if a
// third argument is given, it will return the value
// of the third argument when the input string is empty.)
//
// The second argument must be a function which accepts
// an ASCII character code (integer) and returns a
// non-zero integer when a character passes the test.
//
// Example:
//   TestString("5C3A", _isHex) -> 100
//   TestString("5C3A", _isLetter) -> 50
//   TestString("Apples?", _isDigit) -> 0
//   TestString("Whatever it takes", _isLetter) -> 88
//   TestString("", _isAlphaNumeric, 100) -> 100
//
// Usage: INTEGER = TestString(STRING, FUNCTION, [EMPTY])
//
function TestString(S, TEST, EMPTY)
{
  if (typeof(EMPTY) === "undefined") EMPTY = 0;
  if (typeof(S) === "undefined" || S == null) return EMPTY;
  S += "";
  var p = S.length, COUNT = 0;
  if (p == 0) return EMPTY;
  while (p--)
    if (TEST(S.charCodeAt(p)))
      COUNT++;
  if (COUNT == 0) return 0;
  if (COUNT == S.length) return 100;
  p = (COUNT / S.length * 100) | 0;
  return (p < 2) ? 1 : (p > 98 ? 99 : p);
}
//////////////////////////////////////////////////
//                                      v2021.3.31
// This function quotes special characters so they
// can be included in a Regular Expression
// character list without messing up the regex engine.
// Usage: STRING = QuoteRegExp(STRING)
//
function QuoteRegExp(S)
{
// TODO: Test this for speed on different browsers:
//  return makeString(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
  var i, c;
  S = MakeString(S).split("");
  for (i = 0; i < S.length; i++)
  {
    c = S[i].charCodeAt(0);
    if (_isAlphaNumeric(c) || c == 32 || c == 95) continue;
         if (c  < 8)  S[i] = "\\" + c;
    else if (c == 9)  S[i] = "\\t";
    else if (c == 10) S[i] = "\\n";
    else if (c == 12) S[i] = "\\f";
    else if (c == 13) S[i] = "\\r";
    else S[i] = _isPrintable(c) ? "\\" + S[i] : "\\x" + toHex(c);
  }
  return S.join("");
}
//////////////////////////////////////////////////
//                                      v2021.3.31
// Replaces SEARCHSTR with PASTE globally (not case sensitive).
// Usage: STRING = ReplaceAll(STRING, REPLACE_THIS, WITH_THIS)
//
function ReplaceAll(STRING, SEARCHSTR, PASTE)
{
  return STRING.replace(RegExp(QuoteRegExp(SEARCHSTR), "gi"), PASTE);
}
//////////////////////////////////////////////////
//                                       v2018.8.3
// This function moves a character or string pattern
// within a string by N number of bytes to the right
// or the left, inserting pad characters when needed.
//
// If DIRECTION is a positive value, the pattern is
// shifted to the right. If DIRECTION is a negative
// value, the pattern is shifted to the left.
// This function returns a new string.
//
// Usage: STRING = MovePattern(STRING, PATTERN, DIRECTION, PAD)
//
function MovePattern(STRING, PATTERN, DIRECTION, PAD)
{
  // TAKE CARE OF SOME EXCEPTIONAL CASES...

  if (typeof(STRING) === "undefined") return "";
  if (STRING == null || STRING.length == 0) return "";
  if (isNaN(DIRECTION)) return STRING;
  if (PATTERN.length == 0 || DIRECTION == 0) return STRING;

  var FOUND = STRING.indexOf(PATTERN);

  // IF CHARACTER OR PATTERN IS NOT FOUND, JUST EXIT.
  if (FOUND < 0) return STRING;

  var LEFT_SIDE = STRING.substr(0, FOUND);
  var RIGHT_SIDE = STRING.slice(FOUND + PATTERN.length);

  var STEP = Math.abs(DIRECTION);
  var SPACES, POS, LEN;

  if (DIRECTION < 0)   // MOVING CHAR TO THE LEFT...!
  {
    if (STEP == FOUND)
    {
      LEFT_SIDE = PATTERN + LEFT_SIDE;
    }
    else if (STEP > FOUND)  // MUST ADD SPACES TO THE BEGINNING
    {
      // This creates a string made up of X number of spaces
      // that is needed for padding:

      SPACES = new Array(STEP-FOUND+1);
      SPACES = SPACES.join(PAD);

      LEFT_SIDE = PATTERN + SPACES + LEFT_SIDE;
    }
    else
    {
      // In this case, we must split the LEFT_SIDE string.
      POS = FOUND - STEP;
      LEFT_SIDE = LEFT_SIDE.substr(0, POS) + PATTERN + LEFT_SIDE.slice(POS);
    }
  }
  else                 // MOVING CHAR TO THE RIGHT...!
  {
    LEN = RIGHT_SIDE.length;
    if (STEP == LEN)
    {
      RIGHT_SIDE += PATTERN;
    }
    else if (STEP > LEN)    // MUST ADD SPACES TO THE END
    {
      SPACES = new Array(STEP-LEN+1);
      SPACES = SPACES.join(PAD);
      RIGHT_SIDE = RIGHT_SIDE + SPACES + PATTERN;
    }
    else
    {
      // RIGHT_SIDE STRING HAS TO BE SPLIT AND PATTERN INSERTED
      POS = STEP;
      RIGHT_SIDE = RIGHT_SIDE.substr(0, POS) + PATTERN + RIGHT_SIDE.slice(POS);
    }
  }
  return LEFT_SIDE + RIGHT_SIDE;
}
//////////////////////////////////////////////////
//                                      v2021.3.28
// Trims number(s) by removing insignificant zeros
// and commas. If the input string contains text
// or other data, it leaves those intact.
// Only the numbers will be trimmed.
// Example: TrimNumber("-006,845.33300E+0010 and -0.00 and 008.900!") -> "-6845.333E+10 and 0 and 8.9!"
// Usage: STRING = TrimNumber(NUMBER_OR_STRING)
//
function TrimNumber(S)
{
  if (typeof(S) === "undefined" || S == null) return "";
  S += "";
  return S.replace(/([\-\+]?\.[0-9]+)/g,
    function(match, Number) { return RTRIM(Number, ".0"); })
  .replace(/([0-9]+)\.([^0-9]+)/g,
    function(match, Number, Etc) { return Number + Etc; })
  .replace(/[\-\+]+[0]+([^0-9,eE]+)/g,
    function(match, Etc) { return "0" + Etc; })
  .replace(/([\-\+]?)[0,]*([0-9.,]+)([Ee]?[\-\+]?)[0]*([0-9]+)/g,
    function(match, Sign, Number, E, Exp)
    { return (Sign + Number + E + Exp).split(",").join(""); });
}
//////////////////////////////////////////////////
//                                      v2021.3.31
// This function outputs an integer.
// Returns 0 if the input is null or undefined.
// If the number is NaN, still tries to extract
// a number if it can.
// Usage: INTEGER = MakeInteger(VALUE)
//
function MakeInteger(S)
{
  if (typeof(S) === "undefined" || S == null) return 0;

  if (isNaN(S))     // Try to extract a number
  {
    var i, c, DIGITS = 0, EXP = 0, DEC = 0, PAR = 0, DEC = 0, POS = 0, NEG = 0, N = [];
    for (i = 0; i < S.length; i++)
    {
      c = S.charCodeAt(i);
      if (c > 47 && c < 58)          // Number
        { DIGITS++; N[DEC] += S.charAt(i) + ""; }
      else if (c == 43)              // Plus sign : ALLOWED TWO MAX
        { if (POS++ < 2 && DIGITS && EXP) N.push("+"); }
      else if (c == 45)              // Minus sign : ALLOWED TWO MAX
        { if (NEG++ > 1 || (DIGITS && EXP == 0)) break; N.push("-"); }
      else if (c == 46)              // Decimal point: ALLOWED ONLY ONE
        { if (DEC++) break; }
      else if (c == 69 || c == 101)  // Letters E / e for exponent
        { if (DIGITS == 0 || EXP++) break; N.push("E"); }
      else if (c == 10 || c == 13)   // Line break : STOP
        { if (DIGITS) break; }
      else if (c == 40)              // Opening parentheses
        { if (NEG || DIGITS) break; NEG++; N.push("-"); }
      // Ignore comma, whitespace, and various other characters: # $ % = :
      else if (c == 44 || c == 32 || c == 9 || c == 35 || c == 36 || c == 37 || c == 58 || c == 61) {}
      else
        break;                       // Anything else is an illegal character
    }
    if (DIGITS == 0) return 0;
    if (EXP)
      S = N.join(".");
    else
      S = N[0];
    if (isNaN(S)) return 0;
  }
  S *= 1;
  var N = Math.floor(S);
  if (N == S) return N;
  return N;
  //return N + () (S < 0 ? 1 : 0);
}
//////////////////////////////////////////////////
//                                      v2021.5.12
// Returns 1 if the input string contains Unicode
// characters. Returns 0 if it only contains
// regular ASCII characters.
// Usage: INTEGER = isUnicode(STRING)
//
function isUnicode(s)
{
  for (var i = 0; i < s.length; i++)
    if (s.charCodeAt(i) & 0xFFFFFF00)
      return 1;
  return 0;
}
//////////////////////////////////////////////////
//                                      v2021.3.29
// Just like in C/C++, the sprintf() function prints
// formatted text to a string. The first argument
// must be a string which can contain embedded
// format specifiers that are replaced by the values
// specified in subsequent additional arguments...
//
// A format specifier follows this prototype:
// %[flags][length][.precision]specifier
//
// Specifiers:
//   d = signed decimal integer (from -999,999,999,999,999 to +999,999,999,999,999)
//   x = unsigned hexadecimal integer (lowercase)
//   X = Unsigned hexadecimal integer (uppercase)
//   u = unsigned decimal integer
//   o = unsigned octal
//   f = Decimal floating point
//   e = Scientific notation (lowercase)
//   E = Scientific notation (uppercase)
//   j = JSON
//   g = Use the shortest representation: %e or %f 392.65 
//   G = Use the shortest representation: %E or %F 392.65 
//   a = Hexadecimal floating point, lowercase -0xc.90fep-2 
//   A = Hexadecimal floating point, uppercase -0XC.90FEP-2 
//   c = Character a 
//   s = String of characters sample  %33s  - cut short to 33 bytes!
//   p = Pointer address b8000000 
//   n = Nothing printed
//   % followed by another % character will produce a single %
//
// Usage: STRING = sprintf(STRING, [VALUES...])
//
function sprintf(S)
{
  var v, i, v, a = 1;
  S += "";
  S = S.split("%");
  for (i = 1; i < S.length; i++)
  {
    if (S[i].length == 0) { S[i++] = "%"; continue; }
    if (a >= arguments.length) { S[i] = "%"; continue; }
    v = arguments[a++];
    S[i] = S[i].replace(/(^[0-9\-\+\#\. ]*)([diuoxXfFeEgGaAcspbn])/,
    function(match, f, c)
    {
      var force_sign = (f.indexOf("+") < 0) ? 0 : 1;
      var left_justify = (f.indexOf("-") < 0) ? 0 : 1;
      var force_decimal = (f.indexOf("#") < 0) ? 0 : 1;
      var pad_char = (f.charCodeAt(0) == 48) ? "0" : "";
      f = f.split(".");
//      if (v == "" || isNaN(v)) v = 0;
      if (typeof(v) === "undefined" || v == null) v = "";
      if (c == "n") v = "";
      else if (c == "s") v += "";
      else if (c == "c") v = (isNaN(v)) ? "" : String.fromCharCode(v & 65535);
      else if (v == "d") v = FIX(toDecimal(v));
      else if (v == "i") v = FIX(toDecimal(v));
      else if (v == "o") v = v.toString(8);
      else if (v == "e") v = v.toExponential();
      else if (v == "E") v = v.toExponential().toUpperCase();
      else if (v == "f") v = PadRight(toDecimal(v), 30, "0");
      else if (v == "b") v = v.toString(2);
      else if (v == "X") v = PadLeft(v.toString(16).toUpperCase(), 16, "0");
      else if (v == "x") v = PadLeft(v.toString(16), 16, "0");
      else if (v == "g") v = v + "";
      return v;
    });
  }
  return S.join("");
}
//////////////////////////////////////////////////
// This function can compress JavaScript code.
function MinifyJS(DATA)
{
  var OUTPUT = [];
  var ORIGINAL_SIZE = DATA.length;
  var WORD = 0;     // Are we reading a word?
  var NUMBER = 0;   // Are we reading a number?
  var STRING = 0;   // Are we reading a string?
  var COMMENT = 0;  // Are we reading a comment?
  var i, c = 0, prev;

  function OUT(c) { OUTPUT.push(String.fromCharCode(c)); }
  function BKSP() { if (OUTPUT.length) OUTPUT.pop(); }
  function next() { var Next = i + 1; return (DATA.length > Next) ? DATA.charCodeAt(Next) : 0; }

  for (i = 0; i < DATA.length; i++)
  {
    prev = c;
    c = DATA.charCodeAt(i);

    if (COMMENT == 1)      // Are we in a one-line comment?
    {
      if (c == 10 || c == 13)    // Wait until end of line
        COMMENT = 0;
      continue;
    }
    if (COMMENT == 2)      // Are we in a comment block?
    {
      if (prev == 42 && c == 47) // Wait for end marker: */
        COMMENT = 0;
      continue;
    }
    if (STRING)            // Are we in a string?
    {
      OUT(c);
      if (c == 92 && prev == 92)     // This counts as one backslash
      { c = 0; continue; }
      if (c == STRING && prev != 92) // Wait for closing quote
        STRING = 0;
      continue;
    }

    // Are we at the beginning of a string?
    if ((c == 34 || c == 39) && prev != 92)
    { OUT(c); STRING = c; continue; }

    // RegExp probably:
    if (c == 47 && prev == 92) { COMMENT = 0; OUT(c); c = 0; continue; }

    // One-line comment begins:
    if (c == 47 && prev == 47) { COMMENT = 1; BKSP(); continue; }

    // Comment block begins:
    if (c == 42 && prev == 47) { COMMENT = 2; BKSP(); continue; }

    // Are we reading a number?
    if (NUMBER)
    {
      if (prev == 48 && c == 120)   // Hexadecimal number?
      {
        OUT(c);
        continue;      // Just keep going
      }
      else if (!isDigit(c))
      {
        NUMBER = 0;
      }
    }
    else if (isDigit(c) && !isDigit(prev))
    {
      NUMBER = 1;
      OUT(c);
      continue;
    }

    // Are we reading a word?
    if (WORD)
    {
      if (isWordChar(c))
      {
        OUT(c);
        continue;
      }
      else               // End of word?
      {
// To collect function and variable names, save this:
// DATA.substring(WORD - 1, i)
        WORD = 0;
      }
    }
    else if (isWordInitial(c))
    {
      WORD = i + 1;
      OUT(c);
      continue;
    }

    // Whitespace:
    if (c < 33)
    {
      if (isWordChar(prev) && isWordChar(next())) OUT(c);
      continue;
    }
    else
    {
      OUT(c);
    }
  }
  return OUTPUT.join("");
}
//////////////////////////////////////////////////
// Returns 1 if a character might be the first
// letter of a variable or function name or keyword.
function isWordInitial(c)
{
  if (c == 36 || c == 95) return 1;
  if (c > 64 && c < 91) return 1;
  if (c > 96 && c < 123) return 1;
  return 0;
}
//////////////////////////////////////////////////
// Returns 1 if a character might be part
// of a variable or function name or keyword.
function isWordChar(c)
{
  if (c == 36 || c == 95) return 1;
  if (c > 64 && c < 91) return 1;
  if (c > 47 && c < 58) return 1;
  if (c > 96 && c < 123) return 1;
  return 0;
}
//////////////////////////////////////////////////
// Returns 1 if a character is a digit.
function isDigit(c)
{
  if (c > 47 && c < 58) return 1;
  return 0;
}
//////////////////////////////////////////////////
//                              String | v2021.4.7
// This function counts the number of words in a
// string and returns the integer.
// Usage: INTEGER = CountWords(S)
//
function CountWords(S)
{
  if (typeof(S) === "undefined" || S == null) return 0;
  S += "";
  var i, SPACE = 1, WORD_COUNT = 0, WORD_SEPARATOR = " \t\r\n_.,;:!?()[]{}<>+=/\\'`\"&|";
  for (i = 0; i < S.length; i++)
  {
    if (WORD_SEPARATOR.indexOf(S.charAt(i)) >= 0)
      SPACE = 1;
    else if (SPACE)
    {
      SPACE = 0;
      WORD_COUNT++;
    }
  }
  return WORD_COUNT;
}
//////////////////////////////////////////////////
//                                      v2021.3.24
// This function returns an array of 256 numbers
// each number indicating whether a certain character
// is present or absent in string S. For example,
// if the first input string contains the letter 'A' but
// does not contain any spaces, then output_array[65]
// will be 1, while output_array[32] will be zero.
// If a second string is provided, any characters
// present in the second string will set bit 2 of the
// output array. So, if the second string contains a
// letter 'A' as well, then output_array[65] will be 3.
// Since each number in JavaScript is a 32-bit int,
// using this function with more than 32 arguments
// won't provide accurate results.
// Usage: ARRAY = CharMap(STRING, [STRINGs...])
//
function CharMap()
{
  var a, i, S, MASK = 1, MAP = [];
  for (i = 0; i < 256; i++) MAP[i] = 0;
  for (a = 0; a < arguments.length; a++)
  {
    S = arguments[a] + "";
    for (i = 0; i < S.length; i++) MAP[S.charCodeAt(i)] |= MASK;
    MASK <<= 1;
  }
  return MAP;
}
//////////////////////////////////////////////////
//                                      v2021.5.12
// This function converts a string of Unicode
// characters to a plain ASCII string, replacing
// punctuation marks and converting everything else
// by simply stripping the high bits and leaving the
// low 8 bits only. If a second argument is given,
// then all Unicode characters except punctuation
// will be replaced with whatever value is given
// in the second argument. Note: Sometimes the
// return value will have more characters than the
// input string. Example: character 8230 becomes "..."
//
// Usage: STRING = toASCII(STRING, [REPLACE_WITH])
//
function toASCII(s, r)
{
  var i, c, REPLACE = 1;
  if (typeof(s) === "undefined" || s == null) return "";
  if (typeof(r) === "undefined" || r == null) REPLACE = 0; else r += "";
  s = (s + "").split("");
  for (i = 0; i < s.length; i++)
  {
    if ((c = s[i].charCodeAt(0)) & 0xFFFFFF00)
    {
      if (c == 1645) s[i] = "*";
      else if (c == 8204) s[i] = "|";
      else if (c == 8230) s[i] = "...";
      else if (c == 8215 || c == 59450) s[i] = "_";
      else if (c == 8722 || c == 8211 || c == 8212 || c == 8213) s[i] = "-";
      else if (c == 733 || c == 8243 || c == 8220 || c == 8221 || c == 8222) s[i] = '"';
      else if (c == 8242 || c == 61448 || c == 8216 || c == 8217 || c == 8218 || c == 8219) s[i] = "'";
      else s[i] = REPLACE ? r : String.fromCharCode(c & 255);
    }
  }
  return s.join("");
}
//////////////////////////////////////////////////
//
// This function strips html tags from a string
// and returns the text portion only.
// Usage: STRING = StripHTML(STRING)
function StripHTML(S)
{
  var i, c, SKIP = 0, OUTPUT = [];
  for (i = 0; i < S.length; i++)
  {
    c = S.charCodeAt(i);
    if (c == 60) SKIP = 1;
    if (SKIP == 0) OUTPUT.push(S.substr(i, 1));
    if (c == 62) SKIP = 0;
  }
  OUTPUT = OUTPUT.join("");
  OUTPUT = OUTPUT.replace(/\&nbsp;/g, " ");
  OUTPUT = OUTPUT.replace(/\&amp;/g, "&");
  OUTPUT = OUTPUT.replace(/\t/g, " ");
  OUTPUT = OUTPUT.replace(/  /g, " ");
  return OUTPUT;
}
//////////////////////////////////////////////////
//                             String | v2021.3.21
// This function extracts a section from string S
// that lies between string L and R. Returns an
// empty string if either L or R is not found.
// Usage: STRING = Between(STRING, LEFTSTR, RIGHTSTR, SKIP_COUNT)
//
function Between(S, L, R, SKIP)
{
  if (typeof(SKIP) === "undefined") SKIP = 1;
  var p1 = 0;
  for (var i = 0; i < SKIP; i++)
  {
    p1 = S.indexOf(L, p1);
    if (p1 < 0) return "";
    p1 += L.length;
  }
  var p2 = S.indexOf(R, p1);
  if (p2 <= p1) return "";
  return Trim(S.substring(p1, p2));
}
//////////////////////////////////////////////////
//                                      v2021.3.22
// This function removes a set of characters from the
// right side of a string.
// Usage: STRING = TrimChar(STRING, REMOVE)
//
function RTrimChar(S, R)
{
  if (typeof(S) == 'undefined' || S == null) return ''; S += '';
  if (typeof(R) == 'undefined' || R == null) return S; R += '';
  var P = S.length;
  while (P--)
    if (R.indexOf(S.substr(P, 1)) < 0)
      return S.substr(0, P + 1);
  return S;
}
//////////////////////////////////////////////////
//                                     v2020.12.12
// This function encodes a binary string and
// returns a new string that has the same length.
// A second argument (number) may be supplied
// which acts as a password. If no password is
// given, then the default password is 0.
// Usage: STRING = SimpleStringEncode(STRING, [X])
//
function SimpleStringEncode(STRING, X)
{
  if (typeof(X) === "undefined") X = 0;
  var i, c, r = 43, OUTPUT = [];
  for (i = 0; i < STRING.length; i++)
  {
    r = (r + i * 23 + X) & 65535;
    c = (STRING.charCodeAt(i) + r) & 255;
    OUTPUT[i] = String.fromCharCode(c);
  }
  return OUTPUT.join("");
}
//////////////////////////////////////////////////
//                                     v2020.12.12
// This function decodes a binary string and
// returns a new string that has the same length.
// A second argument (number) may be supplied
// which acts as a password. If no password is
// given, then the default password is 0.
// Usage: STRING = SimpleStringDecode(STRING, [X])
//
function SimpleStringDecode(STRING, X)
{
  if (typeof(X) === "undefined") X = 0;
  var i, c, r = 43, OUTPUT = [];
  for (i = 0; i < STRING.length; i++)
  {
    r = (r + i * 23 + x) & 65535;
    c = (STRING.charCodeAt(i) - r) & 255;
    OUTPUT[i] = String.fromCharCode(c);
  }
  return OUTPUT.join("");
}
//////////////////////////////////////////////////
//                                     v2020.12.12
// This function takes a binary string and turns it
// into a safe string that can be included enclosed
// between double quotes in JavaScript source code.
// Usage: STRING = toQuotedJSString(STRING)
//
function toQuotedJSString(BINARY, ESC)
{
  function Esc(BYTES) { if (LAST >= 0) OUTPUT.push(BINARY.substring(LAST, i)); OUTPUT.push(BYTES); LAST = -1; }

  var i, C, LAST = 0, OUTPUT = [];
  for (i = 0; i < BINARY.length; i++)
  {
    C = BINARY.charCodeAt(i);
         if (C == 92) Esc("\\\\");
    else if (C == 60) Esc("\\x3C");
    else if (C == 34) Esc('\\"');
    else if (C == 13) Esc("\\r");
    else if (C == 10) Esc("\\n");
    else if (C == 9)  Esc("\\t");
    else if (C < 7)   Esc("\\" + C);
    else if (C < 16)  Esc("\\x0" + C.toString(16));
    else if (C < 32 || C > 126) Esc("\\x" + C.toString(16));
    else if (LAST < 0) LAST = i;
  }
  Esc("");
  return OUTPUT.join("");
}
//////////////////////////////////////////////////
//                                     v2020.12.12
// This function takes a binary string and turns it
// into a HTML-safe string.
// Usage: STRING = toSafeHTML(STRING)
//
function toSafeHTML(S)
{
  var i, C, LAST = 0, $ = [];
  function Esc(BYTES) { if (LAST >= 0) $.push(S.substring(LAST, i)); $.push(BYTES); LAST = -1; }
  for (i = 0; i < S.length; i++)
  {
    C = S.charCodeAt(i);
         if (C == 38) Esc("&amp;");
    else if (C == 60) Esc("&lt;");
    else if (C == 62) Esc("&gt;");
    else if (C == 10) Esc("<BR>");
    else if (C == 9)  Esc(" &nbsp; &nbsp; ");
    else if (C == 13) continue;
    else if (C < 16 || C > 126)  Esc("&#x" + C.toString(16) + ";");
    else if (LAST < 0) LAST = i;
  }
  Esc("");
  return $.join("");
}
// SHORT VERSION:
// Converts any binary or HTML/JavaScript mix into HTML-safe string.
// function toSafeHTML(S) { var i, C, LAST = 0, $ = []; function Esc(BYTES) { if (LAST >= 0) $.push(S.substring(LAST, i)); $.push(BYTES); LAST = -1; } for (i = 0; i < S.length; i++) { C = S.charCodeAt(i); if (C == 38) Esc("&amp;"); else if (C == 60) Esc("&lt;"); else if (C == 62) Esc("&gt;"); else if (C == 10) Esc("<BR>"); else if (C == 9)  Esc(" &nbsp; &nbsp; "); else if (C == 13) continue; else if (C < 16 || C > 126)  Esc("&#x" + C.toString(16) + ";"); else if (LAST < 0) LAST = i; } Esc(""); return $.join(""); }
//
//////////////////////////////////////////////////////
//
// This function splits a string, stuffing digits and
// non-digits into alternating elements of an array.
//   Example:
// SplitNumbers("34DX5g") -> ["34", "DX", "5", "g"]
// SplitNumbers("-x39.4") -> ["-x", "39", ".", "4"]
//
function SplitNumbers(S)
{
  var A = [], p = 0, m = -1, i, d;
  for (i = 0; i < S.length; i++)
  {
    d = S.charCodeAt(i);
    d = d > 47 && d < 58;
    if (m == d) { A.push(S.substring(p, i)); p = i; }
    m = !d;
  }
  A.push(S.substring(p, i));
  return A;
}
//////////////////////////////////////////////////////
//
// This function extracts digits from a string and
// returns them in an array.
//   Example:
// SplitNumbers("34DX5g") -> ["34", "5"]
// SplitNumbers("-x39.4") -> ["39", "4"]
//
function GetNumbers(S)
{
  var A = [], p = -1, i, c;
  for (i = 0; i <= S.length; i++)
  {
    c = S.charCodeAt(i);
    if (c < 48 || c > 57)
    {
      if (p >= 0) A.push(S.substring(p, i));
      p = -1;
    }
    else if (p < 0) p = i;
  }
  return A;
}
//////////////////////////////////////////////////////
//
// This function extracts digits from strings and
// returns them in an array.
// Usage: ARRAY = GetNumberList(STRING, [STRING]...)
//   Example:
// GetNumberList("34DX5g", 55, "a41") -> ["34", "5", "55", "41"]
// GetNumberList("-x39.4") -> ["39", "4"]
//
function GetNumberList()
{
  var A = [], S, p = -1, i = 0, c;

  while (i < arguments.length)
    A.push(arguments[i++] + "/");
  S = A.join("");
  A = [];

  for (i = 0; i < S.length; i++)
  {
    c = S.charCodeAt(i);
    if (c < 48 || c > 57)
    {
      if (p >= 0) A.push(S.substring(p, i));
      p = -1;
    }
    else if (p < 0)
      p = i;
  }
  return A;
}
//////////////////////////////////////////////////
//                                     v2020.12.13
// This function inserts commas into the whole
// portion of a number to make it easier to read.
// Usage: STRING = FormatNumber(STRING_NUMBER, [STRING], [FREQUENCY])
//
function FormatNumber(N)
{
  N += "";
  var SEPARATOR = (arguments.length > 1) ? arguments[1] : ",";
  var FREQUENCY = (arguments.length > 2) ? arguments[2] : 3;

  // Extract sign (either positive or negative) and
  // find where the significant part of the number begins and ends.
  var i, j, x, C, SIGN = "";
  for (x = i = j = 0, i--; x < N.length; x++)
  {
    C = N.charCodeAt(x);
    if (C == 46 || (C > 48 && C < 58)) { if (i < 0) i = x; j = x + 1; }
    else if (C == 45) { if (i < 0) SIGN = "-"; }
    else if (C == 43) { if (i < 0) SIGN = "+"; }
  }
  N = N.slice(i, j);

  // Filter non-digits from the number and remember where
  // the whole portion of the number ends and the decimal portion begins.
  var DECIMAL = -1;
  var FILTERED = [];
  for (i = 0; i < N.length; i++)
  {
    C = N.charCodeAt(i);
    if (C > 47 && C < 58) FILTERED.push(N.charAt(i));
    else if (C == 46) { if (DECIMAL < 0) DECIMAL = FILTERED.length; FILTERED.push("."); }
  }
  i = (DECIMAL < 0) ? FILTERED.length : DECIMAL;

  // Add separators
  for (j = 0; i > 0; i--)
    if (j++ >= FREQUENCY)
    { FILTERED.splice(i, 0, SEPARATOR); j = 1; }
  return SIGN + FILTERED.join("");
}
//////////////////////////////////////////////////
function PadRight(S, L, C)
{
  if (typeof(S) === "undefined" || S == null) S = "";
  if (typeof(C) === "undefined") C = " ";
  S += "";
  if (S.length > L)
    return S.slice(0, S.length - L);
  while (S.length < L) S += C;
  return S;
}
//////////////////////////////////////////////////
function PadLeft(S, L, C)
{
  if (typeof(S) === "undefined" || S == null) S = "";
  if (typeof(C) === "undefined") C = " ";
  S += "";
  if (S.length > L)
    return S.slice(0, S.length - L);
  while (S.length < L) S = C + S;
  return S;
}
//////////////////////////////////////////////////////
//                                  String | v2022.1.1
// Same as the indexOf() function, but the pointers start at 1.
// integer = INSTR([start_offset], String1, String2)
//
function INSTR()
{
  var A = 0;
  var START = (arguments.length > 2) ? arguments[A++] - 1 : 0;
  var STR1 = arguments[A++];
  var STR2 = arguments[A++];
  return STR1.indexOf(STR2, START) + 1;
}
//////////////////////////////////////////////////////
//                                  String | v2022.1.1
// Same as the substr() function, but the pointers start at 1.
// NewString = MID$(String, Start, [Length])
//
function MID$(String, Start)
{
  var Len = (arguments.length > 2) ? arguments[2] : String.length;
  return String.substr(Start - 1, Len);
}
//////////////////////////////////////////////////////
//                                 String | v2023.2.26
// This function looks for the first occurrence of a
// character listed in CHARS in STRING and returns
// the index of the character OR returns -1 if not found.
//
// Usage: INDEX = CharIndex(STRING, CHARACTERS, [START])
//
function CharIndex(S, C, P)
{
  if (typeof(S) == 'undefined') return -1;
  if (typeof(C) == 'undefined') return -1;
  S += ''; if (S.length == 0) return -1;
  C += ''; if (C.length == 0) return -1;
  P |= 0; if (P >= S.length) return -1;
  if (C.length == 1) return S.indexOf(C, P);
  for (var i = 0; i < S.length; i++)
    if (C.indexOf(S.charAt(i), P) >= 0)
      return i;
  return -1;
}
//////////////////////////////////////////////////
//                              String | v2023.4.7
// This function changes a single character in a
// string and returns a new string, OR if only two
// arguments are used, it returns the character
// code at a given index. (A negative index refers
// to the end of string.)
//
function vec(STRING, INDEX, CHARCODE)
{
  if (typeof(STRING) === "undefined")
    STRING = "";
  else if (STRING == null)
    STRING = "";
  else
    STRING += "";
  if (typeof(INDEX) === "undefined")
    INDEX = 0;
  else if (isNaN(INDEX))
    INDEX = 0;
  else if (INDEX < 0)
    INDEX += STRING.length;
  if (arguments.length < 3)
    return (INDEX < 0 || INDEX >= STRING.length) ? 0 : STRING.charCodeAt(INDEX);
  var C = String.fromCharCode(CHARCODE & 255);
  if (INDEX < 0) return STRING;
  if (INDEX == 0) return C + STRING.slice(1);
  if (INDEX == STRING.length) return STRING + C;
  if (INDEX < STRING.length) return STRING.substr(0, INDEX) + C + STRING.slice(INDEX+1);
  return STRING + (new Array(INDEX - STRING.length+1)).join(" ") + C;
}
//////////////////////////////////////////////////
//                             String | v2021.7.20
// This function splits a string along words and
// returns an array of lines.
// Usage: ARRAY = WrapText(STRING, WIDTH)
function WrapText(T, WIDTH)
{
  if (typeof(T) === "undefined" || T == null) return [];
  WIDTH |= 0;
  var i, c, PREV_WORD = 0, CONTENT = -1, OUTPUT = [];
  T = T.replace(/\r\n/g, "\n");
  for (i = 0; i < T.length; i++)
  {
    c = T.charCodeAt(i);
    if (c == 13)
    {
      if (CONTENT >= 0)
      {
        OUTPUT.push(T.substring(CONTENT, i));
        CONTENT = -1;
      }
      OUTPUT.push("");
      PREV_WORD = i;
    }
    else if (c == 32 || c == 9)
    {
      if (CONTENT >= 0)
      {
        if (i - CONTENT == WIDTH)
        {
          OUTPUT.push(T.substring(CONTENT, i));
          CONTENT = -1;
        }
        else if (i - CONTENT > WIDTH)
        {
          OUTPUT.push(T.substring(CONTENT, PREV_WORD));
          CONTENT = PREV_WORD + 1;
        }
      }
      PREV_WORD = i;
    }
    else
    {
      if (CONTENT < 0) CONTENT = i;
    }
  }
  if (CONTENT) OUTPUT.push(T.slice(CONTENT));
  return OUTPUT;
}
//////////////////////////////////////////////////
//                             String | v2023.2.12
// This function splits a string into two parts
// along the first occurrence of substring.
// Returns the first part if CMD is 0x10.
// Returns the second part if CMD is 1.
// If substring is not found, returns the
// original string if CMD is 0x100.
// Ignores case when CMD is 0x1000.
// Starts searching from end of string when CMD is 0x10000.
//
// Usage: cut(STR, SUB, CMD)
//
function cut(STR, SUB, CMD)
{
  STR = (typeof(STR) == 'undefined' || STR == null) ? '' : STR + '';
  SUB = (typeof(SUB) == 'undefined' || SUB == null) ? '' : SUB + '';
  CMD = (typeof(CMD) == 'undefined') ? 0x111 : CMD | 0;
  var P = (CMD & 0x1000) ?
    ((CMD & 0x10000) ? STR.toUpperCase().lastIndexOf(SUB) : STR.toUpperCase().indexOf(SUB)) :
    ((CMD & 0x10000) ? STR.lastIndexOf(SUB) : STR.indexOf(SUB));
  if (P < 0) return (CMD & 256) ? STR : '';
  return (CMD & 16 ? STR.substr(0, P) : '') + (CMD & 1 ? STR.slice(P + SUB.length) : '');
}
// function strBefore(STR, SEP)    { return cut(STR, SEP, 0x10); }
// function strAfter(STR, SEP)     { return cut(STR, SEP, 0x01); }
// function strLeftBack(STR, SEP)  { return cut(STR, SEP, 0x10010);
// function strRightBack(STR, SEP) { return cut(STR, SEP, 0x10001);
//////////////////////////////////////////////////
//                                      v2021.4.30
// This function cuts a string along the first
// occurrence of any of the characters of CHARSET.
// The exact behavior of this function is controlled
// by CMD, which may contain the sum of these values:
//         0x1 = Returns the right side of the match
//         0x2 = Store the right side in $b
//        0x10 = Returns the matched character
//        0x20 = Store str pointer in $p and matched char in $c
//       0x100 = Returns the left side of the match
//       0x200 = Store the left side in $a
//      0x1000 = Returns the original string if no match
//     0x50000 = Starts searching from the end of string
//    0x100000 = Searching for non-occurrence of characters
//
// Usage: STRING = cutchr(STRING, CHARSET, CMD)
//
function cutchr(S, C, CMD)
{
  CMD |= 0;
  if (typeof(S) === "undefined" || S == null) S = ""; else S += "";
  if (typeof(C) === "undefined" || C == null) C = ""; else C += "";
  var i = -1, P = -1, L = S.length;
  if (C.length) {
    if (CMD & 0x50000) {
      if (CMD & 0x100000)
        while (L--) { if (C.indexOf(S.charAt(L)) < 0) { P = L; break; }}
      else
        while (L--) { if (C.indexOf(S.charAt(L)) >= 0) { P = L; break; }}}
    else {
      if (CMD & 0x100000)
        while (++i < L) { if (C.indexOf(S.charAt(i)) < 0) { P = i; break; }}
      else
        while (++i < L) { if (C.indexOf(S.charAt(i)) >= 0) { P = i; break; }}}}
  if (P < 0) {
    if (CMD & 2) $b = "";
    if (CMD & 32) { $c = ""; $p = -1; }
    if (CMD & 512) $a = "";
    return (CMD & 4096) ? S : ""; }
  if (CMD & 2) $b = S.slice(P + 1);
  if (CMD & 32) $c = S.charAt($p = P);
  if (CMD & 512) $a = S.substr(0, P);
  return (CMD & 256 ? (CMD & 512 ? $a : S.substr(0, P)) : '')
       + (CMD & 16 ? S.charAt(P) : '')
       + (CMD & 1 ? (CMD & 2 ? $b : S.slice(P + 1)) : '');
}
//////////////////////////////////////////////////
//                             String | v2021.3.15
// This is similar to the tr|||cd operator in Perl.
// This function removes all characters from STR
// that do not appear anywhere in CHARSET, forcing
// string to be only made up of the given characters.
// Example: tr("cabbage cake", " abc") --> "cabba ca"
// Usage: STRING = tr(STRING, LIST)
//
function tr(S, L)
{
  if (typeof(S) === 'undefined' || S == null) return ''; S += '';
  if (typeof(L) === 'undefined' || L == null) return ''; L += '';

  // This regex replace will run faster on MSIE and SeaMonkey web browsers.
  if (MSIE || SEAMONKEY)
    return S.replace(RegExp("[^" + L.replace(/([^a-zA-Z0-9])/g, "\\$1") + "]+", "g"), "");

  var c, i, X, OUTPUT = []; 
  for (i = X = 0; i < S.length; i++)
  {
    c = S.charAt(i);
    if (L.indexOf(c) >= 0)
      OUTPUT[X++] = c;
  }
  return OUTPUT.join('');
}
//////////////////////////////////////////////////
//                             String | v2023.2.12
// This function removes whitespace from the beginning
// and the end of a string, and returns a new string.
//
// Here "whitespace" is defined as any character
// whose ASCII value is less than 33. This includes
// tab, space, null, bel, esc, new line characters, etc.
//
// Usage: STRING = Trim(STRING)
//
function Trim(S)
{
  if (typeof(S) == 'undefined' || S == null) return '';
  S += '';
  var i = 0, L = S.length;
  while (S.charCodeAt(--L) < 33);
  while (i < L) if (S.charCodeAt(i) < 33) i++; else break;
  return S.substring(i, L + 1);
}
//////////////////////////////////////////////////
//                              String | v2023.4.7
// This function removes whitespace from the beginning
// and the end of a string using regex.
//
// Usage: STRING = TrimRE(STRING)
//
function TrimRE(S)
{
  if (typeof(S) == 'undefined' || S == null) return '';
  return (S + '').replace(/^[\x00-\x20]+|[\x00-\x20]+$/g, '');
}

//////////////////////////////////////////////////
//                             String | v2021.3.22
// This function is just like Trim() except it
// removes characters specified in SUBSTR.
// Usage: STRING = TrimChar(STRING, SUBSTR)
//
function TrimChar(STR, CHARLIST)
{
  STR += "";
  var L = STR.length, START = 0, LAST = 0;
  while (L--)
  {
    if (CHARLIST.indexOf(STR.substr(L, 1)) < 0)
    {
      START = L;
      if (LAST == 0) LAST = L + 1;
    }
  }
  return STR.substring(START, LAST);
}
//////////////////////////////////////////////////
//                             String | v2019.12.9
// Returns one or more words from a string.
// The string is treated as a list of words separated
// by whitespace. In this case, a "whitespace" is any
// character whose ASCII value is less than 33. This
// includes new line characters, tab, space, null, etc.
// PTR tells which word to grab starting with 1.
// If PTR is 3, the third word is returned.
// If PTR is not specified, the default value is 1.
// COUNT tells how many words to return. Default is 1.
// When COUNT has a negative value, returns every word
// from PTR all the way to the end of the string.
// The words in the return value will always be separated
// by a space character regardless of how many spaces or
// tabs were between them in the input string.
//
// Usage: STRING = GetWord(STRING, [PTR, [COUNT]])
//
function GetWord(S, PTR, COUNT)
{
  S += "";
  if (typeof(PTR) === "undefined") PTR = 1;
  if (typeof(COUNT) === "undefined") COUNT = 1;
  if (S.length == 0 || COUNT == 0 || PTR >= S.length)
    return "";
  if (PTR <= 0) PTR = 1;
  var i, START = -1, OUTPUT = [];
  for (i = 0; i <= S.length; i++)
  {
    if (S.charCodeAt(i) > 32)
    {
      if (START < 0) START = i;
      continue;
    }
    if (START >= 0)
    {
      if (PTR-- < 2)
      {
        OUTPUT.push(S.substring(START, i));
        if (COUNT-- == 1) break;
      }
      START = -1;
    }
  }
  return OUTPUT.join(" ");
}
//////////////////////////////////////////////////
//                             String | v2021.4.15
// This function takes a large block of text and
// looks up one line using a pointer. The pointer
// may point to any character of the line, and this
// function will grab the entire line and return it
// without any new line characters. If the pointer is
// pointing to a CR / LF character, the function will
// return the line right BEFORE it. This function
// correctly handles CR / LF / CR+LF / LF+CR line breaks.
// Usage: STRING = GetLine(STRING, INTEGER)
//
function GetLine(S, P)
{
  if (typeof(S) === "undefined" || S == null) return "";
  S += "";
  P |= 0;
  if (S.length == 0 || P < 0 || P >= S.length) return "";
  var START, END = P, i, c, k;
  for (; END < S.length; END++)      // Find the end of the line
  {
    c = S.charCodeAt(END);
    if (c == 10 || c == 13) break;
  }
  if (P == 0)
    return S.substr(0, END);
  c = S.charCodeAt(P);               // Check if P is pointing to a new line character
  if (c == 10 || c == 13)
  {
    k = S.charCodeAt(--P);           // Adjust START pointer
    if (k == 10 || k == 13)          // It might be CR+LF or LF+CR
      if (k != c && P)
        { P--; END--; }              // Adjust START+END pointers
  }
  for (; P >= 0; P--)                // Find beginning of line
  {
    c = S.charCodeAt(P);
    if (c == 10 || c == 13) break;
  }
  return S.substring(P + 1, END);
}
//////////////////////////////////////////////////
//                                     v2020.12.26
// This function escapes a string using a custom
// character set. The first character of CHARSET
// will be used as an escape character. The rest
// of the characters specify which characters
// should not be escaped. Everything else
// will be escaped.
//
// Usage: STRING = EscapeString(STRING, CHARSET)
//
function EscapeString(STR, SET)
{
  var i, c, P, $ = [];
  for (i = 0; i < STR.length; i++)
  {
    c = STR.charAt(i);
    P = SET.indexOf(c, 1);
    if (P >= 0) { $[i] = c; continue; }
    c = STR.charCodeAt(i);
    c = (c < 16 ? "0" : "") + c.toString(16);
    $[i] = SET.charAt(0) + c;
  }
  return $.join("");
}
// SHORT VERSION:
// Escapes a string using a custom character set. The first character of CHARSET will be used as an escape character. The rest of the characters will not be escaped.
// function EscapeString(STR, SET) { var i, c, P, $ = []; for (i = 0; i < STR.length; i++) { c = STR.charAt(i); P = SET.indexOf(c, 1); if (P >= 0) { $[i] = c; continue; } c = STR.charCodeAt(i); c = (c < 16 ? "0" : "") + c.toString(16); $[i] = SET.charAt(0) + c; } return $.join(""); }
//
//////////////////////////////////////////////////
//                                     v2020.12.26
// This function is the reverse of EscapeString()
//
// Usage: STRING = UnescapeString(STRING, CHARSET)
//
function UnescapeString(STR, SET)
{
  STR = STR.split("%").join("%25");
  STR = STR.split(SET.charAt(0)).join("%");
  return unescape(STR);
}
// SHORT VERSION:
// This function is the reverse of EscapeString()
// function UnescapeString(STR, SET) { STR = STR.split("%").join("%25"); STR = STR.split(SET.charAt(0)).join("%"); return unescape(STR); }
//

//////////////////////////////////////////////////
//
//
//               ARRAY FUNCTIONS
//
//

// This function swaps two elements of array A.
function Swap(A, x, y) { var T = A[x]; A[x] = A[y]; A[y] = T; }

// This function extracts elements of small array B from big array A. This function reduces the size of array A.
function ExtractFrom(A, B) { var i, j; for (i = 0; i < A.length; i++) for (j = 0; j < B.length; j++) if (A[i] == B[j]) { A[i] = ""; break; } }

// This function looks for string S in array A and returns the index where it is found. The scan is non-case sensitive.
function FindInArray(S, A) { S = S.toUpperCase(); for (var i = 0; i < A.length; i++) if (A[i].toUpperCase().indexOf(S) >= 0) return i; return -1; }

// This function returns a new array full of zeros. A second argument may be provided to initialize the array with something other than zeros.
function InitArray(SIZE) { var i, A = new Array(SIZE), InitValue = (arguments.length > 1) ? arguments[1] : 0; for (i = 0; i < SIZE; i++) A[i] = InitValue; return A; }

// This function returns the length of the longest string in an array.
function LongestWordIn(A) { var L = 0, X, i = A.length; while(i--) { X = (A[i]).toString().length; if (X > L) L = X; } return L; }

// This function returns the length of the shortest string in an array.
function ShortestWordIn(A) { var L = 0x7FFFFFFF, X, i = A.length; while(i--) { X = (A[i]).toString().length; if (L > X) L = X; } return L; }

// This function copies elements of array B into array A without creating more duplicates. This function runs a case-sensitive search and does not sort the contents of either arrays.
function MergeArray(A, B) { var i, j, N = 0; for (i = 0; i < B.length; i++) { for (j = 0; j < A.length; j++) if (A[j] == B[i]) { j = -1; break; } if (j >= 0) { A.push(B[i]); N++; } } return N; }

// This function returns part of an array and reduces the length of the original array. It works just like the slice() method on strings, but this operates on arrays only. This function will change the size of array A.
function ArraySlice(A, X) { var R = []; if (X < 0) X += A.length; if (X < 0 || X > A.length) return R; for (var i = X; i < A.length; i++) R.push(A[i]); A.length = X; return R; }

// This function converts a string to an array of ASCII character codes.
function charCodeArray(S) { var i, A = []; for (i = 0; i < S.length; i++) A[i] = S.charCodeAt(i); return A; }

// This function assembles a string from an array of ASCII character codes. It's the opposite of charCodeArray() with one important difference: 16-bit and 32-bit numbers are converted into multiple bytes. For example, 0x20 becomes a space character. But 0x4020 becomes a "@" followed by a space character! And 0x41424344 becomes a string "ABCD". Now, this function won't know the size of the desired output if the input array holds just one zero. It can't tell whether that stands for 2 zero bytes or just one or four, because there's no difference between 0x00 and 0x0000. So, in that case, it will assume that Zero stands for just one byte. For example, this works: STRING = fromCharCodeArray( [0x33, 0x00414243, 0x204748, 0x20, 0x49] ); -- zero character becomes omitted.
function fromCharCodeArray(ARRAY) { var i, N, S = []; for (i = 0; i < ARRAY.length; i++) { N = ARRAY[i]; if (N <= 0xff) S[i] = String.fromCharCode(N); else if (N <= 0xffff)   S[i] = String.fromCharCode((N>> 8) & 0xff) + "" + String.fromCharCode(N & 0xff); else if (N <= 0xffffff) S[i] = String.fromCharCode((N >> 16) & 0xff) + "" + String.fromCharCode((N >> 8) & 0xff) + "" + String.fromCharCode(N & 0xff); else S[i] = String.fromCharCode((N >> 24) & 0xff) + "" + String.fromCharCode((N >> 16) & 0xff) + "" + String.fromCharCode((N >> 8) & 0xff) + "" + String.fromCharCode(N & 0xff); } return S.join(""); }

// This function trims each element of array A and removes empty strings elements. This function shortens the original array.
function RemoveBlank(A) { var L, i, j = 0; for (i = 0; i < A.length; i++) { L = Trim(A[i]); if (L.length) { if (j < i) A[j] = L; j++; } } A.length = j; }

// QSort algorithm written in JavaScript. I took this code from a QBasic program written by Ethan Winer and translated it to JavaScript. In Chrome and Safari, qsort runs 2X faster than the builtin sort() method. In KMeleon, qsort is 8X faster! The only browsers where qsort is actually slower is QupZilla and Internet Explorer. In QupZilla, the difference is barely noticeable, however in IE6, the old sort() method is 6X faster. Most people, however, don't use IE6 anymore, so I think, we can ignore that. Example : SortArrays(AGE, NAME, HEIGHT, SCORE) would rearrange all four arrays by age.
function SortArrays(A) { var i, j, k, m, x, Q = [], First = 0, Last = A.length - 1; for (;;) { do { m = A[((First+Last)/2)|0]; i = First; j = Last; do { while (A[i] < m) i++; while (A[j] > m) j--; if (i > j) break; if (i < j) { for (k = 0; k < arguments.length; k++) { x = arguments[k][i]; arguments[k][i] = arguments[k][j]; arguments[k][j] = x; } } i++; j--; } while (i <= j); if (i < Last) { Q.push(i); Q.push(Last); } Last = j; } while (First < Last); if (Q.length == 0) break; Last = Q.pop(); First = Q.pop(); } }

// This function is designed to sort a two-dimensional array. ROW tells which row to sort by. This function rearranges the contents of ARRAY.
function SortBy(ARRAY, ROW) { function COMPARE(A, B) { if (isNaN(A[ROW]) || isNaN(B[ROW])) { if (A[ROW] > B[ROW]) return 1; if (A[ROW] < B[ROW]) return -1; return 0; } return A[ROW] - B[ROW]; } ARRAY = ARRAY.sort(COMPARE); }

//////////////////////////////////////////////////
//                              Array | v2023.3.13
// Updates the value of the Nth array element.
// Usage: SetValueOf(ARRAY, N, VALUE)
//
function SetValueOf(A, N, V)
{
  if (typeof(A) != 'object') return;
  if (typeof(N) == 'undefined' || isNaN(N)) return;
  if (typeof(V) == 'undefined' || V == null) V = '';
  while (A.length < N) A.push('');
  A[N] = V;
}
//////////////////////////////////////////////////
//                              Array | v2023.2.28
// This function returns the Nth element of an array,
// or if the array does not have an Nth element,
// then returns the DEFAULT value. If a default value
// is not specified, then an empty string is used
// as the default value.
//
function GetValueOf(ARRAY, PTR, DEFAULT)
{
  if (typeof(DEFAULT) == 'undefined') DEFAULT = '';
  if (typeof(ARRAY) != 'object') return DEFAULT;
  return (PTR < 0) ? DEFAULT : (PTR < ARRAY.length ? ARRAY[PTR] : DEFAULT);
}
//////////////////////////////////////////////////
//                                      v2021.4.22
// Sorts an array of strings by length,
// rearranging the contents of the original array.
// Undefined values are treated as empty strings.
// Usage: SortByLength(ARRAY)
//
function SortByLength(ARRAY)
{
  ARRAY.sort(function(A, B)
  {
    return ((typeof(A) === "undefined" || A == null) ? 0 : (A + "").length)
         - ((typeof(B) === "undefined" || B == null) ? 0 : (B + "").length);
  });
}

//////////////////////////////////////////////////
//
// Returns the last element of an array without
// modifying the array. If the array has no
// elements, then returns DEFAULT if specified, or
// returns an empty string when DEFAULT is not provided.
// Usage: VALUE = LastElementOf(ARRAY, [DEFAULT])
//
function LastElementOf(A, DEFAULT)
{
  if (A.length == 0) return (typeof(DEFAULT) === "undefined") ? "" : DEFAULT;
  return A[A.length - 1];
}
//////////////////////////////////////////////////
//                             Array | v2019.12.27
// This function splits string S into N-byte sized
// chunks and returns an array. If a third argument
// is given, it will use as padding. The padding must
// be either one byte or two bytes. If it is one byte,
// it will be added in front of the last group.
// If it is two bytes, the second byte will be added
// at the end of the last group.
// Usage: ARRAY = Group(STRING, LENGTH, [PADDING])
// Example: Group('abcd', 3)     -> ['abc', 'd']
//          Group('abcd', 3, '-') -> ['abc', '--d']
//          Group('abcd', 3, ' -') -> ['abc', 'd--']
//
function Group(S, N, PADDING)
{
  var i, j = -1, A = [];
  if (S.length == 0) return A;
  for (i = 0; i < S.length; i += N)
    A[++j] = S.substr(i, N);
  if (typeof(PADDING) === "string")
  {
    if (PADDING.length == 1)
      while (A[j].length < N)
        A[j] = "" + PADDING + A[j];
    if (PADDING.length == 2)
      while (A[j].length < N)
        A[j] += "" + PADDING.charAt(1);
  }
  return A;
}
//////////////////////////////////////////////////
//                              Array | v2021.3.26
// This function sorts array A and removes duplicate
// elements, changing the size of the original array!
// Returns the number of duplicates removed.
// Usage: INTEGER = RemoveDuplicates(ARRAY)
//
// NOTE: This function has not been fully tested yet!!!
//
function RemoveDuplicates(A)
{
  A.sort();
  var LINE, i, j = 0, prev = "", ORIGINAL_LENGTH = A.length;
  for (i = 0; i < A.length; i++)
  {
    LINE = Trim(A[i]);
    if (LINE == prev)
      LINE = "";
    else
      prev = LINE;
    if (LINE.length)
      { if (j < i) A[j] = LINE; j++; }
  }
  A.length = j;
  return ORIGINAL_LENGTH - j;
}
//////////////////////////////////////////////////
//                               Array | v2021.4.7
// This function sorts an array of strings and returns
// an array of pointers that reflect how the array
// should be rearranged to make it sorted.
// Uses the bubble sort algorithm.
// Usage: ARRAY = SortStr(ARRAY)
//
function SortStr(A)
{
  var i, j, N, PTR = [];
  for (i = 0; i < A.length; i++)
  {
    PTR[i] = i;
    if (typeof(A[i]) === "undefined" || A[i] == null)
      A[i] = "";
    else
      A[i] += "";
  }
  for (i = 0; i < A.length; i++)
    for (j = i; j < A.length; j++)
      if (A[PTR[i]] > A[PTR[j]])
        { N = PTR[i]; PTR[i] = PTR[j]; PTR[j] = N; }
  return PTR;
}
//////////////////////////////////////////////////
//                               Array | v2021.4.6
// This function takes an array of pointers and
// rearranges the elements of other array(s)
// using the pointer table. This function has
// no return value; it directly modifies the
// arrays that are passed as arguments! This function
// should be used after the SortStr() function.
//
// Usage: RearrangeArray(PATTERN, ARRAY, [ARRAY...])
//
function RearrangeArray(PATTERN)
{
  if (typeof(PATTERN) != "object") return;
  var i, x, A = arguments.length;
  while (A-- > 1)
  {
    var TEMP = [], SAVED = [], ARRAY = arguments[A];
    if (typeof(ARRAY) != "object" || ARRAY.length == 0) continue;
    for (i = 0; i < PATTERN.length; i++)
    {
      x = PATTERN[i];
      if (i == x) continue;
      TEMP[i] = ARRAY[i];
      SAVED[i] = 1;
      ARRAY[i] = SAVED[x] ? TEMP[x] : ARRAY[x];
    }
    ARRAY.length = PATTERN.length;
  }
}

//////////////////////////////////////////////////
//
//
//           BITWISE ROTATE FUNCTIONS
//
//

// This function perform bitwise rotate of a byte by N bits.
// If N is a positive number, it rotates right by N bits.
// If N is a negative number, it rotates left by N bits.
function ROL8(C,N){if(N&=7){var M=[,127,63,31,15,7,3,1][N];C=((C&M)<<N)|((C&255)>>(8-N));}return C&255;}

// This function rotates byte C to the RIGHT by N number of bits.
function ROR8(C,N){return ROL8(C,8-N);}

// This function performs bitwise rotate right on a 16-bit word.
function ROR16(WORD, N) { N &= 15; if (N == 0) return (WORD & 0xFFFF); var MASK = [0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF]; var BITS = WORD & MASK[N]; BITS <<= (16 - N); WORD >>>= N; return WORD + BITS; }

// This function performs bitwise rotate right on a 32-bit long.
function ROR32(LONG, N) { N &= 31; if (N == 0) return (LONG & 0xFFFFFFFF); var MASK = [0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF, 0x1FFFF, 0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF, 0x7FFFFF, 0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF, 0xFFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF]; var BITS = LONG & MASK[N]; BITS <<= (32 - N); LONG >>>= N; return LONG + BITS; }

// This function performs bitwise rotate on a string segment
// marked by StartBit and EndBit. Rotates to the right by N bits.
function RORS(S, N, StartBit, EndBit) { var LEFT = (N < 0) ? 0 : 1; if (StartBit >= EndBit) return S; N = Math.abs(N) % (EndBit - StartBit); if (N == 0) return S; var B = Str2Bin(S); if (EndBit > B.length) return ""; var UNCH1 = B.substr(0, StartBit); var UNCH2 = B.slice(EndBit); B = B.substring(StartBit, EndBit); if (LEFT) N = B.length - N; var PART1 = B.substr(0, N); var PART2 = B.slice(N); return Bin2Str(UNCH1 + PART2 + PART1 + UNCH2); }

//////////////////////////////////////////////////
//
//
//          BINARY ARRAY I/O FUNCTIONS
//
//

// Each 32-bit integer in an array can hold 4 bytes of data.
// For example, we could store the word "GOLDSTAR" in an array of 2 elements.

// This function reads one bit from an array of 32-bit integers.
function ReadBIT(ARRAY, BIT_INDEX) { var LONG = ARRAY[BIT_INDEX >> 5]; var X = BIT_INDEX & 31; if (X) LONG >>>= X; return LONG & 1; }

// This function returns one byte-size int from an array of 32-bit integers.
function ReadBYTE(ARRAY, BYTE_INDEX) { var SHIFT = [0, 8, 16, 24]; var LONG = ARRAY[BYTE_INDEX >> 2]; var X = BYTE_INDEX & 3; if (X) LONG >>>= SHIFT[X]; return LONG & 255; }

// This function overwrites one bit in an array of 32-bit integers.
function WriteBIT(ARRAY, BIT_INDEX, BIT) { BIT &= 1; var INDEX = BIT_INDEX >> 5; var LONG = ARRAY[INDEX]; var MASK = 1 << (BIT_INDEX & 31); if (BIT) LONG |= MASK; else LONG &= (~MASK); ARRAY[INDEX] = LONG; }

// This function writes one byte (int) to an array of 32-bit integers.
function WriteBYTE(ARRAY, BYTE_INDEX, BYTE) { BYTE &= 255; var INDEX = BYTE_INDEX >> 2; var LONG = ARRAY[INDEX]; var MASK = [0xFFFFFF00, 0xFFFF00FF, 0xFF00FFFF, 0x00FFFFFF]; var X = BYTE_INDEX & 3; if (X) BYTE <<= (X << 3); LONG &= MASK[X]; LONG += BYTE; ARRAY[INDEX] = LONG; }

// This function writes a word (int) to an array of 32-bit integers.
function WriteWORD(ARRAY, WORD_INDEX, WORD) { WORD &= 0xFFFF; var MASK = [0xFFFF0000, 0x0000FFFF]; var INDEX = WORD_INDEX >> 1; var LONG = ARRAY[INDEX]; var X = WORD_INDEX & 1; if (X) WORD <<= 16; LONG &= MASK[X]; LONG += WORD; ARRAY[INDEX] = LONG; }

// This function writes a string into an array of 32-bit integers. See Also: fromCharCodeArray()
function WriteSTRING(ARRAY, BYTE_INDEX, STRING) { var i, C; for (i = 0; i < STRING.length; i++) { C = STRING.charCodeAt(i) & 255; WriteBYTE(ARRAY, BYTE_INDEX++, C); } }


//////////////////////////////////////////////////

// Initializes document and location objects for scripting context.
TYPE = "";
if (typeof(window) == 'undefined') { window = { screen:"" }; }
if (typeof(navigator) == 'undefined') { navigator = { userAgent:'JS' }; }
if (typeof(document) == 'undefined')
{
  location = { top:WScript.ScriptFullName, href:WScript.ScriptFullName };
  document = { cookie:"", title:"", write:function(S) { WScript.Echo(S); } };
}


// FAST STRING MANIPULATION
//
//   It is very important to write fast code, and benchmark
//   tests have shown that calling a function that is a
//   prototype takes 2-3 times longer on average than
//   calling just a regular function.
//
//   Calling private functions do not make the script
//   run slower, but using prototypes significantly
//   lowers the performance of our scripts.

// GLOBAL DECLARATIONS

ß            = "<>@#$&%`^+~,";
B64SET       = ABC + NUM + "/+";
MOSTUSED     = "etaoinsrhdlucmfywgpbvkxq" + HEX + "TOINSRHLUMWGPzjYVKXQJZ";
SHELLSET     = "./" + MOSTUSED + "*_-!?:[]{}()";
COOKIEJAR    = "|" + SHELLSET + ß + "'\"\\";
FREQSET      = " " + COOKIEJAR + "=;\r\n\t\x1B\0\x80\xFF\xAA\xCC";
SQUOTE       = SHELLSET + ß + ' =;"|';
DQUOTE       = SHELLSET + ß + " =;'|";
URLSET       = B64SET + "@*-._";
ALLCHARS     = CharRange(0, 255, 1);   // DO NOT CHANGE THIS LINE! This function creates an array of characters from 0 to 255.

CX = [512,0,0,0,0,0,0,0,0,520,520,0,512,520,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,632,9464,1192,1272,1257,1272,1264,1240,9464,9464,13560,7416,1272,13560,13560,15608,14840,14840,14840,14840,14840,14840,14840,14840,14840,14840,9464,1144,1264,1144,1264,9464,1256,47613,31229,31229,31229,47613,31229,30973,30973,47357,30973,30973,30973,30973,30973,47357,30973,30973,30973,30973,30973,47357,30973,30973,30973,30973,30973,9464,1160,9464,1272,9465,1272,47611,31227,31227,31227,47611,31227,30971,30971,47355,30971,30971,30971,30971,30971,47355,30971,30971,30971,30971,30971,47355,31483,30971,30971,30971,30971,9464,1272,9464,1272,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,5,5,5,5,5,5,1,1,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,1,3,3,3,3,3,3,1,3,3,3,3,3,3,0,3];


// MULTI-ENVIRONMENT FUNCTIONS


SplitURL(location.href);

// GET JAVASCRIPT ARGUMENTS
ARGJ = "";
if (BROWSER)
{
  Z = "zlib.js?"; i = document.scripts.length;
  while (i--) { S = document.scripts[i].src; P = S.indexOf(Z); if (P >= 0) { ARGJ = S.slice(P + Z.length + 1); break; } }
}

// This function converts fixed size to relative size depending on current screen resolution.
function SIZE(N) { return Math.round(WX * N / 500); }



// This function removes duplicate items from an array and returns a new array containing the items that have been removed. The scan is case sensitive. This function also sorts the array.
//function ExtractDuplicates(A) { if (A.length < 2) return 0; A.sort(); var i = 0, j = 1, D = []; while (j < A.length) { if (A[i] == A[j]) { A.splice(j, 1); D.push(A[i]); } else { i++; j++; } } return D; }

// This function returns the first matching index
// where A[index] is an exact match with string S.
// LookUp() is case-sensitive: will treat upper/lower case letters differently
// LOOKUP() is non-case-sensitive: will match upper/lower case letters
function LookUp(S, A) { S = S + ""; for (var i = 0; i < A.length; i++) if (S == A[i]) return i; return -1; }
function LOOKUP(S, A) { S = S.toUpperCase(); for (var i = 0; i < A.length; i++) if (S == A[i].toUpperCase()) return i; return -1; }

//////////////////////////////////////////////////




RNDTXT = "i8Dr0Rl1o9mqGsMeZ_PuLzBp2cNb6S4UfwWOIatHEhxVAdF5XyCJnKY7@vQkg3jT";

//////////////////////////////////////////////////
//                                       v2021.1.6
// This function takes a list of 1s and 0s
// and returns a B64-encoded string.
// Usage: STRING = Bin2B64(STRING)
//
function Bin2B64(BIN)
{
  BIN += "";
  while (BIN.length % 6) BIN += "0";
  var i, c, MASK = 32, BYTE = 0, $ = [];
  for (i = 0; i < BIN.length; i++)
  {
    c = BIN.charCodeAt(i);
    if (c == 48) MASK >>= 1;
    if (c == 49) { BYTE += MASK; MASK >>= 1; }
    if (MASK == 0)
    {
      $.push(RNDTXT.charAt(BYTE));
      MASK = 32;
      BYTE = 0;
    }
  }
  return $.join("");
}
// SHORT VERSION:
// Converts a string of 1s and 0s to a B64-encoded string.
// function Bin2B64(BIN) { BIN += ""; while (BIN.length % 6) BIN += "0"; var i, c, MASK = 32, BYTE = 0, $ = []; for (i = 0; i < BIN.length; i++) { c = BIN.charCodeAt(i); if (c == 48) MASK >>= 1; if (c == 49) { BYTE += MASK; MASK >>= 1; } if (MASK == 0) { $.push(RNDTXT.charAt(BYTE)); MASK = 32; BYTE = 0; } } return $.join(""); }
//
//////////////////////////////////////////////////
//                                       v2021.1.6
// This function takes a B64-encoded string and
// converts it to a string of 1s and 0s.
// Usage: STRING = B642Bin(STRING)
//
function B642Bin(B64)
{
  var i, c, $ = [];
  for (i = 0; i < B64.length; i++)
  {
    c = RNDTXT.indexOf(B64.charAt(i));
    if (c < 0) c = 0;
    c = c.toString(2);
    while (c.length < 6) c = "0" + c;
    $.push(c);
  }
  return $.join("");
}
// SHORT VERSION:
// Converts a B64-encoded string to a string of 1s and 0s.
// function B642Bin(B64) { var i, c, $ = []; for (i = 0; i < B64.length; i++) { c = RNDTXT.indexOf(B64.charAt(i)); if (c < 0) c = 0; c = c.toString(2); while (c.length < 6) c = "0" + c; $.push(c); } return $.join(""); }
//
//////////////////////////////////////////////////

//////////////////////////////////////////////////
//                                      v2021.2.10
// This function displays an alert message box.
// Anything between {} brackets will be evaluated
// first and then printed.
//
// Usage: Alert(STRINGS...)
//
function Alert()
{
  if (typeof(SILENT) != "undefined") return;
  var i, L = arguments.length, OUTPUT = [];
  for (i = 0; i < L; i++) OUTPUT[i] = arguments[i];
  OUTPUT = OUTPUT.join("").split("{");
  for (i = 1; i < OUTPUT.length; i++)
  {
    P = OUTPUT[i].indexOf("}");
    if (P >= 0) OUTPUT[i] = eval(OUTPUT[i].substr(0, P)) + OUTPUT[i].slice(P + 1);
  }
  alert(OUTPUT.join(""));
}



// This function overwrites a part of string S with character C at byte position X and returns a new string. Example: vec("ABCDEF", 2, 42) --> "AB*DEF"
//function vec(S, X, C) { X |= 0; S += ""; if (X < 0) return S; C = String.fromCharCode(C & 255); if (X == 0) return C + S.slice(1); if (X < S.length) return S.substr(0, X) + "" + C + S.slice(X+1); while (S.length < X) S += " "; return S + "" + C; }


// Adds padding characters C to string S on the left. Returns a string that is exactly L bytes long.
function _LEFT(S, C, L) {S=S.toString();if(S.length>L)return S.slice(S.length-L);while(S.length<L)S=C.charAt(0)+S;return S;}

// Adds padding characters C to string S on the right. Returns a string that is exactly L bytes long.

function _RIGHT(S, C, L) {S=S.toString();if(S.length>L)return S.slice(S.length-L);while(S.length<L)S+=C.charAt(0);return S;}

//////////////////////////////////////////////////
//                                      v2021.3.28
// This function outputs a string. If the input is
// undefined or null, returns an empty string.
// Usage: STRING = MakeString(VALUE)
//
function MakeString(S)
{
  if (typeof(S) === "undefined") return "";
  return (S == null) ? "" : S + "";
}
//////////////////////////////////////////////////
//                                      v2021.3.26
// This function returns a part of a string that
// occurs between two strings. It does that by
// finding the Nth occurrence the first string.
// Then it looks for the closest second string,
// and whatever is between the two will be returned.
// Whatever is outside the two will be stored
// in $a and $b. If either of the two strings is
// not found, then returns an empty string!
//
// The CMD argument controls several things:
// The lower 12 bits of CMD are called N.
// CMD 0x1000 = Convert string to upper case temporarily.
// CMD 0x10000 = Search for the Nth occurrence of
// RIGHT_STR starting from the end of string!
// (If CMD is omitted, then just searches for the
// first occurrence of LEFT_STR from the beginning.)
//
// Usage: STRING = Between2(STRING, LEFT_STR, RIGHT_STR, [CMD])
//
function Between2(STR, LEFT_STR, RIGHT_STR, CMD)
{
  STR += "";
  $a = $b = "";
  if (typeof(N) === "undefined") CMD = 1;
  var START = 0, END = STR.length, N = CMD & 0xFFF;
  if (CMD & 0x1000) STR = STR.toUpperCase();
  if (CMD & 0x10000)
  {
    while (N--)         // Search from the end of string
    {
      END = STR.lastIndexOf(RIGHT_STR, END);
      if (END < 0) return "";
    }
    $b = STR.slice(END + RIGHT_STR.length);
    START = STR.lastIndexOf(LEFT_STR, END);
    if (START < 0) return "";
    $a = STR.substr(0, START);
  }
  else
  {
    while (N--)         // Search from the beginning of string
    {
      START = STR.indexOf(LEFT_STR, START);
      if (START < 0) return "";
      START += LEFT_STR.length;
    }
    $a = STR.substr(0, START - LEFT_STR.length);
    END = STR.indexOf(RIGHT_STR, START);
    if (END <= START) return "";
    $b = STR.slice(END);
  }
  return Trim(STR.substring(START, END));
}

// THIS REVISED FUNCTION HAS NOT BEEN FULLY TESTED YET!!!!

//////////////////////////////////////////////////

// This function encrypts or decrypts a string using a random number series generated with the seed provided. The SEED acts as a password.
function RndXOR(STRING, SEED) { var i, $ = []; if (typeof(SEED) === "undefined") SEED = 39.7287167553; SEED += STRING.length; for (i = 0; i < STRING.length; i++) { SEED = (SEED * 1882.03 + 3917.485 + i) % 5931; $[i] = String.fromCharCode(STRING.charCodeAt(i) ^ (SEED & 255)); } return $.join(""); }

//////////////////////////////////////////////////
//                                     v2020.12.26
// This function encrypts a cookie name to hide it
// from plain sight. The resulting name will not
// collide with other names when stored in a
// database. Both the input and the output shall
// be made up of the following characters only:
// 0-9 A-Z a-z $ and _
// If the input contains any special characters,
// they will be replaced with an _ character when
// decrypted. Since the encryption uses a builtin
// password with the XOR operator, it can be
// easily reversed with the same function.
//
// Usage: STRING = XORName(STRING)
//
function XORName(S)
{
  var $ = [], i = S.length, A = "8ODpmr0l1o9qGMRsNeZP_uLzB2cb6S4UfjwWIatHh$ExVAdFCQ5XyJnKY7vkg3iT";
  while (i--)
    $[i] = A.charAt(((A.indexOf(S.charAt(i)) & 63) ^ A.charCodeAt(i & 63)) & 63);
  return $.join("");
}
// SHORT VERSION:
// This function encrypts or decrypts a plain text name or label using the XOR operator with a fixed password. The output is going to be plain text.
// function XORName(S) { var $ = [], i = S.length, A = "8ODpmr0l1o9qGMRsNeZP_uLzB2cb6S4UfjwWIatHh$ExVAdFCQ5XyJnKY7vkg3iT"; while (i--) $[i] = A.charAt(((A.indexOf(S.charAt(i)) & 63) ^ A.charCodeAt(i & 63)) & 63); return $.join(""); }
//
//////////////////////////////////////////////////


// COMPRESSION LIBRARY

//////////////////////////////////////////////////
//                                     v2019.12.27
// This function compresses a text to binary string
// by removing the highest 0 bit from every byte
// thus shrinking the output by 8:7 ratio.
// Usage: STRING = Compress8to7(TEXT)
//
function Compress8to7(T)
{
  var i, j, L = T.length,
  BINARY = [(((L-1) & 7) == 0) || (((L-2) & 7) == 0) ? '1' : '0'];
  for (i = j = 0; i < L; i++)
    BINARY[++j] = toBin(T.charCodeAt(i) & 127, 7);
  BINARY = BINARY.join("");
  // This line is really unnecessary.
  // It is here just for clarification only:
  // while (BINARY.length & 7) BINARY += '0';
  return Bin2Str(BINARY);
}
//////////////////////////////////////////////////
//                                     v2019.12.27
// This function expands a binary string to a text
// by inserting a '0' in the high bit of each byte,
// thus expanding the output by a 7:8 ratio.
// Usage: TEXT = Expand7to8(STRING)
//
function Expand7to8(S)
{
  var BINARY = Str2Bin(S);
  var L = BINARY.length - 1;
  var OUTPUT = [];
  for (i = 1; i < L; i += 7)
    OUTPUT.push(String.fromCharCode(parseInt(BINARY.substr(i, 7), 2)));
  if (BINARY.charCodeAt(0) == 48)
    OUTPUT.pop();
  return OUTPUT.join("");
}
//////////////////////////////////////////////////
//
// LZW-compress a string
// [This function was copied from LZ-String.js]
//
function LzwCompress(s)
{
    var dict = {};
    var data = (s + "").split("");
    var out = [];
    var currChar;
    var phrase = data[0];
    var code = 256;
    for (var i=1; i<data.length; i++) {
        currChar=data[i];
        if (dict[phrase + currChar] != null) {
            phrase += currChar;
        }
        else {
            out.push(phrase.length > 1 ? dict[phrase] : phrase.charCodeAt(0));
            dict[phrase + currChar] = code;
            code++;
            phrase=currChar;
        }
    }
    out.push(phrase.length > 1 ? dict[phrase] : phrase.charCodeAt(0));
    for (var i=0; i<out.length; i++) {
        out[i] = String.fromCharCode(out[i]);
    }
    return out.join("");
}
//////////////////////////////////////////////////
//
// Expand an LZW-encoded string.
// [This function was copied from LZ-String.js]
//
function LzwExpand(s)
{
    var dict = {};
    var data = (s + "").split("");
    var currChar = data[0];
    var oldPhrase = currChar;
    var out = [currChar];
    var code = 256;
    var phrase;
    for (var i=1; i<data.length; i++) {
        var currCode = data[i].charCodeAt(0);
        if (currCode < 256) {
            phrase = data[i];
        }
        else {
           phrase = dict[currCode] ? dict[currCode] : (oldPhrase + currChar);
        }
        out.push(phrase);
        currChar = phrase.charAt(0);
        dict[code] = oldPhrase + currChar;
        code++;
        oldPhrase = phrase;
    }
    return out.join("");
}
//////////////////////////////////////////////////



//////////////////////////////////////////////////
//                                     v2020.12.27
// This function counts how many times each
// character occurs in a string and returns the
// results for only those characters that are
// listed in CHARSET. The return value is an array
// whose elements contain 6-digit numbers followed
// by one character. Example: ["000200L"] indicates
// that letter L occurs 200 times in the string.
// The array will start with the character that
// occurs least frequently in the string.
//
// Usage: ARRAY = FindLeastCommonChar(STRING, CHARSET)
//
function FindLeastCommonChar(S, SET)
{
  var i, c, A = [], $ = [];
  for (i = 0; i < 256; i++) A[i] = 0;
  for (i = 0; i < S.length; i++) A[S.charCodeAt(i)]++;
  for (i = 0; i < SET.length; i++)
    $[i] = ("00000" + A[SET.charCodeAt(i)]).slice(-6) + "" + SET.charAt(i);
  $.sort();
  return $;
}
//////////////////////////////////////////////////


//
// Takes any value and returns an integer.
// function toInt(X, MAXVALUE) { X += ""; X = X.replace(/[^[0-9]/g, ""); if (X.length == 0) return 0; X = X.substr(0, 15) * 1; if (typeof(MAXVALUE) != "undefined") if (X > MAXVALUE) return MAXVALUE; return X; }
//////////////////////////////////////////////////
//
// This function compares a list of numbers and
// returns the smallest number in the list that
// is bigger than the START_VALUE.
//
function FindLowest(START_VALUE)
{
  var i, A, MIN = START_VALUE;
  for (i = 1; i < arguments.length; i++)
  {
    A = arguments[i];
    if (typeof(A) === "undefined") continue;
    if (A == null || A < 55) continue;
    if (MIN > A) MIN = A;
  }
  return MIN;
}
// SHORT VERSION:
// Returns the smallest number from a list of arguments that is bigger than the START_VALUE.
// function FindLowest(START_VALUE) { var i, A, MIN = START_VALUE; for (i = 1; i < arguments.length; i++) { A = arguments[i]; if (typeof(A) === "undefined") continue; if (A == null || A < 55) continue; if (MIN > A) MIN = A; } return MIN; }
//
//////////////////////////////////////////////////

// This function converts number N to a positive integer that is exactly X number of bytes long. It does that by either chopping off some of the first few digits or putting some zeros in the front.
function FIXLEN(X, N) { if (isNaN(N) || N == null) N = "0"; else N = Math.floor(Math.abs(N)) + ""; if (N.length > X) return N.substr(N.length - X, X); while (N.length < X) N = "0" + N; return N; }

// This function splits binary string S into groups of 8 and removes the first digit of each group and returns a new string. This function can remove the first N digits if a second argument is provided.
// Example:
//  DiscardHighBit("1000000010000000");    --> "00000000000000"
//  DiscardHighBit("1100000011000000", 2); --> "000000000000"
//  DiscardHighBit("1110000011100000", 3); --> "0000000000"
function DiscardHighBit(S) { S = Group(S, 8); var i, N = (arguments.length == 2) ? arguments[1] : 1; for (i = 0; i < S.length; i++) S[i] = S[i].slice(N); return S.join(""); }

// This function is the opposite of DiscardHighBit() function. If a string is provided as a second argument, this string will be inserted at the beginning of every group.
// Example:
//  InsertHighBit("11111111111111");    --> "0111111101111111"
//  InsertHighBit("1111111111", "000"); --> "0001111100011111"
//  InsertHighBit("00000000", "1111");  --> "1111000011110000"
function InsertHighBit(S) { var BITS = (arguments.length > 1) ? arguments[1] : "0"; var N = (8 - BITS.length); S = Group(S, N); for (var i = 0; i < S.length; i++) S[i] = BITS + S[i]; return S.join(""); }


// COLOR MANIPULATION

// This function returns a random color code in rrggbb format.
function RandomColor()
{
  var C = "";
  while (C.length < 6)
    C += "0123456789ABCDEF".charAt(Math.round(Math.random() * 15));
  return C;
}

// Converts 3 decimal numbers to hex color code.
function toColor(R, G, B) { return toHex(R) + toHex(G) + toHex(B); }

// WARNING: This function overwrites global variables: R,G,B
// Converts a hex color code to individual R, G, B numbers.
function GetRGB(C) { C = Hex2Int(C); R = (C & 0xFF0000) >>> 16; G = (C & 0xFF00) >>> 8; B =  C & 0xFF; }

// WARNING: This function overwrites global variables: R,G,B
// This function returns the opposite color of C in hex format
function InvertColor(C) { GetRGB(C); return toColor(255-R, 255-G, 255-B); }

// WARNING: This function overwrites global variables: R,G,B,R1,G1,B1,R2,G2,B2,RX,GX,BX
// Returns an array of colors which is a transition from C1 to C2 in N steps
function GetColorShades(C1, C2, N) { var i, A = [C1]; if (N > 2) { CalculateColorGain(C1, C2, N); for (i = 0; i < N-2; i++) { R1 += RX; G1 += GX; B1 += BX; A.push(toColor(R1, G1, B1)); } } A.push(C2); return A; }

// WARNING: This function overwrites global variables: R,G,B,R1,G1,B1,R2,G2,B2,RX,GX,BX
// This function calculates how much R, G, B values need to change
// in order go from color C1 to color C2 in N steps.
// Side effects: C1 ---> R,G,B
function CalculateColorGain(C1, C2, N) { GetRGB(C2); R2=R; G2=G; B2=B; GetRGB(C1); R1=R; G1=G; B1=B; RX = (R2 - R1) / (N - 1); GX = (G2 - G1) / (N - 1); BX = (B2 - B1) / (N - 1); }

// WARNING: This function overwrites global variables: R,G,B,R1,G1,B1,R2,G2,B2,RX,GX,BX
// Prints each letter in a different color from C1 to C2.
function WriteInColor(S, C1, C2) { var i, c; CalculateColorGain(C1, C2, S.length); for (i = 0; i < S.length; i++) { c = S.charCodeAt(i); if (c < 33) PRINT("&nbsp;"); else { if (c == 38) c = "&amp;"; else if (c == 60) c = "&lt;"; else if (c == 62) c = "&gt;"; else c = S.charAt(i); PRINT("<FONT COLOR=" + toColor(R, G, B) + ">"+c+"</FONT>"); } R += RX; G += GX; B += BX; } }

// WARNING: This function overwrites global variables: R,G,B
// This function converts Hue, Saturation, and Luminance to RGB values
// Source: www.rapidtables.com/convert/color/hsv-to-rgb.htm
function HSL2RGB(H, S, L) { H = H * 1; if (H < 0) H = 0; if (H > 360) H = 359; H = H / 60; S = S * 1; if (S < 0) S = 0; if (S > 100) S = 100; S /= 100; L = L * 1; if (L < 0) L = 0; if (L > 100) L = 100; L /= 100; R = 0; G = 0; B = 0; var C = L * S; var M = L - C; var X = C * (1 - Math.abs(H % 2 - 1)); if (H >= 0 && H < 1) { R = C; G = X; } else if (H >= 1 && H < 2) { R = X; G = C; } else if (H >= 2 && H < 3) { G = C; B = X; } else if (H >= 3 && H < 4) { G = X; B = C; } else if (H >= 4 && H < 5) { R = X; B = C; } else { R = C; B = X; } R += M; R *= 255; R = Math.round(R); G += M; G *= 255; G = Math.round(G); B += M; B *= 255; B = Math.round(B); }

// This function converts RGB values to HSL format and returns
// these three values in an array: [Hue, Saturation, Luminance]
// Source: www.javascripter.net/faq/rgb2hsv.htm
function RGB2HSL(R, G, B) { R = R * 1; if (R < 0) R = 0; if (R > 255) R = 255; R = R / 255; G = G * 1; if (G < 0) G = 0; if (G > 255) G = 255; G = G / 255; B = B * 1; if (B < 0) B = 0; if (B > 255) B = 255; B = B / 255; var minRGB = Math.min(R, Math.min(G, B)); var maxRGB = Math.max(R, Math.max(G, B)); if (minRGB == maxRGB) return [0, 0, minRGB]; var S = (maxRGB - minRGB) / maxRGB; var D = (R == minRGB) ? G - B : ((B == minRGB) ? R - G : B - R); var H = (R == minRGB) ? 3 : ((B == minRGB) ? 1 : 5); H = 60 * (H - D / (maxRGB - minRGB)); return [H, S, maxRGB]; }

// This function can increase or decrease R-G-B brightness of a color and return a new color.
function ColorGain(C, R_GAIN, G_GAIN, B_GAIN) { GetRGB(C); R += R_GAIN; G += G_GAIN; B += B_GAIN; return toColor(R, G, B); }

function FadeBackground(CURRENT, BGCOLOR, TOTALTIME, DELAY)
{
  WAIT = DELAY;
  var STEPS = (TOTALTIME / DELAY) | 0;
  CURRENT = ("000000" + CURRENT.toString(16)).slice(-6);
  BGCOLOR = ("000000" + BGCOLOR.toString(16)).slice(-6);
  CalculateColorGain(CURRENT, BGCOLOR, STEPS);
  StepBgColor(STEPS);
}

// This function overwrites global variables: R,G,B,R1,G1,B1,R2,G2,B2,RX,GX,BX
// Changes the background color in steps.
function StepBgColor(STEPS)
{
  document.body.style.backgroundColor = toColor(R, G, B);
  R += RX;
  G += GX;
  B += BX;
  if (STEPS > 0)
  {
    STEPS--;
    setTimeout("StepBgColor(" + STEPS + ");", WAIT);
  }
}




// ARGUMENT PROCESSING & NAVIGATION CONTROL

//////////////////////////////////////////////////
//                                      v2021.2.10
// This function displays an alert message box.
// Anything between {} brackets will be evaluated
// first and then printed.
//
// Usage: Alert(STRINGS...)
//
function Alert()
{
  var i, P, L = arguments.length, MSG = [];
  for (i = 0; i < L; i++)
    MSG[i] = arguments[i];
  MSG = MSG.join("").split("{");
  for (i = 1; i < MSG.length; i++)
  {
    P = MSG[i].indexOf("}");
    if (P >= 0) MSG[i] = eval(MSG[i].substr(0, P)) + MSG[i].slice(P + 1);
  }
  MSG = MSG.join("");
  if(window)
    alert(MSG);
  else
    WScript.Echo(MSG);
}
//////////////////////////////////////////////////


// This function loads a given URL address.
function Goto(URL) { location.href = URL; }


///////////////////////////////////////////////////
// HTML GET

// This function is called when data downloaded by
// WGET() arrives and becomes available.
function RECEIVER(DATA)
{
  // IF WE DIDN'T GET ANYTHING
  if (DATA.length == 0) { alert("ERROR: No data received.\n\nYour browser may not allow cross domain resource access."); return; }
  alert("DATA: " + DATA);
}

// The WGET function downloads a file from the internet
// and allows us to work with it. But unfortunately,
// not all web browsers support this feature, so its
// behavior is somewhat unpredictable. For example:
// * Safari 5.1.7 receives a blank string
// * Firefox 19.0 receives a blank string unless an addon called "Force CORS" is installed and enabled.
// * KMeleon 1.5.4 displays an error message and doesn't receive anything
// * Internet Explorer 9 works fine
function WGET(URL) { try { var REQUEST = (typeof window.ActiveXObject != "undefined") ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest(); REQUEST.open("GET", URL, true); REQUEST.onreadystatechange = function() { if (REQUEST.readyState == 4) RECEIVER(REQUEST.responseText); }; REQUEST.send(null); } catch (e) { alert("ERROR: Could not fetch data from\n\n" + URL + "\n\n(" + e.message + ")"); } }


// TASK MANAGER written by Zsolt Nagy-Perge on Oct 21, 2017.
//
// The task manager is initiated by calling AddTimer();
// This function creates a timer hook like setInterval()
// but here you MUST specify how many times a function
// should be called. The DELAY is given in tenths of a second.
//
// Usage: AddTimer(FUNCTION, DELAY, ITERATIONS, [INSTRUCTIONS]);
//
// Example:  AddTimer("MyFunc", 2, 5, "callback();");
//
// This executes MyFunc(0,4); immediately and then 2/10 seconds later,
//   it executes MyFunc(1,4); and then 200ms later,
//      it calls MyFunc(2,4); and 200ms later
//         calls MyFunc(3,4); and 200ms later
//         calls MyFunc(4,4); and callback(); and stops.
//
// FUNCTION only gets executed when ITERATIONS > 0
// INSTRUCTIONS always get executed at the end.
//
// These functions rely on a global variable called $TIMER,
// so this array must be created before AddTimer() can be used.
//

$TIMER = [0, 0]; // $TIMER[0] = TIMER STATUS, $TIMER[1] = TIMER HANDLE

// Adds a task to the task tray and starts the timer.
function AddTimer(FUNC, DELAY, REP) { var CALLBACK = (arguments.length > 3) ? arguments[3] : ""; if (REP < 2) { while (--REP >= 0) eval(FUNC+"(0,"+REP+");"); eval(CALLBACK); return; } $TIMER.push(FUNC, 0, REP, 1, DELAY, CALLBACK); StartTimer(); }

// Starts the timer.
function StartTimer() { if (!$TIMER[0]) $TIMER[1] = setInterval("TaskMGR();", 100); $TIMER[0] = 1; }

// Removes task from the task tray and stops the timer if no tasks are left. Finally, executes callback instructions (if any).
function StopTimer(N) { var CALLBACK = ""; if ($TIMER.length > N+5) { CALLBACK = $TIMER[N+5]; $TIMER.splice(N, 6); } if ($TIMER.length < 3) if ($TIMER[0]) { clearInterval($TIMER[1]); $TIMER[0] = 0; } eval(CALLBACK); }

// This function is called every 100 milliseconds.
function TaskMGR() { var RUNCOUNT, MAXRUNS, DELAY, i; for (i = 2; i < $TIMER.length; i += 6) { DELAY = $TIMER[i+4]; if (DELAY > 1) { if (++$TIMER[i+3] < DELAY) continue; $TIMER[i+3] = 1; } RUNCOUNT = ++$TIMER[i+1]; MAXRUNS = $TIMER[i+2]; eval($TIMER[i] + "(" + RUNCOUNT + "," + MAXRUNS + ");"); if (RUNCOUNT >= MAXRUNS) StopTimer(i); } }


// BENCHMARK

TIMER = [];
function Timer(E) { D = new Date(); TIMER.push(D.getTime()); TIMER.push(E); }
function ShowTimer() { var i, E, PREV, DIFF, T = 0; PRINT("<TABLE BGCOLOR=666666 CELLSPACING=5><TD><TABLE BORDER=1 BGCOLOR=EEEEEE CELLSPACING=0 CELLPADDING=7><TR BGCOLOR=FFEEFF><TD><CENTER>Raw Time (ms)<TD><CENTER>Delay (ms)<TD><CENTER>Description"); while (TIMER.length > 0) { PREV = T; T = TIMER.shift(); E = TIMER.shift(); DIFF = Math.abs(PREV - T); if (PREV == 0) continue; PRINT("<TR><TD ALIGN=RIGHT><FONT COLOR=0000CC>" + T + "<TD ALIGN=RIGHT><B><FONT COLOR=0000CC>" + DIFF + "<TD>" + E); } PRINT("</TABLE></TABLE>"); TIMER = []; FLUSH(); }


//////////////////////////////////////////////////
//                                     v2020.12.31
// This function rearranges the bits in a byte
// according to a pattern, and returns a new value.
// The pattern string should contain a hexadecimal
// value which indexes bits from 1 to 8. When the
// pattern is 0x12345678, the output is the same
// as the input. When the pattern is 0x82345671,
// the first and last bits are swapped! Bits can
// also be zeroed out by using the "0" instead of
// an index. And bits can be turned on by using any
// value larger than 8. So, for example: 0x00123456
// will shift 6 bits and clear the upper two bits.
// Usage: BYTE = BitShuffle(BYTE, PATTERN)
//
function BitShuffle(BYTE, PATTERN)
{
  var i, X, $ = [];
  BYTE = ("0000000" + BYTE.toString(2)).slice(-8);
  for (i = 7; i >= 0; i--)
  {
    X = PATTERN & 15;
    PATTERN >>= 4;
    if (X == 0) $.push(0);
    else if (X > 8) $.push(1);
    else $.push(BYTE.charAt(X-1));
  }
  return parseInt($.reverse().join(""), 2);
}
//////////////////////////////////////////////////





//////////////////////////////////////////////////
// SHORT VERSIONS OF THE FOLLOWING:

// This function saves a binary string in localStorage or cookies.
function StoreXStr(NAME, VALUE) { VALUE += ""; NAME = XORName(NAME); if (SetItem(NAME, ForwardShuffle(RndXOR(VALUE)))) return SetCookie(NAME, EncodeCookie(VALUE)); return 2; }

// This function retrieves a string saved earlier by the StoreXStr() function. If the value is not found or could not be retrieved, an empty string is returned.
function LoadXStr(NAME) { NAME = XORName(NAME); var VALUE = GetItem(NAME); if (VALUE == null || VALUE == "") return DecodeCookie(GetCookie(NAME)); return RndXOR(BackwardShuffle(VALUE)); }

// Returns the decrypted names of all items saved both in cookies and localStorage.
function GetXNames() { var A, i, $ = []; A = GetCookieNames(); for (i = 0; i < A.length; i++) $.push(XORName(A[i])); A = GetItemNames(); for (i = 0; i < A.length; i++) $.push(XORName(A[i])); return $; }

// Deletes an encrypted value both from localStorage and cookies.
function DeleteX(NAME) { NAME = XORName(NAME); DeleteItem(NAME); DeleteCookie(NAME); }

// This function encrypts and converts any binary string before it is stored in a cookie.
function EncodeCookie(S, SEED) { if (typeof(SEED) === "undefined") SEED = 13.7426523411; if (isFromCharSet(S, COOKIEJAR)) S = "a" + S; else { var E = EscapeString(S, COOKIEJAR); if (S.length * 1.33333333 < E.length) S = "b" + EncodeB64(S); else S = "e" + E; } S = ShiftRStr(S, SEED, COOKIEJAR); return ForwardShuffle(S, SEED); }

// This function decrypts a cookie value and returns a binary string.
function DecodeCookie(S, SEED) { if (typeof(SEED) === "undefined") SEED = 13.7426523411; S = BackwardShuffle(S, SEED); S = ShiftRStr(S, -SEED, COOKIEJAR); var c = S.charCodeAt(0); S = S.slice(1); if (c == 98) S = DecodeB64(S); else if (c == 101) S = UnescapeString(S, COOKIEJAR); return S; }


//////////////////////////////////////////////////
//                                     v2020.12.18
// This function saves a binary string in the
// localStorage first, and if that fails, then
// it tries to save it as a cookie instead.
// Returns 2 if the value was saved in localStorage.
// Returns 1 if the value was saved in cookies.
// Returns 0 if the value could not be saved.
//
// Usage: INTEGER = StoreXStr(NAME, VALUE)
//
function StoreXStr(NAME, VALUE)
{
  VALUE += "";
  NAME = XORName(NAME);
  if (SetItem(NAME, ForwardShuffle(XORBinary(VALUE))))
    return SetCookie(NAME, EncodeCookie(VALUE));
  return 2;
}
//////////////////////////////////////////////////
//                                     v2020.12.18
// This function retrieves a string saved earlier
// by the StoreXStr() function. If the value
// is not found or could not be retrieved,
// then an empty string is returned.
//
// Usage: STRING = LoadXStr(NAME)
//
function LoadXStr(NAME)
{
  NAME = XORName(NAME);
  var VALUE = GetItem(NAME);
  if (VALUE == null || VALUE == "")
    return DecodeCookie(GetCookie(NAME));
  return XORBinary(BackwardShuffle(VALUE));
}
//////////////////////////////////////////////////
//                                     v2020.12.29
// Returns the decrypted names of all items saved
// both in cookies and localStorage.
// Usage: ARRAY = GetXNames()
//
function GetXNames()
{
  var A, i, $ = [];
  A = GetCookieNames();
  for (i = 0; i < A.length; i++) $.push(XORName(A[i]));
  A = GetItemNames();
  for (i = 0; i < A.length; i++) $.push(XORName(A[i]));
  return $;
}
//////////////////////////////////////////////////
//                                     v2020.12.29
// Deletes an encrypted value both
// from localStorage and cookies.
// Usage: DeleteX(NAME)
//
function DeleteX(NAME)
{
  NAME = XORName(NAME);
  DeleteItem(NAME);
  DeleteCookie(NAME);
}
//////////////////////////////////////////////////
//                                     v2020.12.31
// Erases all cookies and localStorage items.
// Usage: FlushBrowserStorage();
//
function FlushBrowserStorage()
{
  DeleteAllItems();
  DeleteAllCookies();
}
//////////////////////////////////////////////////
//                                     v2020.12.19
// This function saves a cookie in the browser.
// The expiration must be given in seconds, which
// tells the browser how long the cookie will exist.
// Returns 1 on success.
// Returns 0 if the cookie could not be saved.
//
// Usage: INTEGER = SetCookie(NAME, VALUE, EXPIRATION)
//
function SetCookie(NAME, VALUE, EXPIRATION)
{
  var DATE = new Date();
  var COOKIE = NAME + "=" + (typeof(VALUE) === "undefined" ? "" : VALUE);
  DATE.setTime(DATE.getTime() + 1000 * (typeof(EXPIRATION) === "undefined" ? 157680000 : EXPIRATION));
  document.cookie = COOKIE + ";Expires=" + DATE.toGMTString() + ";";
  return document.cookie.indexOf(COOKIE) < 0 ? 0 : 1;
}
//////////////////////////////////////////////////
//                                     v2020.12.29
// Returns the value of a cookie. If the cookie
// could not be found, an empty string is returned.
// Usage: INTEGER = GetCookie(NAME)
//
function GetCookie(NAME)
{
  var i, s, COOKIE = document.cookie.split(";");
  for (i = 0; i < COOKIE.length; i++)
    if ((s = COOKIE[i].indexOf(NAME + "=")) >= 0)
      return COOKIE[i].slice(s + NAME.length + 1);
  return "";
}
//////////////////////////////////////////////////
//
// Deletes a cookie from the browser's storage.
// Usage: DeleteCookie(NAME)
//
function DeleteCookie(NAME)
{
  document.cookie = NAME + "=;Expires=Jan 01 1970 01:01:01 GMT";
}
//////////////////////////////////////////////////
//                                     v2020.12.29
// Returns the names of all saved cookies.
// Usage: ARRAY = GetCookieNames()
//
function GetCookieNames()
{
  var i, P, COOKIE = document.cookie.split(";"), A = [];
  for (i = 0; i < COOKIE.length; i++)
    if ((P = COOKIE[i].indexOf("=")) >= 0)
      A.push(Trim(COOKIE[i].substr(0, P)));
  return A;
}
//////////////////////////////////////////////////
//                                     v2020.12.29
// Completely erases all cookies.
// Returns the number of cookies removed.
// Usage: INTEGER = DeleteAllCookies()
//
function DeleteAllCookies()
{
  var i, COOKIE = GetCookieNames();
  for (i = 0; i < COOKIE.length; i++)
    DeleteCookie(COOKIE[i]);
  return COOKIE.length;
}
//////////////////////////////////////////////////
//                                     v2020.12.13
// This function returns 0 when cookies are disabled.
// Returns 1 when cookies are enabled yet new cookies
// cannot be saved. Returns 2 when cookies can be
// saved and retrieved without a problem.
// Usage: INTEGER = TestCookies()
//
function TestCookies()
{
  var TEST_NAME = "XXTEST123XX";
  var TEST_VALUE = "Blessed are the pure in heart, for they shall see God. Matthew 5:8 (NKJV)";
  SetCookie(TEST_NAME, TEST_VALUE);
  if (GetCookie(TEST_NAME) == TEST_VALUE)
  {
    DeleteCookie(TEST_NAME);
    return 2;
  }
  return navigator.cookieEnabled ? 1 : 0;
}
//////////////////////////////////////////////////
//                                     v2020.12.18
// This function saves a string in localStorage.
// Returns 1 if the value could not be saved.
// Returns 0 on success.
// Usage: INTEGER = SetItem(STRING, STRING)
//
function SetItem(NAME, VALUE)
{
  if (typeof(VALUE) === "undefined" || VALUE == null) VALUE = "";
  try
  {
    with(window.localStorage)
    {
      setItem(NAME, VALUE);
      if (getItem(NAME) == VALUE) return 0;
    }
  }
  catch(e) {}
  return 1;
}
//////////////////////////////////////////////////
//                                     v2020.12.30
// Retrieves a binary string from localStorage.
// If the named value is not found,
// an empty string is returned.
// Usage: STRING = GetItem(NAME)
//
function GetItem(NAME)
{
  try
  {
    var X = localStorage.getItem(NAME);
    return (X == null) ? "" : X;
  }
  catch(e) {}
  return "";
}
//////////////////////////////////////////////////
//
// This function returns the names of values
// saved in localStorage.
// Usage: ARRAY = GetItemNames()
//
function GetItemNames()
{
  var i, A = [];
  try
  {
    for (i = 0; i < localStorage.length; i++)
      A[i] = localStorage.key(i);
  }
  catch(e) {}
  return A;
}
//////////////////////////////////////////////////
//                                     v2020.12.29
// Deletes one item from localStorage.
// Returns 1 on success.
// Returns 0 if the operation failed.
// Usage: INTEGER = DeleteItem(NAME)
//
function DeleteItem(NAME)
{
  try
  {
    with(window.localStorage)
    {
      setItem(NAME, "");
      removeItem(NAME);
    }
    return 1;
  }
  catch(e) {}
  return 0;
}
//////////////////////////////////////////////////
//                                     v2020.12.29
// Completely erases all values from localStorage.
// On success, returns the number of items removed.
// On failure, returns -1.
// Usage: INTEGER = DeleteAllItems()
//
function DeleteAllItems()
{
  try
  {
    var L = window.localStorage.length;
    window.localStorage.clear();
    return L;
  }
  catch(e) {}
  return -1;
}
//////////////////////////////////////////////////
//                                     v2020.12.13
// This function returns 2 when localStorage is
// enabled and values can be saved and retrieved
// with no problem. Returns 1 when localStorage is
// enabled, yet for some reason new values cannot be
// saved. Returns 0 when localStorage is not supported.
// Usage: INTEGER = TestLocalStorage()
//
function TestLocalStorage()
{
  var STATUS = 0;
  var TEST_NAME = "XXTEST123XX";
  var TEST_VALUE = "Blessed are the peacemakers, for they shall be called sons of God. Matthew 5:9 (NKJV)";
  try
  {
    localStorage.setItem(TEST_NAME, TEST_VALUE);
    STATUS = 1;
    if (localStorage.getItem(TEST_NAME) == TEST_VALUE)
    {
      localStorage.removeItem(TEST_NAME);
      STATUS = 2;
    }
  } catch (e) {}
  return STATUS;
}
//////////////////////////////////////////////////
//                                       v2021.1.5
// This function adds to the ASCII value of each
// character, shifting values either up or down
// depending on the DIRECTION value. CHARSET
// defines what characters are allowed in the set.
// The DIRECTION value should be either a positive
// or a negative value depending on which way the
// values are desired to be shifted.
// Usage: STRING = ShiftRStr(STRING, DIRECTION, CHARSET)
//
function ShiftRStr(S, DIR, SET)
{
  S += "";
  var c, i, $ = [];
  var SEED = Math.abs(DIR);
  var NEG = (DIR < 0) ? 1 : 0;
  for (i = 0; i < S.length; i++)
  {
    c = SET.indexOf(S.charAt(i));
    if (c < 0) c = 0;
    SEED = (SEED * 539 + 5321) & 0xFFFF;
    ADD = (SEED >> 4) & 63;
    if (NEG) c += SET.length - ADD; else c += ADD;
    c %= SET.length;
    $[i] = SET.charAt(c);
  }
  return $.join("");
}
// SHORT VERSION:
// This function adds to the ASCII value of each character, shifting values either up or down. CHARSET defines what characters are allowed in the set. DIRECTION should be either a positive or a negative value.
// function ShiftRStr(S, DIR, SET) { S += ""; var c, i, $ = []; var SEED = Math.abs(DIR); var NEG = (DIR < 0) ? 1 : 0; for (i = 0; i < S.length; i++) { c = SET.indexOf(S.charAt(i)); if (c < 0) c = 0; SEED = (SEED * 539 + 5321) & 0xFFFF; ADD = (SEED >> 4) & 63; if (NEG) c += SET.length - ADD; else c += ADD; c %= SET.length; $[i] = SET.charAt(c); } return $.join(""); }
//
//////////////////////////////////////////////////
//                                     v2020.12.26
// This function encrypts and converts any binary
// string before it is stored in a cookie.
//
// Usage: STRING = EncodeCookie(STRING, [SEED])
// 
function EncodeCookie(S, SEED)
{
  if (typeof(SEED) === "undefined") SEED = 13.7426523411;
  if (isFromCharSet(S, COOKIEJAR))
    S = "a" + S;
  else
  {
    var E = EscapeString(S, COOKIEJAR);
    if (S.length * 1.33333333 < E.length)
      S = "b" + EncodeB64(S);
    else
      S = "e" + E;
  }
  S = ShiftRStr(S, SEED, COOKIEJAR);
  return ForwardShuffle(S, SEED);
}
//////////////////////////////////////////////////
//                                     v2020.12.26
// This function decrypts a cookie value and
// returns a binary string.
//
// Usage: STRING = DecodeCookie(STRING, [SEED])
//
function DecodeCookie(S, SEED)
{
  if (typeof(SEED) === "undefined") SEED = 13.7426523411;
  S = BackwardShuffle(S, SEED);
  S = ShiftRStr(S, -SEED, COOKIEJAR);
  var c = S.charCodeAt(0);
  S = S.slice(1);
  if (c == 98)
    S = DecodeB64(S);
  else if (c == 101)
    S = UnescapeString(S, COOKIEJAR);
  return S;
}

// While items in localStorage can hold binary data, but
// cookie values may only contain the following bytes:
COOKIEJAR = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz []{}()<>-~+:?@#$&%*^`',_/|\\\t\"!.";

// Cookies expire; localStorage items do not.
// The most important difference between cookies and
// localStorage is that cookies are sent over the
// internet with each request, therefore the size of
// all cookies together on a page cannot exceed 5KB.
// LocalStorage is not automatically sent over the
// wire, therefore its capacity can be much larger
// (usually 10MB).

// The SetCookie() function sets a cookie in the
// client's browser that expires in N days. N can be
// either a number or string date such as "Feb 3 2014".
// When N is omitted, the default value for N is 1825,
// which is exactly 5 years.
// When N is zero, a session cookie is created that
// will be deleted when the browser is closed.
// If the VALUE is an empty string, the cookie will be
// deleted. This function returns 1 on success,
// or 0 if the cookie could not be created.
// Usage: STATUS = SetCookie(NAME, VALUE, EXPIRATION)

function SetCookie(N, V, E)	   {if(typeof(N)==="undefined"||N.length==0)return 0;if(typeof(V)==="undefined")V="";var VL=V.toString().length;if(VL&&document.cookie.length+N.length+VL>5000)return 0;if(!VL)E="Jan 01 1970 00:00:00 GMT";if(typeof(E)==="undefined")E=157680000;if(!isNaN(E)){if(E>0){var T=new Date();T.setTime(T.getTime()+E*1000);E=T.toGMTString();}else E="";}document.cookie=N+"="+V+";Expires="+E+";";return 1;}
//function SetCookie(NAME, VALUE, N) {if(typeof(NAME)==="undefined"||NAME.length==0)return 0;if(typeof(VALUE)==="undefined")VALUE="";var VL=VALUE.toString().length;if(VL&&document.cookie.length+NAME.length+VL>5000)return 0;if(!VL)N="Jan 01 1970 01:01:01 GMT";if(typeof(N)==="undefined")N=1825;if(!isNaN(N)){if(N>0){var T=new Date();T.setTime(T.getTime()+N*86400000);N=T.toGMTString();}else N="";}document.cookie=NAME+"="+VALUE+";Expires="+N+";";return 1;}

// Returns the value of a cookie. Cookie names are
// always case sensitive! If the cookie doesn't
// exist, then an empty string is returned.
function GetCookie(NAME) {var P,K=" "+document.cookie;P=K.indexOf(" "+NAME+"=");if(P<0)return"";K=K.slice(P+NAME.length+2);P=K.indexOf(";");if(P>=0)K=K.substr(0,P);return K;}

// Returns an array containing the names of existing cookies.
function GetCookieNames() {var i,S,L,C,K=document.cookie+";",SAVE=1,A=[];for(L=S=i=0;i<K.length;i++){C=K.charCodeAt(i);if(C==61||C==59){if(SAVE)A.push(K.substr(S,L));L=S=0;SAVE=(C==59)?1:0;}else if(SAVE&&C>32)if(L++==0)S=i;}return A;}

// Empties the named cookie and marks it for deletion.
function DeleteCookie(NAME) {document.cookie=NAME+"=;Expires=Jan 01 1970 01:01:01 GMT";}

// Deletes all cookies.
// Returns the number of cookies found & deleted.
function DeleteAllCookies() {var i,S,L,C,K=document.cookie+";",SAVE=1,CC=0;for(L=S=i=0;i<K.length;i++){C=K.charCodeAt(i);if(C==61||C==59){if(SAVE){DeleteCookie(K.substr(S,L));CC++;}L=S=0;SAVE=(C==59)?1:0;}else if(SAVE&&C>32)if(L++==0)S=i;}return CC;}

// Creates a cookie that expires in 5 years.
//function SetCookie(NAME, VALUE) { var E = new Date(); E.setFullYear(E.getFullYear() + 5); document.cookie = NAME + "=" + VALUE + ";Expires=" + E.toGMTString(); }

// Returns the value of a cookie.
//function GetCookie(NAME) { var i, e, s, K = document.cookie.split(";"); for (i = 0; i < K.length; i++) { for (s = 0; K[i].charCodeAt(s) < 33; s++); e = K[i].indexOf("="); if (K[i].substring(s, e) == NAME) return K[i].slice(++e); } return ""; }

// Completely erases a cookie.
//function DeleteCookie(NAME) { document.cookie = NAME + "=;Expires=Thu, 01 Jan 1970 00:00:01 GMT"; }

// Deletes all cookies.
//function DeleteAllCookies() { var i, s, e, X, K = document.cookie.split(";"); for (i = 0; i < K.length; i++) { e = K[i].indexOf("="); if (e < 0) X = ""; else { for (s = 0; K[i].charCodeAt(s) < 33; s++); X = K[i].substring(s, e); } DeleteCookie(X); } }

// Creates a name-value pair and stores it in localStorage.
function SetItem(NAME, VALUE) { try { with (window.localStorage) { setItem(NAME, VALUE); if (getItem(NAME) == VALUE) return 1; } } catch (e) {} return 0; }

// Returns a value from localStorage. Returns null if failed or not found.
function GetItem(NAME) { var V = null; try { V = localStorage.getItem(NAME); } catch (e) {} return V; }

// Deletes a value from localStorage.
function DeleteItem(NAME) { try { with (window.localStorage) { setItem(NAME, ''); clear(NAME); } return 1; } catch (e) {} return 0; }

// Deletes everything from localStorage.
function DeleteAllItems() { try { localStorage.removeItem(); return 1; } catch (e) {} return 0; }

// Saves an encrpyted cookie that expires in 5 years.
// Also removes illegal characters from the cookie before saving it!
function SetXCookie(NAME, VALUE) { var i, c, r = VALUE.length, X = []; for (i = 0; i < VALUE.length; i++) { c = COOKIEJAR.indexOf(VALUE.charAt(i)); if (c < 0) continue; r = (r * 133) % 179; c = c - r; while (c < 0) c += COOKIEJAR.length; X.push(COOKIEJAR.charAt(c)); } SetCookie(NAME, X.join("")); }

// Returns the value of an encrypted cookie.
function GetXCookie(NAME) { var X = GetCookie(NAME); var i, c, r = X.length, K = []; for (i = 0; i < X.length; i++) { c = COOKIEJAR.indexOf(X.charAt(i)); r = (r * 133) % 179; c = (c + r) % COOKIEJAR.length; K.push(COOKIEJAR.charAt(c)); } return K.join(""); }

// This function saves an encryted string in localStorage and
// in a cookie. You may specify a password string as a third
// argument, or else the function will use a default password.
// (Note: This function encrypts only the VALUE, not the NAME.)
function SetValue(NAME, VALUE) { var PW = (arguments.length > 2) ? arguments[2] : ""; VALUE += ""; VALUE = XCrypt(VALUE, PW); SetCookie(NAME, EncodeB64(VALUE)); try { localStorage.setItem(NAME, VALUE); } catch (e) {} }

// This function retrieves an encrypted string from localStorage
// or from a cookie. Again, you may specify a password string as a
// third argument, or else the function will use a default password.
function GetValue(NAME) { var PW = (arguments.length > 2) ? arguments[2] : ""; var VALUE = ""; var C = DecodeB64(GetCookie(NAME)); try { VALUE = localStorage.getItem(NAME); } catch (e) {} if (VALUE == null || C.length > VALUE.length) VALUE = C; return XCrypt(VALUE, PW); }

// This function stores a test cookie to see if cookies are working.
function CookieTest() { var A = "ABC" + Math.round(Math.random() * 1000000); SetCookie(A, A); var X = GetCookie(A); DeleteCookie(A); if (X == A) return 2; return navigator.cookieEnabled ? 1 : 0; }

// This function stores a string in localStorage to see if it is working.
function StorageTest() { var A = "ABC" + Math.round(Math.random() * 1000000); try { with (window.localStorage) { setItem(A, A); if (getItem(A) == A) { removeItem(A); return 2; } } } catch (e) { return 0; } return 1; }


// HTML FUNCTIONS

function BUTTON(LABEL, W, H, HANDLE, ACTION, BGCOLOR, TEXTCOLOR) { var BTN_FONT_SIZE = 20; if (WX > 1000 || HX > 1000) BTN_FONT_SIZE = SIZE(6); PRINT("<INPUT ID='"+HANDLE+"' TYPE=BUTTON VALUE='"+LABEL+"' STYLE='WIDTH:"+W+"; HEIGHT:"+H+"; BACKGROUND-COLOR:"+BGCOLOR+"; COLOR:"+TEXTCOLOR+"; BORDER:NONE; FONT-FAMILY:ARIAL; FONT-SIZE:"+BTN_FONT_SIZE+"PX;' onClick='"+ACTION+"'>"); BUTTONS++; }

//////////////////////////////////////////////////
//                                       v2021.1.5
// This function displays the entire ASCII character set in color.
function DisplayCharSet()
{
  var i = 16, j, C, c = 0;
  PRINT("<P><CENTER><TABLE BGCOLOR=000044 STYLE='BORDER:SOLID; BORDER-COLOR:000033;'><TR><TD HEIGHT=40 COLSPAN=16 BGCOLOR=003366><FONT SIZE=4 COLOR=WHITE><B><CENTER>ASCII CHARACTER SET");
  while (i--)
  {
    PRINT("<TR>");
    for (j = 0; j < 16; j++)
    {
      COLOR = "000000";
      BGCOLOR = "FFFFFF";
      C = toSafeHTML(String.fromCharCode(c));
      if (c < 32) C = "&nbsp;";
      if (c == 0) C = "nul";
      if (c == 9) { C = "tab"; BGCOLOR = "FFCCFF"; }
      if (c == 10) { C = "LF \\n"; BGCOLOR = "FFCCFF"; }
      if (c == 13) { C = "CR \\r"; BGCOLOR = "FFCCFF"; }
      if (c == 32) C = "space";
      if (c < 127 && c > 31) BGCOLOR = "CCFFCC";
      if (escape(String.fromCharCode(c)).length == 1)
        BGCOLOR = "00CC00";
      PRINT("<TD BGCOLOR=" + BGCOLOR + " WIDTH=32><FONT FACE=ARIAL SIZE=2 COLOR=" + COLOR + "><CENTER>" + c + "<BR>" + C);
      c++;
    }
  }
  PRINT("</TABLE></CENTER><P>");
  FLUSH();
}

// SHORT VERSION:
// Displays the entire ASCII character set in color.
// function DisplayCharSet() { var i = 16, j, C, c = 0; PRINT("<P><CENTER><TABLE BGCOLOR=000044 STYLE='BORDER:SOLID; BORDER-COLOR:000033;'><TR><TD HEIGHT=40 COLSPAN=16 BGCOLOR=003366><FONT SIZE=4 COLOR=WHITE><B><CENTER>ASCII CHARACTER SET"); while (i--) { PRINT("<TR>"); for (j = 0; j < 16; j++) { COLOR = "000000"; BGCOLOR = "FFFFFF"; C = toSafeHTML(String.fromCharCode(c)); if (c < 32) C = "&nbsp;"; if (c == 0) C = "nul"; if (c == 9) { C = "tab"; BGCOLOR = "FFCCFF"; } if (c == 10) { C = "LF \\n"; BGCOLOR = "FFCCFF"; } if (c == 13) { C = "CR \\r"; BGCOLOR = "FFCCFF"; } if (c == 32) C = "space"; if (c < 127 && c > 31) BGCOLOR = "CCFFCC"; if (escape(String.fromCharCode(c)).length == 1) BGCOLOR = "00CC00"; PRINT("<TD BGCOLOR=" + BGCOLOR + " WIDTH=32><FONT FACE=ARIAL SIZE=2 COLOR=" + COLOR + "><CENTER>" + c + "<BR>" + C); c++; } } PRINT("</TABLE></CENTER><P>"); FLUSH(); }
//
//////////////////////////////////////////////////

// Changes the transparency of an object. Usage: SetOpacity(ID, ALPHA)
function SetOpacity(E, A) { A = Math.round(A); if (A > 100) A = 100; if (A < 0) A = 0; E = document.getElementById(E); E.style.opacity = A / 100; E.style.filter  = "alpha(opacity="+A+")"; }

// Causes an object to float and changes its coordinates.
function SetObjCoords(E, LEFT, TOP) { E = document.getElementById(E); LEFT = Math.round(LEFT); TOP = Math.round(TOP); E.style.position = "ABSOLUTE"; E.style.top = TOP; E.style.left = LEFT; }

function FadeIn(E) { for (var i = 0; i <= 100; i += 10) setTimeout("SetOpacity('" + E + "', " + i + ");", 7*i); }
function FadeOut(E) { for (var i = 0; i <= 100; i += 10) setTimeout("SetOpacity('" + E + "', " + i + ");", 7*(100-i)); }

function Fadein(OBJECT, NEXT_COLOR, END_COLOR, ITERATIONS) { if (typeof(ITERATIONS) === "undefined") ITERATIONS = 10; var R_START = (NEXT_COLOR >> 16) & 255; var G_START = (NEXT_COLOR >> 8) & 255; var B_START = NEXT_COLOR & 255; var R_END = (END_COLOR >> 16) & 255; var G_END = (END_COLOR >> 8) & 255; var B_END = END_COLOR & 255; var R_DIFF = (R_END - R_START) / (ITERATIONS+1); var G_DIFF = (G_END - G_START) / (ITERATIONS+1); var B_DIFF = (B_END - B_START) / (ITERATIONS+1); if (ITERATIONS > 0) { R_START += R_DIFF; G_START += G_DIFF; B_START += B_DIFF; } else { R_START = R_END; G_START = G_END; B_START = B_END; } var NEW_COLOR = toColor(R_START, G_START, B_START); document.getElementById(OBJECT).style.color = "#" + NEW_COLOR; if (ITERATIONS--) setTimeout("Fadein('"+OBJECT+"', 0x"+NEW_COLOR+", "+END_COLOR+", "+ITERATIONS+");", 150); }

// DIV or B is a lot faster than TABLE
function DrawBox(LEFT, TOP, WIDTH, HEIGHT, COLOR) { PRINT("<B CLASS=DRAW STYLE='BACKGROUND-COLOR:"+COLOR+"; WIDTH:"+WIDTH+"; HEIGHT:"+HEIGHT+"; TOP:"+TOP+"; LEFT:"+LEFT+";'></B>"); }
function DrawFrame(LEFT, TOP, WIDTH, HEIGHT, BORDER_WIDTH, COLOR) { PRINT("<TABLE CLASS=DRAW CELLSPACING=0 CELLPADDING=0 WIDTH="+WIDTH+" HEIGHT="+HEIGHT+" STYLE='BORDER:SOLID; BORDER-WIDTH:"+BORDER_WIDTH+"; BORDER-COLOR:"+COLOR+"; TOP:"+TOP+"; LEFT:"+LEFT+";'><TD></TABLE>"); }
function DrawPixel(LEFT, TOP, COLOR) { PRINT("<DIV CLASS=DRAW STYLE='BACKGROUND-COLOR:"+COLOR+"; TOP:"+TOP+"; LEFT:"+LEFT+"; WIDTH:2; HEIGHT:2;'></DIV>"); }
function DrawLine(WIDTH, THICKNESS, COLOR, MARGIN) { PRINT("<CENTER><TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 BGCOLOR="+COLOR+" WIDTH="+WIDTH+" HEIGHT="+THICKNESS+" STYLE='MARGIN-TOP:"+MARGIN+"; MARGIN-BOTTOM:"+MARGIN+"; MARGIN-LEFT:"+MARGIN+"; MARGIN-RIGHT:"+MARGIN+";'><TD></TABLE></CENTER>"); }
function DrawCover(LEFT, TOP, WIDTH, HEIGHT) { var ETC = (arguments.length > 4) ? arguments[4] : ""; PRINT("<IMG SRC='glass.gif' BORDER=0 WIDTH="+WIDTH+" HEIGHT="+HEIGHT+" CLASS=DRAW STYLE='BORDER:NONE; TOP:"+TOP+"; LEFT:"+LEFT+"; z-index:1000;' "+ETC+">"); }
function DrawNiceBox(C1, C2, THICKNESS, CONTENT) { var i, $ = [], C = GetColorShades(C1, C2, THICKNESS); for (i = 0; i < THICKNESS; i++) $.push("<TABLE BGCOLOR="+C[i]+">"); PRINT($.join("<TD>") + CONTENT); for (i = 0; i < THICKNESS; i++) PRINT("</TABLE>"); }

// This function estimates the approximate width of each character printed on the screen and returns a number.
function EstimateWidth(TEXT)
{
// CHARSET: !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
  var Z = "00122320002201011011111111002321333333333123332323323223323010230111110110010211110101121111013";
  var $ = TEXT.length;
  var i = $, c;
  while (i--)
  {
    c = TEXT.charCodeAt(i);
    $ += (c < 32 || c > 126) ? 0 : Z.charCodeAt(c-32) - 47;
  }
  return $;
}

// FUNCTIONS PORTED FROM QBASIC


//function INPUT(s) { s = prompt(s, ""); return (s == null) ? '' : s; }
//function PRINT() { for (var i = 0; i < arguments.length; i++) document.write(arguments[i] + " "); }

// This function draws a line or rectangle.
// Color is the rrggbb color of the line.
// mode == 0 draws a line
// mode == 1 draws a dotted line
// mode == 2 draws a rectangle
// mode == 3 draws a filled box
function LINE(x1, y1, x2, y2, color, mode)
{
  var temp;             // Swap some values when necessary
  x1 = Math.round(x1);
  x2 = Math.round(x2);
  y1 = Math.round(y1);
  y2 = Math.round(y2);
  if (x1 > x2) { t = x1; x1 = x2; x2 = t; }
  if (y1 > y2) { t = y1; y1 = y2; y2 = t; }

  if (typeof(mode) == "undefined") mode = 0;

  if (mode == 3)        // Draw a filled box
  {
    document.write("<DIV STYLE='POSITION:ABSOLUTE; PADDING:0; MARGIN:0; BORDER:NONE; TOP:"+y1+"; LEFT:"+x1+"; WIDTH:"+(x2-x1+1)+"; HEIGHT:"+(y2-y1)+"; FONT-SIZE:1PX; BACKGROUND-COLOR:"+color+"'></DIV>");
  }
  else if (mode == 2)   // Draw a rectangle
  {
    document.write("<DIV STYLE='POSITION:ABSOLUTE; PADDING:0; MARGIN:0; BORDER:NONE; TOP:"+y1+"; LEFT:"+x1+"; WIDTH:1; HEIGHT:"+(y2-y1)+"; FONT-SIZE:1PX; BACKGROUND-COLOR:"+color+"'></DIV>");
    document.write("<DIV STYLE='POSITION:ABSOLUTE; PADDING:0; MARGIN:0; BORDER:NONE; TOP:"+y1+"; LEFT:"+x2+"; WIDTH:1; HEIGHT:"+(y2-y1)+"; FONT-SIZE:1PX; BACKGROUND-COLOR:"+color+"'></DIV>");
    document.write("<DIV STYLE='POSITION:ABSOLUTE; PADDING:0; MARGIN:0; BORDER:NONE; TOP:"+y1+"; LEFT:"+x1+"; WIDTH:"+(x2-x1)+"; HEIGHT:1; FONT-SIZE:1PX; BACKGROUND-COLOR:"+color+"'></DIV>");
    document.write("<DIV STYLE='POSITION:ABSOLUTE; PADDING:0; MARGIN:0; BORDER:NONE; TOP:"+y2+"; LEFT:"+x1+"; WIDTH:"+(x2-x1)+"; HEIGHT:1; FONT-SIZE:1PX; BACKGROUND-COLOR:"+color+"'></DIV>");
  }
  else if (x1 == x2)    // Draw a vertical line
  {
    document.write("<DIV STYLE='POSITION:ABSOLUTE; PADDING:0; MARGIN:0; BORDER:NONE; TOP:"+y1+"; LEFT:"+x1+"; WIDTH:1; HEIGHT:"+(y2-y1)+"; FONT-SIZE:1PX; BACKGROUND-COLOR:"+color+"'></DIV>");
  }
  else if (y1 == y2)    // Draw a horizontal line
  {
    document.write("<DIV STYLE='POSITION:ABSOLUTE; PADDING:0; MARGIN:0; BORDER:NONE; TOP:"+y1+"; LEFT:"+x1+"; WIDTH:"+(x2-x1+1)+"; HEIGHT:1; FONT-SIZE:1PX; BACKGROUND-COLOR:"+color+"'></DIV>");
  }
  else                  // Draw a slanted line
  {
    var WIDTH = x2 - x1;
    var HEIGHT = y2 - y1;
    var SLOPE = WIDTH / HEIGHT;
    var x = x1;
    for (y = y1; y < y2; y++)
    {
      if (mode == 0 || mode == 1 && y & 2)
        document.write("<DIV STYLE='POSITION:ABSOLUTE; PADDING:0; MARGIN:0; BORDER:NONE; TOP:"+y+"; LEFT:"+x+"; WIDTH:" + (SLOPE > 1 ? Math.ceil(SLOPE) : 1) + "; HEIGHT:" + (SLOPE < 1 ? Math.ceil(SLOPE) : 1) + "; FONT-SIZE:1PX; BACKGROUND-COLOR:"+color+"'></DIV>");
      x += SLOPE;
    }
  }
}

// NewString = MID$(String, String_to_Insert, Start, [Length])
//
function _MID$(String, InsertString, Start)
{
  var Len = (arguments.length > 3) ? arguments[3] : String.length;
  return String.substr(Start - 1, Len);
}