From ef0302107f99529bbfa165f308b4028f54d8d33c Mon Sep 17 00:00:00 2001 From: Baoshuo Date: Sat, 2 Apr 2022 08:57:40 +0800 Subject: [PATCH] G - Six Characters https://codeforces.com/contest/1663/submission/152441614 --- Codeforces/1663/G/G.js | 416 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 416 insertions(+) create mode 100644 Codeforces/1663/G/G.js diff --git a/Codeforces/1663/G/G.js b/Codeforces/1663/G/G.js new file mode 100644 index 00000000..54536163 --- /dev/null +++ b/Codeforces/1663/G/G.js @@ -0,0 +1,416 @@ +/*! JSFuck 0.5.0 - http://jsfuck.com */ + +const MIN = 32, + MAX = 126; + +const SIMPLE = { + false: "![]", + true: "!![]", + undefined: "[][[]]", + NaN: "+[![]]", + Infinity: "+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]]+[+[]])", // +"1e1000" +}; + +const CONSTRUCTORS = { + Array: "[]", + Number: "(+[])", + String: "([]+[])", + Boolean: "(![])", + Function: '[]["flat"]', + RegExp: 'Function("return/"+false+"/")()', + Object: '[]["entries"]()', +}; + +const MAPPING = { + a: '(false+"")[1]', + b: '([]["entries"]()+"")[2]', + c: '([]["flat"]+"")[3]', + d: '(undefined+"")[2]', + e: '(true+"")[3]', + f: '(false+"")[0]', + g: "(false+[0]+String)[20]", + h: '(+(101))["to"+String["name"]](21)[1]', + i: "([false]+undefined)[10]", + j: '([]["entries"]()+"")[3]', + k: '(+(20))["to"+String["name"]](21)', + l: '(false+"")[2]', + m: '(Number+"")[11]', + n: '(undefined+"")[1]', + o: '(true+[]["flat"])[10]', + p: '(+(211))["to"+String["name"]](31)[1]', + q: '("")["fontcolor"]([0]+false+")[20]', + r: '(true+"")[1]', + s: '(false+"")[3]', + t: '(true+"")[0]', + u: '(undefined+"")[0]', + v: '(+(31))["to"+String["name"]](32)', + w: '(+(32))["to"+String["name"]](33)', + x: '(+(101))["to"+String["name"]](34)[1]', + y: "(NaN+[Infinity])[10]", + z: '(+(35))["to"+String["name"]](36)', + + A: '(NaN+[]["entries"]())[11]', + B: "(+[]+Boolean)[10]", + C: 'Function("return escape")()(("")["italics"]())[2]', + D: 'Function("return escape")()([]["flat"])["slice"]("-1")', + E: '(RegExp+"")[12]', + F: "(+[]+Function)[10]", + G: '(false+Function("return Date")()())[30]', + H: null, + I: '(Infinity+"")[0]', + J: null, + K: null, + L: null, + M: '(true+Function("return Date")()())[30]', + N: '(NaN+"")[0]', + O: "(+[]+Object)[10]", + P: null, + Q: null, + R: "(+[]+RegExp)[10]", + S: "(+[]+String)[10]", + T: '(NaN+Function("return Date")()())[30]', + U: '(NaN+Object()["to"+String["name"]]["call"]())[11]', + V: null, + W: null, + X: null, + Y: null, + Z: null, + + " ": '(NaN+[]["flat"])[11]', + "!": null, + '"': '("")["fontcolor"]()[12]', + "#": null, + $: null, + "%": 'Function("return escape")()([]["flat"])[21]', + "&": '("")["fontcolor"](")[13]', + "'": null, + "(": '([]["flat"]+"")[13]', + ")": '([0]+false+[]["flat"])[20]', + "*": null, + "+": "(+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]])+[])[2]", + ",": '[[]]["concat"]([[]])+""', + "-": '(+(.+[0000001])+"")[2]', + ".": "(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]", + "/": '(false+[0])["italics"]()[10]', + ":": '(RegExp()+"")[3]', + ";": '("")["fontcolor"](NaN+")[21]', + "<": '("")["italics"]()[0]', + "=": '("")["fontcolor"]()[11]', + ">": '("")["italics"]()[2]', + "?": '(RegExp()+"")[2]', + "@": null, + "[": '([]["entries"]()+"")[0]', + "\\": '(RegExp("/")+"")[1]', + "]": '([]["entries"]()+"")[22]', + "^": null, + _: null, + "`": null, + "{": '(true+[]["flat"])[20]', + "|": null, + "}": '([]["flat"]+"")["slice"]("-1")', + "~": null, +}; + +const GLOBAL = 'Function("return this")()'; + +function fillMissingDigits() { + var output, number, i; + + for (number = 0; number < 10; number++) { + output = "+[]"; + + if (number > 0) { + output = "+!" + output; + } + for (i = 1; i < number; i++) { + output = "+!+[]" + output; + } + if (number > 1) { + output = output.substr(1); + } + + MAPPING[number] = "[" + output + "]"; + } +} + +function replaceMap() { + var character = "", + value, + i, + key; + + function replace(pattern, replacement) { + value = value.replace(new RegExp(pattern, "gi"), replacement); + } + + function digitReplacer(_, x) { + return MAPPING[x]; + } + + function numberReplacer(_, y) { + var values = y.split(""); + var head = +values.shift(); + var output = "+[]"; + + if (head > 0) { + output = "+!" + output; + } + for (i = 1; i < head; i++) { + output = "+!+[]" + output; + } + if (head > 1) { + output = output.substr(1); + } + + return [output] + .concat(values) + .join("+") + .replace(/(\d)/g, digitReplacer); + } + + for (i = MIN; i <= MAX; i++) { + character = String.fromCharCode(i); + value = MAPPING[character]; + if (!value) { + continue; + } + + for (key in CONSTRUCTORS) { + replace("\\b" + key, CONSTRUCTORS[key] + '["constructor"]'); + } + + for (key in SIMPLE) { + replace(key, SIMPLE[key]); + } + + replace("(\\d\\d+)", numberReplacer); + replace("\\((\\d)\\)", digitReplacer); + replace("\\[(\\d)\\]", digitReplacer); + + replace("GLOBAL", GLOBAL); + replace('\\+""', "+[]"); + replace('""', "[]+[]"); + + MAPPING[character] = value; + } +} + +function replaceStrings() { + var regEx = /[^\[\]\(\)\!\+]{1}/g, + all, + value, + missing, + count = MAX - MIN; + + function findMissing() { + var all, + value, + done = false; + + missing = {}; + + for (all in MAPPING) { + value = MAPPING[all]; + + if (value && value.match(regEx)) { + missing[all] = value; + done = true; + } + } + + return done; + } + + function mappingReplacer(a, b) { + return b.split("").join("+"); + } + + function valueReplacer(c) { + return missing[c] ? c : MAPPING[c]; + } + + for (all in MAPPING) { + if (MAPPING[all]) { + MAPPING[all] = MAPPING[all].replace( + /\"([^\"]+)\"/gi, + mappingReplacer + ); + } + } + + while (findMissing()) { + for (all in missing) { + value = MAPPING[all]; + value = value.replace(regEx, valueReplacer); + + MAPPING[all] = value; + missing[all] = value; + } + + if (count-- === 0) { + console.error("Could not compile the following chars:", missing); + } + } +} + +function escapeSequence(c) { + var cc = c.charCodeAt(0); + if (cc < 256) { + return "\\" + cc.toString(8); + } else { + var cc16 = cc.toString(16); + return "\\u" + ("0000" + cc16).substring(cc16.length); + } +} + +function escapeSequenceForReplace(c) { + return escapeSequence(c).replace("\\", "t"); +} + +function encode(input, wrapWithEval, runInParentScope) { + var output = []; + + if (!input) { + return ""; + } + + var unmappped = ""; + for (var k in MAPPING) { + if (MAPPING[k]) { + unmappped += k; + } + } + unmappped = unmappped.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); + unmappped = new RegExp("[^" + unmappped + "]", "g"); + var unmappedCharactersCount = (input.match(unmappped) || []).length; + if (unmappedCharactersCount > 1) { + // Without this optimization one unmapped caracter has encoded length + // of about 3600 characters. Every additional unmapped character adds + // 2000 to the total length. For example, the lenght of `~` is 3605, + // `~~` is 5600, and `~~~` is 7595. + // + // The loader with replace has encoded length of about 5300 characters + // and every additional character adds 100 to the total length. + // In the same example the length of `~~` becomes 5371 and `~~~` -- 5463. + // + // So, when we have more than one unmapped character we want to encode whole input + // except select characters (that have encoded length less than about 70) + // into an escape sequence. + // + // NOTE: `t` should be escaped! + input = input.replace( + /[^0123456789.adefilnrsuN]/g, + escapeSequenceForReplace + ); + } else if (unmappedCharactersCount > 0) { + //Because we will wrap the input into a string we need to escape Backslash + // and Double quote characters (we do not need to worry about other characters + // because they are not mapped explicitly). + // The JSFuck-encoded representation of `\` is 2121 symbols, + // so esacped `\` is 4243 symbols and escaped `"` is 2261 symbols + // however the escape sequence of that characters are + // 2168 and 2155 symbols respectively, so it's more practical to + // rewrite them as escape sequences. + input = input.replace(/["\\]/g, escapeSequence); + //Convert all unmapped characters to escape sequence + input = input.replace(unmappped, escapeSequence); + } + + var r = ""; + for (var i in SIMPLE) { + r += i + "|"; + } + r += "."; + + input.replace(new RegExp(r, "g"), function (c) { + var replacement = SIMPLE[c]; + if (replacement) { + output.push("(" + replacement + "+[])"); + } else { + replacement = MAPPING[c]; + if (replacement) { + output.push(replacement); + } else { + throw new Error("Found unmapped character: " + c); + } + } + }); + + output = output.join("+"); + + if (/^\d$/.test(input)) { + output += "+[]"; + } + + if (unmappedCharactersCount > 1) { + // replace `t` with `\\` + output = + "(" + + output + + ")[" + + encode("split") + + "](" + + encode("t") + + ")[" + + encode("join") + + "](" + + encode("\\") + + ")"; + } + + if (unmappedCharactersCount > 0) { + output = + "[][" + + encode("flat") + + "]" + + "[" + + encode("constructor") + + "]" + + "(" + + encode('return"') + + "+" + + output + + "+" + + encode('"') + + ")()"; + } + + if (wrapWithEval) { + if (runInParentScope) { + output = + "[][" + + encode("flat") + + "]" + + "[" + + encode("constructor") + + "]" + + "(" + + encode("return eval") + + ")()" + + "(" + + output + + ")"; + } else { + output = + "[][" + + encode("flat") + + "]" + + "[" + + encode("constructor") + + "]" + + "(" + + output + + ")()"; + } + } + + return output; +} + +fillMissingDigits(); +replaceMap(); +replaceStrings(); + +/* ============================================= */ + +print(encode(readline()));