0
1
mirror of https://git.sb/baoshuo/OI-codes.git synced 2024-12-25 16:52:00 +00:00
OI-codes/Codeforces/1663/G/G.js

417 lines
11 KiB
JavaScript

/*! 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()));