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()));