"use strict"; return (function f(n){ if (n <= 0) { return "foo"; } return f(n - 1); }(1e6)) === "foo";

"use strict"; function f(n){ if (n <= 0) { return "foo"; } return g(n - 1); } function g(n){ if (n <= 0) { return "bar"; } return f(n - 1); } return f(1e6) === "foo" && f(1e6+1) === "bar";

return (function (a = 1, b = 2) { return a === 3 && b === 2; }(3));

return (function (a = 1, b = 2) { return a === 1 && b === 3; }(undefined, 3));

return (function (a, b = a) { return b === 5; }(5));

return (function (a = "baz", b = "qux", c = "quux") { a = "corge"; // The arguments object is not mapped to the // parameters, even outside of strict mode. return arguments.length === 2 && arguments[0] === "foo" && arguments[1] === "bar"; }("foo", "bar"));

return (function(x = 1) { try { eval("(function(a=a){}())"); return false; } catch(e) {} try { eval("(function(a=b,b){}())"); return false; } catch(e) {} return true; }());

return (function(a=function(){ return typeof b === 'undefined'; }){ var b = 1; return a(); }());

return new Function("a = 1", "b = 2", "return a === 3 && b === 2;" )(3);

return (function (foo, ...args) { return args instanceof Array && args + "" === "bar,baz"; }("foo", "bar", "baz"));

return function(a, ...b){}.length === 1 && function(...c){}.length === 0;

return (function (foo, ...args) { foo = "qux"; // The arguments object is not mapped to the // parameters, even outside of strict mode. return arguments.length === 3 && arguments[0] === "foo" && arguments[1] === "bar" && arguments[2] === "baz"; }("foo", "bar", "baz"));

return (function (...args) { try { eval("({set e(...args){}})"); } catch(e) { return true; } }());

return new Function("a", "...b", "return b instanceof Array && a+b === 'foobar,baz';" )('foo','bar','baz');

return Math.max(...[1, 2, 3]) === 3

return [...[1, 2, 3]][2] === 3;

var a = Array(...[,,]); return "0" in a && "1" in a && '' + a[0] + a[1] === "undefinedundefined";

var a = [...[,,]]; return "0" in a && "1" in a && '' + a[0] + a[1] === "undefinedundefined";

return Math.max(..."1234") === 4;

return ["a", ..."bcd", "e"][3] === "d";

return Array(..."𠮷𠮶")[0] === "𠮷";

return [..."𠮷𠮶"][0] === "𠮷";

var iterable = (function*(){ yield 1; yield 2; yield 3; }()); return Math.max(...iterable) === 3;

var iterable = (function*(){ yield "b"; yield "c"; yield "d"; }()); return ["a", ...iterable, "e"][3] === "d";

var iterable = global.__createIterableObject([1, 2, 3]); return Math.max(...iterable) === 3;

var iterable = global.__createIterableObject(["b", "c", "d"]); return ["a", ...iterable, "e"][3] === "d";

var iterable = global.__createIterableObject([1, 2, 3]); return Math.max(...Object.create(iterable)) === 3;

var iterable = global.__createIterableObject(["b", "c", "d"]); return ["a", ...Object.create(iterable), "e"][3] === "d";

try { Math.max(...2); } catch(e) { return Math.max(...[1, 2, 3]) === 3; }

var x = 'y'; return ({ [x]: 1 }).y === 1;

var a = 7, b = 8, c = {a,b}; return c.a === 7 && c.b === 8;

return ({ y() { return 2; } }).y() === 2;

return ({ "foo bar"() { return 4; } })["foo bar"]() === 4;

var x = 'y'; return ({ [x](){ return 1 } }).y() === 1;

var x = 'y', valueSet, obj = { get [x] () { return 1 }, set [x] (value) { valueSet = value } }; obj.y = 'foo'; return obj.y === 1 && valueSet === 'foo';

var arr = [5]; for (var item of arr) return item === 5;

var arr = [,,]; var count = 0; for (var item of arr) count += (item === void undefined); return count === 2;

var str = ""; for (var item of "foo") str += item; return str === "foo";

var str = ""; for (var item of "𠮷𠮶") str += item + " "; return str === "𠮷 𠮶 ";

var result = ""; var iterable = (function*(){ yield 1; yield 2; yield 3; }()); for (var item of iterable) { result += item; } return result === "123";

var result = ""; var iterable = global.__createIterableObject([1, 2, 3]); for (var item of iterable) { result += item; } return result === "123";

var result = ""; var iterable = global.__createIterableObject([1, 2, 3]); for (var item of Object.create(iterable)) { result += item; } return result === "123";

var closed = false; var iter = __createIterableObject([1, 2, 3], { 'return': function(){ closed = true; return {}; } }); for (var it of iter) break; return closed;

var closed = false; var iter = __createIterableObject([1, 2, 3], { 'return': function(){ closed = true; return {}; } }); try { for (var it of iter) throw 0; } catch(e){} return closed;

return 0o10 === 8 && 0O10 === 8;

return 0b10 === 2 && 0B10 === 2;

return Number('0o1') === 1;

return Number('0b1') === 1;

var a = "ba", b = "QUX"; return `foo bar ${a + "z"} ${b.toLowerCase()}` === "foo bar\nbaz qux";

var a = { toString: function() { return "foo"; }, valueOf: function() { return "bar"; } }; return `${a}` === "foo";

var called = false; function fn(parts, a, b) { called = true; return parts instanceof Array && parts[0] === "foo" && parts[1] === "bar\n" && parts.raw[0] === "foo" && parts.raw[1] === "bar\\n" && a === 123 && b === 456; } return fn `foo${123}bar\n${456}` && called;

return (function(parts) { return Object.isFrozen(parts) && Object.isFrozen(parts.raw); }) `foo${0}bar${0}baz`;

var cr = eval("`x" + String.fromCharCode(13) + "y`"); var lf = eval("`x" + String.fromCharCode(10) + "y`"); var crlf = eval("`x" + String.fromCharCode(13,10) + "y`"); return cr.length === 3 && lf.length === 3 && crlf.length === 3 && cr[1] === lf[1] && lf[1] === crlf[1] && crlf[1] === '\n';

// TemplateStrings caching was changed from per-contents to // per-call-site. // https://github.com/tc39/ecma262/pull/890 function strings(array) { return array; } function getStrings() { return strings`foo`; } var original = getStrings(); var other = strings`foo`; return original === getStrings() && original !== other;

function strings(array) { return array; } function getStrings() { return strings`foo`; } var original = getStrings(); var newed = new getStrings(); return original === getStrings() && original === newed;

var re = new RegExp('\\w', 'y'); re.exec('xy'); return (re.exec('xy')[0] === 'y');

var re = new RegExp('yy', 'y'); re.lastIndex = 3; var result = re.exec('xxxyyxx')[0]; return result === 'yy' && re.lastIndex === 5;

return "𠮷".match(/^.$/u)[0].length === 2;

return "𠮷x".match(/^.x$/u)[0].length === 3;

return "𝌆".match(/\u{1d306}/u)[0].length === 2;

return "ſ".match(/S/iu) && "S".match(/ſ/iu);

var [a, , [b], c] = [5, null, [6]]; return a === 5 && b === 6 && c === void undefined;

var [a, , b] = [,,,]; return a === void undefined && b === void undefined;

var [a, b, c] = "ab"; return a === "a" && b === "b" && c === void undefined;

var [c] = "𠮷𠮶"; return c === "𠮷";

var [a, b, c] = (function*(){ yield 1; yield 2; }()); return a === 1 && b === 2 && c === void undefined;

var [a, b, c] = global.__createIterableObject([1, 2]); return a === 1 && b === 2 && c === void undefined;

var [a, b, c] = Object.create(global.__createIterableObject([1, 2])); return a === 1 && b === 2 && c === void undefined;

var closed = false; var iter = global.__createIterableObject([1, 2, 3], { 'return': function(){ closed = true; return {}; } }); var [a, b] = iter; return closed;

var [a,] = [1]; return a === 1;

var {c, x:d, e} = {c:7, x:8}; return c === 7 && d === 8 && e === void undefined;

var {toFixed} = 2; var {slice} = ''; return toFixed === Number.prototype.toFixed && slice === String.prototype.slice;

var {a,} = {a:1}; return a === 1;

try { var {a} = null; return false; } catch(e) { if (!(e instanceof TypeError)) return false; } try { var {b} = void undefined; return false; } catch(e) { if (!(e instanceof TypeError)) return false; } return true;

var qux = "corge"; var { [qux]: grault } = { corge: "garply" }; return grault === "garply";

var [a,b] = [5,6], {c,d} = {c:7,d:8}; return a === 5 && b === 6 && c === 7 && d === 8;

var [e, {x:f, g}] = [9, {x:10}]; var {h, x:[i]} = {h:11, x:[12]}; return e === 9 && f === 10 && g === void undefined && h === 11 && i === 12;

for(var [i, j, k] in { qux: 1 }) { return i === "q" && j === "u" && k === "x"; }

for(var [i, j, k] of [[1,2,3]]) { return i === 1 && j === 2 && k === 3; }

try { throw [1,2]; } catch([i,j]) { try { throw { k: 3, l: 4 }; } catch({k, l}) { return i === 1 && j === 2 && k === 3 && l === 4; } }

var [a, ...b] = [3, 4, 5]; var [c, ...d] = [6]; return a === 3 && b instanceof Array && (b + "") === "4,5" && c === 6 && d instanceof Array && d.length === 0;

var {a = 1, b = 0, z:c = 3} = {b:2, z:undefined}; var [d = 0, e = 5, f = 6] = [4,,undefined]; return a === 1 && b === 2 && c === 3 && d === 4 && e === 5 && f === 6;

var {a, b = 2} = {a:1}; try { eval("let {c = c} = {};"); return false; } catch(e){} try { eval("let {c = d, d} = {d:1};"); return false; } catch(e){} return a === 1 && b === 2;

var a,b,c; [a, , [b], c] = [5, null, [6]]; return a === 5 && b === 6 && c === void undefined;

var a, b; [a, , b] = [,,,]; return a === void undefined && b === void undefined;

var a,b,c; [a, b, c] = "ab"; return a === "a" && b === "b" && c === void undefined;

var c; [c] = "𠮷𠮶"; return c === "𠮷";

var a,b,c; [a, b, c] = (function*(){ yield 1; yield 2; }()); return a === 1 && b === 2 && c === void undefined;

var a,b,c; [a, b, c] = global.__createIterableObject([1, 2]); return a === 1 && b === 2 && c === void undefined;

var a,b,c; [a, b, c] = Object.create(global.__createIterableObject([1, 2])); return a === 1 && b === 2 && c === void undefined;

var closed = false; var iter = global.__createIterableObject([1, 2, 3], { 'return': function(){ closed = true; return {}; } }); var a,b; [a, b] = iter; return closed;

var a, b, iterable = [1,2]; return ([a, b] = iterable) === iterable;

var a,b,c,d; [a,b] = [c,d] = [1,2]; return a === 1 && b === 2 && c === 1 && d === 2;

var a; [a,] = [1]; return a === 1;

var c,d,e; ({c, x:d, e} = {c:7, x:8}); return c === 7 && d === 8 && e === void undefined;

var toFixed, slice; ({toFixed} = 2); ({slice} = ''); return toFixed === Number.prototype.toFixed && slice === String.prototype.slice;

var a; ({a,} = {a:1}); return a === 1;

var a, b, obj = { a:1, b:2 }; return ({a,b} = obj) === obj;

var a, b; ({a,b} = {a:1,b:2}); try { eval("({a,b}) = {a:3,b:4};"); } catch(e) { return a === 1 && b === 2; }

var a,b,c,d; ({a,b} = {c,d} = {a:1,b:2,c:3,d:4}); return a === 1 && b === 2 && c === 3 && d === 4;

var a,b; try { ({a} = null); return false; } catch(e) { if (!(e instanceof TypeError)) return false; } try { ({b} = void undefined); return false; } catch(e) { if (!(e instanceof TypeError)) return false; } return true;

var grault, qux = "corge"; ({ [qux]: grault } = { corge: "garply" }); return grault === "garply";

var e,f,g,h,i; [e, {x:f, g}] = [9, {x:10}]; ({h, x:[i]} = {h:11, x:[12]}); return e === 9 && f === 10 && g === void undefined && h === 11 && i === 12;

var a,b,c,d; [a, ...b] = [3, 4, 5]; [c, ...d] = [6]; return a === 3 && b instanceof Array && (b + "") === "4,5" && c === 6 && d instanceof Array && d.length === 0;

var a = [1, 2, 3], first, last; [first, ...[a[2], last]] = a; return first === 1 && last === 3 && (a + "") === "1,2,2";

[] = [1,2]; ({} = {a:1,b:2}); return true;

var a,b,c,d,e,f; ({a = 1, b = 0, z:c = 3} = {b:2, z:undefined}); [d = 0, e = 5, f = 6] = [4,,undefined]; return a === 1 && b === 2 && c === 3 && d === 4 && e === 5 && f === 6;

return function([a, , [b], c]) { return a === 5 && b === 6 && c === void undefined; }([5, null, [6]]);

return function([a, , b]) { return a === void undefined && b === void undefined; }([,,,]);

return function([a, b, c]) { return a === "a" && b === "b" && c === void undefined; }("ab");

return function([c]) { return c === "𠮷"; }("𠮷𠮶");

return function([a, b, c]) { return a === 1 && b === 2 && c === void undefined; }(function*(){ yield 1; yield 2; }());

return function([a, b, c]) { return a === 1 && b === 2 && c === void undefined; }(global.__createIterableObject([1, 2]));

return function([a, b, c]) { return a === 1 && b === 2 && c === void undefined; }(Object.create(global.__createIterableObject([1, 2])));

var closed = false; var iter = global.__createIterableObject([1, 2, 3], { 'return': function(){ closed = true; return {}; } }); (function([a,b]) {}(iter)); return closed;

return function([a,]) { return a === 1; }([1]);

return function({c, x:d, e}) { return c === 7 && d === 8 && e === void undefined; }({c:7, x:8});

return function({toFixed}, {slice}) { return toFixed === Number.prototype.toFixed && slice === String.prototype.slice; }(2,'');

return function({a,}) { return a === 1; }({a:1});

try { (function({a}){}(null)); return false; } catch(e) {} try { (function({b}){}(undefined)); return false; } catch(e) {} return true;

var qux = "corge"; return function({ [qux]: grault }) { return grault === "garply"; }({ corge: "garply" });

return function([e, {x:f, g}], {h, x:[i]}) { return e === 9 && f === 10 && g === void undefined && h === 11 && i === 12; }([9, {x:10}],{h:11, x:[12]});

return (function({a, x:b, y:e}, [c, d]) { return arguments[0].a === 1 && arguments[0].x === 2 && !("y" in arguments[0]) && arguments[1] + '' === "3,4"; }({a:1, x:2}, [3, 4]));

return new Function("{a, x:b, y:e}","[c, d]", "return a === 1 && b === 2 && c === 3 && " + "d === 4 && e === void undefined;" )({a:1, x:2}, [3, 4]);

return function({a, b}, [c, d]){}.length === 2;

return function([a, ...b], [c, ...d]) { return a === 3 && b instanceof Array && (b + "") === "4,5" && c === 6 && d instanceof Array && d.length === 0; }([3, 4, 5], [6]);

return function ([],{}){ return arguments[0] + '' === "3,4" && arguments[1].x === "foo"; }([3,4],{x:"foo"});

return (function({a = 1, b = 0, c = 3, x:d = 0, y:e = 5}, [f = 6, g = 0, h = 8]) { return a === 1 && b === 2 && c === 3 && d === 4 && e === 5 && f === 6 && g === 7 && h === 8; }({b:2, c:undefined, x:4},[, 7, undefined]));

return (function({a=function(){ return typeof b === 'undefined'; }}){ var b = 1; return a(); }({}));

return new Function("{a = 1, b = 0, c = 3, x:d = 0, y:e = 5}", "return a === 1 && b === 2 && c === 3 && d === 4 && e === 5;" )({b:2, c:undefined, x:4});

return ((a, {b: x = 0, c: y = 3}) => { return a === 1 && x === 2 && y === 3; })(1, {b: 2});

return ((a, {b = 0, c = 3}) => { return a === 1 && b === 2 && c === 3; })(1, {b: 2});

try { eval('var d = function d([d]) { return d };'); if (d([true]) !== true) return false; } catch (e) { return !(e instanceof SyntaxError); } try { eval('var f = function f([id, id]) { return id }'); return false; } catch (e) { return e instanceof SyntaxError; }

return '\u{1d306}' === '\ud834\udf06';

var \u{102C0} = 2; return \u{102C0} === 2;

var o = { \u{102C0} : 2 }; return o['\ud800\udec0'] === 2;

var o = { '\ud800\udec0' : 2 }; return o.\u{102C0} === 2;

var passed = false; new function f() { passed = (new.target === f); }(); (function() { passed &= (new.target === void undefined); }()); return passed;

var passed = false; new function f() { passed = (new.target === f); }(); try { Function("new.target = function(){};"); } catch(e) { return passed; }

const foo = 123; return (foo === 123);

const bar = 123; { const bar = 456; } return bar === 123;

try { { const bar = 456; } const bar = 123; return bar === 123; } catch(e) { return false; }

const bar = 1; try { Function("if(true) const baz = 1;")(); } catch(e) { return true; }

const baz = 1; try { Function("const foo = 1; foo = 2;")(); } catch(e) { return true; }

const baz = 1; for(const baz = 0; false;) {} return baz === 1;

var scopes = []; for(const i in { a:1, b:1 }) { scopes.push(function(){ return i; }); } return (scopes[0]() === "a" && scopes[1]() === "b");

var scopes = []; for(const i of ['a','b']) { scopes.push(function(){ return i; }); } return (scopes[0]() === "a" && scopes[1]() === "b");

var passed = (function(){ try { qux; } catch(e) { return true; }}()); function fn() { passed &= qux === 456; } const qux = 456; fn(); return passed;

"use strict"; const foo = 123; return (foo === 123);

'use strict'; const bar = 123; { const bar = 456; } return bar === 123;

'use strict'; try { { const bar = 456; } const bar = 123; return bar === 123; } catch(e) { return false; }

'use strict'; const bar = 1; try { Function("'use strict'; if(true) const baz = 1;")(); } catch(e) { return true; }

'use strict'; const baz = 1; try { Function("'use strict'; const foo = 1; foo = 2;")(); } catch(e) { return true; }

'use strict'; const baz = 1; for(const baz = 0; false;) {} return baz === 1;

'use strict'; var scopes = []; for(const i in { a:1, b:1 }) { scopes.push(function(){ return i; }); } return (scopes[0]() === "a" && scopes[1]() === "b");

'use strict'; var scopes = []; for(const i of ['a','b']) { scopes.push(function(){ return i; }); } return (scopes[0]() === "a" && scopes[1]() === "b");

'use strict'; var passed = (function(){ try { qux; } catch(e) { return true; }}()); function fn() { passed &= qux === 456; } const qux = 456; fn(); return passed;

let foo = 123; return (foo === 123);

let bar = 123; { let bar = 456; } return bar === 123;

try { { let bar = 456; } let bar = 123; return bar === 123; } catch(e) { return false; }

let bar = 1; try { Function("if(true) let baz = 1;")(); } catch(e) { return true; }

let baz = 1; for(let baz = 0; false;) {} return baz === 1;

var passed = (function(){ try { qux; } catch(e) { return true; }}()); function fn() { passed &= qux === 456; } let qux = 456; fn(); return passed;

let scopes = []; for(let i = 0; i < 2; i++) { scopes.push(function(){ return i; }); } let passed = (scopes[0]() === 0 && scopes[1]() === 1); scopes = []; for(let i in { a:1, b:1 }) { scopes.push(function(){ return i; }); } passed &= (scopes[0]() === "a" && scopes[1]() === "b"); return passed;

try { Function("function f(e) { for (let e in {}) e }"); return true; } catch(e) { return false; }

'use strict'; let foo = 123; return (foo === 123);

'use strict'; let bar = 123; { let bar = 456; } return bar === 123;

'use strict'; try { { let bar = 456; } let bar = 123; return bar === 123; } catch(e) { return false; }

'use strict'; let bar = 1; try { Function("'use strict'; if(true) let baz = 1;")(); } catch(e) { return true; }

'use strict'; let baz = 1; for(let baz = 0; false;) {} return baz === 1;

'use strict'; var passed = (function(){ try { qux; } catch(e) { return true; }}()); function fn() { passed &= qux === 456; } let qux = 456; fn(); return passed;

'use strict'; let scopes = []; for(let i = 0; i < 2; i++) { scopes.push(function(){ return i; }); } let passed = (scopes[0]() === 0 && scopes[1]() === 1); scopes = []; for(let i in { a:1, b:1 }) { scopes.push(function(){ return i; }); } passed &= (scopes[0]() === "a" && scopes[1]() === "b"); return passed;

try { Function("'use strict'; function f(e) { for (let e in {}) e }"); return true; } catch(e) { return false; }

'use strict'; if (f() !== 1) return false; function f() { return 1; } { if (f() !== 2) return false; function f() { return 2; } if (f() !== 2) return false; } if (f() !== 1) return false; return true;

return (() => 5)() === 5;

var b = x => x + "foo"; return (b("fee fie foe ") === "fee fie foe foo");

var c = (v, w, x, y, z) => "" + v + w + x + y + z; return (c(6, 5, 4, 3, 2) === "65432");

var d = { x : "bar", y : function() { return z => this.x + z; }}.y(); var e = { x : "baz", y : d }; return d("ley") === "barley" && e.y("ley") === "barley";

var d = { x : "foo", y : function() { return () => this.x; }}; var e = { x : "bar" }; return d.y().call(e) === "foo" && d.y().apply(e) === "foo";

var d = { x : "bar", y : function() { return z => this.x + z; }}; var e = { x : "baz" }; return d.y().bind(e, "ley")() === "barley";

var f = (function() { return z => arguments[0]; }(5)); return f(6) === 5;

return (() => { try { Function("x\n => 2")(); } catch(e) { return true; } })();

return (() => { try { Function("0 || () => 2")(); } catch(e) { return true; } })();

var a = () => 5; return !a.hasOwnProperty("prototype");

var received; class B { constructor (arg) { received = arg; } } class C extends B { constructor () { var callSuper = () => super('foo'); callSuper(); } } return new C instanceof C && received === 'foo'

class B { qux() { return "quux"; } } class C extends B { baz() { return x => super.qux(); } } var arrow = new C().baz(); return arrow() === "quux";

function C() { return x => new.target; } return new C()() === C && C()() === void undefined;

class C {} return typeof C === "function";

class C {} var c1 = C; { class C {} var c2 = C; } return C === c1;

return typeof class C {} === "function";

return typeof class {} === "function";

class C { constructor() { this.x = 1; } } return C.prototype.constructor === C && new C().x === 1;

class C { method() { return 2; } } return typeof C.prototype.method === "function" && new C().method() === 2;

class C { "foo bar"() { return 2; } } return typeof C.prototype["foo bar"] === "function" && new C()["foo bar"]() === 2;

var foo = "method"; class C { [foo]() { return 2; } } return typeof C.prototype.method === "function" && new C().method() === 2;

class C { ; method() { return 2; }; method2() { return 2; } method3() { return 2; }; } return typeof C.prototype.method === "function" && typeof C.prototype.method2 === "function" && typeof C.prototype.method3 === "function";

class C { static method() { return 3; } } return typeof C.method === "function" && C.method() === 3;

var foo = "method"; class C { static [foo]() { return 3; } } return typeof C.method === "function" && C.method() === 3;

var baz = false; class C { get foo() { return "foo"; } set bar(x) { baz = x; } } new C().bar = true; return new C().foo === "foo" && baz;

var garply = "foo", grault = "bar", baz = false; class C { get [garply]() { return "foo"; } set [grault](x) { baz = x; } } new C().bar = true; return new C().foo === "foo" && baz;

var baz = false; class C { static get foo() { return "foo"; } static set bar(x) { baz = x; } } C.bar = true; return C.foo === "foo" && baz;

var garply = "foo", grault = "bar", baz = false; class C { static get [garply]() { return "foo"; } static set [grault](x) { baz = x; } } C.bar = true; return C.foo === "foo" && baz;

class C { method() { return typeof C === "function"; } } var M = C.prototype.method; C = void undefined; return C === void undefined && M();

try { var B = class C { [C](){} } } catch(e) { return true; }

class C { foo() {} static bar() {} } return !C.prototype.propertyIsEnumerable("foo") && !C.propertyIsEnumerable("bar");

class C { static method() { return this === void undefined; } } return (0,C.method)();

class C {} try { C(); } catch(e) { return true; }

class B {} class C extends B {} return new C() instanceof B && B.isPrototypeOf(C);

var B; class C extends (B = class {}) {} return new C() instanceof B && B.isPrototypeOf(C);

class C extends null { constructor() { return Object.create(null); } } return Function.prototype.isPrototypeOf(C) && Object.getPrototypeOf(C.prototype) === null;