diff options
Diffstat (limited to 'src/3rdparty/v8/test/mjsunit')
207 files changed, 20933 insertions, 14807 deletions
diff --git a/src/3rdparty/v8/test/mjsunit/accessor-map-sharing.js b/src/3rdparty/v8/test/mjsunit/accessor-map-sharing.js new file mode 100644 index 0000000..3afce37 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/accessor-map-sharing.js @@ -0,0 +1,192 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +// Handy abbreviations. +var dp = Object.defineProperty; +var gop = Object.getOwnPropertyDescriptor; + +function getter() { return 111; } +function setter(x) { print(222); } +function anotherGetter() { return 333; } +function anotherSetter(x) { print(444); } +var obj1, obj2, obj3, obj4; + +// Two objects with the same getter. +obj1 = {}; +dp(obj1, "alpha", { get: getter }); +obj2 = {}; +dp(obj2, "alpha", { get: getter }); +assertTrue(%HaveSameMap(obj1, obj2)); + +// Two objects with the same getter, oldskool. +obj1 = {}; +obj1.__defineGetter__("bravo", getter); +assertEquals(getter, obj1.__lookupGetter__("bravo")); +obj2 = {}; +obj2.__defineGetter__("bravo", getter); +assertEquals(getter, obj2.__lookupGetter__("bravo")); +assertTrue(%HaveSameMap(obj1, obj2)); + +// Two objects with the same setter. +obj1 = {}; +dp(obj1, "charlie", { set: setter }); +obj2 = {}; +dp(obj2, "charlie", { set: setter }); +assertTrue(%HaveSameMap(obj1, obj2)); + +// Two objects with the same setter, oldskool. +obj1 = {}; +obj1.__defineSetter__("delta", setter); +assertEquals(setter, obj1.__lookupSetter__("delta")); +obj2 = {}; +obj2.__defineSetter__("delta", setter); +assertEquals(setter, obj2.__lookupSetter__("delta")); +assertTrue(%HaveSameMap(obj1, obj2)); + +// Two objects with the same getter and setter. +obj1 = {}; +dp(obj1, "foxtrot", { get: getter, set: setter }); +obj2 = {}; +dp(obj2, "foxtrot", { get: getter, set: setter }); +assertTrue(%HaveSameMap(obj1, obj2)); + +// Two objects with the same getter and setter, set separately. +obj1 = {}; +dp(obj1, "golf", { get: getter, configurable: true }); +dp(obj1, "golf", { set: setter, configurable: true }); +obj2 = {}; +dp(obj2, "golf", { get: getter, configurable: true }); +dp(obj2, "golf", { set: setter, configurable: true }); +assertTrue(%HaveSameMap(obj1, obj2)); + +// Two objects with the same getter and setter, set separately, oldskool. +obj1 = {}; +obj1.__defineGetter__("hotel", getter); +obj1.__defineSetter__("hotel", setter); +obj2 = {}; +obj2.__defineGetter__("hotel", getter); +obj2.__defineSetter__("hotel", setter); +assertTrue(%HaveSameMap(obj1, obj2)); + +// Attribute-only change, shouldn't affect previous descriptor properties. +obj1 = {}; +dp(obj1, "india", { get: getter, configurable: true, enumerable: true }); +assertEquals(getter, gop(obj1, "india").get); +assertTrue(gop(obj1, "india").configurable); +assertTrue(gop(obj1, "india").enumerable); +dp(obj1, "india", { enumerable: false }); +assertEquals(getter, gop(obj1, "india").get); +assertTrue(gop(obj1, "india").configurable); +assertFalse(gop(obj1, "india").enumerable); + +// Attribute-only change, shouldn't affect objects with previously shared maps. +obj1 = {}; +dp(obj1, "juliet", { set: setter, configurable: true, enumerable: false }); +assertEquals(setter, gop(obj1, "juliet").set); +assertTrue(gop(obj1, "juliet").configurable); +assertFalse(gop(obj1, "juliet").enumerable); +obj2 = {}; +dp(obj2, "juliet", { set: setter, configurable: true, enumerable: false }); +assertEquals(setter, gop(obj2, "juliet").set); +assertTrue(gop(obj2, "juliet").configurable); +assertFalse(gop(obj2, "juliet").enumerable); +dp(obj1, "juliet", { set: setter, configurable: false, enumerable: true }); +assertEquals(setter, gop(obj1, "juliet").set); +assertFalse(gop(obj1, "juliet").configurable); +assertTrue(gop(obj1, "juliet").enumerable); +assertEquals(setter, gop(obj2, "juliet").set); +assertTrue(gop(obj2, "juliet").configurable); +assertFalse(gop(obj2, "juliet").enumerable); + +// Two objects with the different getters. +obj1 = {}; +dp(obj1, "kilo", { get: getter }); +obj2 = {}; +dp(obj2, "kilo", { get: anotherGetter }); +assertEquals(getter, gop(obj1, "kilo").get); +assertEquals(anotherGetter, gop(obj2, "kilo").get); +assertFalse(%HaveSameMap(obj1, obj2)); + +// Two objects with the same getters and different setters. +obj1 = {}; +dp(obj1, "lima", { get: getter, set: setter }); +obj2 = {}; +dp(obj2, "lima", { get: getter, set: anotherSetter }); +assertEquals(setter, gop(obj1, "lima").set); +assertEquals(anotherSetter, gop(obj2, "lima").set); +assertFalse(%HaveSameMap(obj1, obj2)); + +// Even 'undefined' is a kind of getter. +obj1 = {}; +dp(obj1, "mike", { get: undefined }); +assertTrue("mike" in obj1); +assertEquals(undefined, gop(obj1, "mike").get); +assertEquals(undefined, obj1.__lookupGetter__("mike")); +assertEquals(undefined, gop(obj1, "mike").set); +assertEquals(undefined, obj1.__lookupSetter__("mike")); + +// Even 'undefined' is a kind of setter. +obj1 = {}; +dp(obj1, "november", { set: undefined }); +assertTrue("november" in obj1); +assertEquals(undefined, gop(obj1, "november").get); +assertEquals(undefined, obj1.__lookupGetter__("november")); +assertEquals(undefined, gop(obj1, "november").set); +assertEquals(undefined, obj1.__lookupSetter__("november")); + +// Redefining a data property. +obj1 = {}; +obj1.oscar = 12345; +dp(obj1, "oscar", { set: setter }); +assertEquals(setter, gop(obj1, "oscar").set); + +// Re-adding the same getter/attributes pair. +obj1 = {}; +dp(obj1, "papa", { get: getter, configurable: true }); +dp(obj1, "papa", { get: getter, set: setter, configurable: true }); +assertEquals(getter, gop(obj1, "papa").get); +assertEquals(setter, gop(obj1, "papa").set); +assertTrue(gop(obj1, "papa").configurable); +assertFalse(gop(obj1, "papa").enumerable); + +// Two objects with the same getter on the prototype chain. +obj1 = {}; +dp(obj1, "quebec", { get: getter }); +obj2 = Object.create(obj1); +obj3 = Object.create(obj2); +obj4 = Object.create(obj2); +assertTrue(%HaveSameMap(obj3, obj4)); + +// Two objects with the same setter on the prototype chain. +obj1 = {}; +dp(obj1, "romeo", { set: setter }); +obj2 = Object.create(obj1); +obj3 = Object.create(obj2); +obj4 = Object.create(obj2); +assertTrue(%HaveSameMap(obj3, obj4)); diff --git a/src/3rdparty/v8/test/mjsunit/array-bounds-check-removal.js b/src/3rdparty/v8/test/mjsunit/array-bounds-check-removal.js index 81064aa..df7988b 100644 --- a/src/3rdparty/v8/test/mjsunit/array-bounds-check-removal.js +++ b/src/3rdparty/v8/test/mjsunit/array-bounds-check-removal.js @@ -29,6 +29,29 @@ var a = new Int32Array(1024); +// Test that we do not assert if the accessed index has not an int32 rep. +var v = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; +function test_do_not_assert_on_non_int32(vector, base) { + var r = 0; + var a1 = base + 1; + var a2 = base + 2; + var a3 = base + 3; + var a4 = base + 4; + if (a1 == 2) { + r += vector[a1]; + r += vector[a4]; + r += vector[a2]; + r += vector[a3]; + } + return r; +} +test_do_not_assert_on_non_int32(v,1); +test_do_not_assert_on_non_int32(v,1); +test_do_not_assert_on_non_int32(v,"a"); +test_do_not_assert_on_non_int32(v,"a"); +%OptimizeFunctionOnNextCall(test_do_not_assert_on_non_int32); +test_do_not_assert_on_non_int32(v,0); + function test_base(base,cond) { a[base + 1] = 1; a[base + 4] = 2; @@ -123,7 +146,7 @@ check_test_minus(7,false); // ALWAYS: 3 // NEVER: 4 -if (false) { +// Test that we still deopt on failed bound checks test_base(5,true); test_base(6,true); test_base(5,false); @@ -139,7 +162,21 @@ test_base(6,false); %OptimizeFunctionOnNextCall(test_base); test_base(2048,true); assertTrue(%GetOptimizationStatus(test_base) != 1); + +// Specific test on negative offsets +var short_a = new Array(100); +for (var i = 0; i < short_a.length; i++) short_a[i] = 0; +function short_test(a, i) { + a[i + 9] = 0; + a[i - 10] = 0; } +short_test(short_a, 50); +short_test(short_a, 50); +%OptimizeFunctionOnNextCall(short_test); +short_a.length = 10; +short_test(a, 0); +assertTrue(%GetOptimizationStatus(short_test) != 1); + gc(); diff --git a/src/3rdparty/v8/test/mjsunit/array-construct-transition.js b/src/3rdparty/v8/test/mjsunit/array-construct-transition.js index 577e321..f8d7c83 100644 --- a/src/3rdparty/v8/test/mjsunit/array-construct-transition.js +++ b/src/3rdparty/v8/test/mjsunit/array-construct-transition.js @@ -27,13 +27,13 @@ // Flags: --allow-natives-syntax --smi-only-arrays -support_smi_only_arrays = %HasFastSmiOnlyElements(new Array(1,2,3,4,5,6,7,8)); +support_smi_only_arrays = %HasFastSmiElements(new Array(1,2,3,4,5,6)); if (support_smi_only_arrays) { var a = new Array(0, 1, 2); - assertTrue(%HasFastSmiOnlyElements(a)); + assertTrue(%HasFastSmiElements(a)); var b = new Array(0.5, 1.2, 2.3); assertTrue(%HasFastDoubleElements(b)); var c = new Array(0.5, 1.2, new Object()); - assertTrue(%HasFastElements(c)); + assertTrue(%HasFastObjectElements(c)); } diff --git a/src/3rdparty/v8/test/mjsunit/array-iteration.js b/src/3rdparty/v8/test/mjsunit/array-iteration.js index 0ee2e6e..033bb54 100644 --- a/src/3rdparty/v8/test/mjsunit/array-iteration.js +++ b/src/3rdparty/v8/test/mjsunit/array-iteration.js @@ -40,7 +40,7 @@ // Simple use. var a = [0,1]; assertArrayEquals([0], a.filter(function(n) { return n == 0; })); - assertArrayEquals(a, a); + assertArrayEquals([0,1], a); // Use specified object as this object when calling the function. var o = { value: 42 } diff --git a/src/3rdparty/v8/test/mjsunit/array-literal-transitions.js b/src/3rdparty/v8/test/mjsunit/array-literal-transitions.js index f657525..d4c0c30 100644 --- a/src/3rdparty/v8/test/mjsunit/array-literal-transitions.js +++ b/src/3rdparty/v8/test/mjsunit/array-literal-transitions.js @@ -1,4 +1,4 @@ -// Copyright 2011 the V8 project authors. All rights reserved. +// Copyright 2012 the V8 project authors. All rights reserved. // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: @@ -26,6 +26,8 @@ // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Flags: --allow-natives-syntax --smi-only-arrays --expose-gc +// Flags: --noparallel-recompilation + // Test element kind of objects. // Since --smi-only-arrays affects builtins, its default setting at compile // time sticks if built with snapshot. If --smi-only-arrays is deactivated @@ -33,7 +35,7 @@ // in this test case. Depending on whether smi-only arrays are actually // enabled, this test takes the appropriate code path to check smi-only arrays. -support_smi_only_arrays = %HasFastSmiOnlyElements([1,2,3,4,5,6,7,8,9,10]); +support_smi_only_arrays = %HasFastSmiElements([1,2,3,4,5,6,7,8,9,10]); if (support_smi_only_arrays) { print("Tests include smi-only arrays."); @@ -46,14 +48,14 @@ function get(foo) { return foo; } // Used to generate dynamic values. function array_literal_test() { var a0 = [1, 2, 3]; - assertTrue(%HasFastSmiOnlyElements(a0)); + assertTrue(%HasFastSmiElements(a0)); var a1 = [get(1), get(2), get(3)]; - assertTrue(%HasFastSmiOnlyElements(a1)); + assertTrue(%HasFastSmiElements(a1)); var b0 = [1, 2, get("three")]; - assertTrue(%HasFastElements(b0)); + assertTrue(%HasFastObjectElements(b0)); var b1 = [get(1), get(2), get("three")]; - assertTrue(%HasFastElements(b1)); + assertTrue(%HasFastObjectElements(b1)); var c0 = [1, 2, get(3.5)]; assertTrue(%HasFastDoubleElements(c0)); @@ -75,7 +77,7 @@ function array_literal_test() { var object = new Object(); var d0 = [1, 2, object]; - assertTrue(%HasFastElements(d0)); + assertTrue(%HasFastObjectElements(d0)); assertEquals(object, d0[2]); assertEquals(2, d0[1]); assertEquals(1, d0[0]); @@ -87,7 +89,7 @@ function array_literal_test() { assertEquals(1, e0[0]); var f0 = [1, 2, [1, 2]]; - assertTrue(%HasFastElements(f0)); + assertTrue(%HasFastObjectElements(f0)); assertEquals([1,2], f0[2]); assertEquals(2, f0[1]); assertEquals(1, f0[0]); @@ -115,9 +117,9 @@ if (support_smi_only_arrays) { large = [ 0, 1, 2, 3, 4, 5, d(), d(), d(), d(), d(), d(), o(), o(), o(), o() ]; assertFalse(%HasDictionaryElements(large)); - assertFalse(%HasFastSmiOnlyElements(large)); + assertFalse(%HasFastSmiElements(large)); assertFalse(%HasFastDoubleElements(large)); - assertTrue(%HasFastElements(large)); + assertTrue(%HasFastObjectElements(large)); assertEquals(large, [0, 1, 2, 3, 4, 5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, new Object(), new Object(), new Object(), new Object()]); diff --git a/src/3rdparty/v8/test/mjsunit/assert-opt-and-deopt.js b/src/3rdparty/v8/test/mjsunit/assert-opt-and-deopt.js index 51cb99a..c79d923 100644 --- a/src/3rdparty/v8/test/mjsunit/assert-opt-and-deopt.js +++ b/src/3rdparty/v8/test/mjsunit/assert-opt-and-deopt.js @@ -25,7 +25,7 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Flags: --allow-natives-syntax +// Flags: --allow-natives-syntax --noparallel-recompilation /** * This class shows how to use %GetOptimizationCount() and diff --git a/src/3rdparty/v8/test/mjsunit/bugs/bug-2337.js b/src/3rdparty/v8/test/mjsunit/bugs/bug-2337.js new file mode 100644 index 0000000..ebf7621 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/bugs/bug-2337.js @@ -0,0 +1,53 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-debug-as debug --expose-gc + +// If one callback causes a GC then the other callbacks don't take place. + +var f = eval("(function f() { return 42; })"); +var f2 = eval("(function f2() { return 43; })"); + +Debug = debug.Debug; + +var called = 0; + +function listener(event, exec_state, event_data, data) { + if (event == Debug.DebugEvent.ScriptCollected) { + if (called != 2) { + called++; + gc(); + } + } +}; + +Debug.scripts(); +Debug.setListener(listener); +f = void 0; +f2 = void 0; +gc(); +assertTrue(called == 2); diff --git a/src/3rdparty/v8/test/mjsunit/compare-known-objects-slow.js b/src/3rdparty/v8/test/mjsunit/compare-known-objects-slow.js new file mode 100644 index 0000000..afa198f --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/compare-known-objects-slow.js @@ -0,0 +1,69 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +// Test CompareIC stubs for normal and strict equality comparison of known +// objects in slow mode. These objects share the same map even though they +// might have completely different properties. + +function eq(a, b) { + return a == b; +} + +function eq_strict(a, b) { + return a === b; +} + +function test(a, b) { + // Check CompareIC for equality of known objects. + assertTrue(eq(a, a)); + assertTrue(eq(b, b)); + assertFalse(eq(a, b)); + // Check CompareIC for strict equality of known objects. + assertTrue(eq_strict(a, a)); + assertTrue(eq_strict(b, b)); + assertFalse(eq_strict(a, b)); +} + +// Prepare two objects in slow mode that have the same map. +var obj1 = %OptimizeObjectForAddingMultipleProperties({}, 1); +var obj2 = %OptimizeObjectForAddingMultipleProperties({}, 1); + +// Test original objects. +assertTrue(%HaveSameMap(obj1, obj2)); +test(obj1, obj2); + +// Test after adding property to first object. +obj1.x = 1; +assertTrue(%HaveSameMap(obj1, obj2)); +test(obj1, obj2); + +// Test after adding property to second object. +obj2.y = 2; +assertTrue(%HaveSameMap(obj1, obj2)); +test(obj1, obj2); diff --git a/src/3rdparty/v8/test/mjsunit/compiler/alloc-object-huge.js b/src/3rdparty/v8/test/mjsunit/compiler/alloc-object-huge.js index 0b202f7..b0a981d 100644 --- a/src/3rdparty/v8/test/mjsunit/compiler/alloc-object-huge.js +++ b/src/3rdparty/v8/test/mjsunit/compiler/alloc-object-huge.js @@ -25,7 +25,9 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Flags: --allow-natives-syntax --inline-construct --max-inlined-source-size=999999 --max-inlined-nodes=999999 --max-inlined-nodes-cumulative=999999 +// Flags: --allow-natives-syntax --inline-construct +// Flags: --max-inlined-source-size=999999 --max-inlined-nodes=999999 +// Flags: --max-inlined-nodes-cumulative=999999 // Test that huge constructors (more than 256 this assignments) are // handled correctly. diff --git a/src/3rdparty/v8/test/mjsunit/compiler/inline-accessors.js b/src/3rdparty/v8/test/mjsunit/compiler/inline-accessors.js new file mode 100644 index 0000000..a4cf7ae --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/compiler/inline-accessors.js @@ -0,0 +1,368 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax --inline-accessors --max-opt-count=100 + +var accessorCallCount, setterArgument, setterValue, obj, forceDeopt; + +// ----------------------------------------------------------------------------- +// Helpers for testing inlining of getters. + +function TestInlinedGetter(context, obj, expected) { + forceDeopt = { deopt: 0 }; + accessorCallCount = 0; + + assertEquals(expected, context(obj)); + assertEquals(1, accessorCallCount); + + assertEquals(expected, context(obj)); + assertEquals(2, accessorCallCount); + + %OptimizeFunctionOnNextCall(context); + assertEquals(expected, context(obj)); + assertEquals(3, accessorCallCount); + + forceDeopt = { /* empty*/ }; + assertEquals(expected, context(obj)); + assertEquals(4, accessorCallCount); +} + + +function value_context_for_getter(obj) { + return obj.getterProperty; +} + +function test_context_for_getter(obj) { + if (obj.getterProperty) { + return 111; + } else { + return 222; + } +} + +function effect_context_for_getter(obj) { + obj.getterProperty; + return 5678; +} + +function TryGetter(context, getter, obj, expected, expectException) { + try { + TestInlinedGetter(context, obj, expected); + assertFalse(expectException); + } catch (exception) { + assertTrue(expectException); + assertEquals(7, exception.stack.split('\n').length); + } + %DeoptimizeFunction(context); + %ClearFunctionTypeFeedback(context); + %ClearFunctionTypeFeedback(getter); +} + +function TestGetterInAllContexts(getter, obj, expected, expectException) { + TryGetter(value_context_for_getter, getter, obj, expected, expectException); + TryGetter(test_context_for_getter, getter, obj, expected ? 111 : 222, + expectException); + TryGetter(effect_context_for_getter, getter, obj, 5678, expectException); +} + +// ----------------------------------------------------------------------------- +// Test getter returning something 'true'ish in all contexts. + +function getter1() { + assertSame(obj, this); + accessorCallCount++; + forceDeopt.deopt; + return 1234; +} + +function ConstrG1() { } +obj = Object.defineProperty(new ConstrG1(), "getterProperty", { get: getter1 }); +TestGetterInAllContexts(getter1, obj, 1234, false); +obj = Object.create(obj); +TestGetterInAllContexts(getter1, obj, 1234, false); + +// ----------------------------------------------------------------------------- +// Test getter returning false in all contexts. + +function getter2() { + assertSame(obj, this); + accessorCallCount++; + forceDeopt.deopt; + return false; +} + +function ConstrG2() { } +obj = Object.defineProperty(new ConstrG2(), "getterProperty", { get: getter2 }); +TestGetterInAllContexts(getter2, obj, false, false); +obj = Object.create(obj); +TestGetterInAllContexts(getter2, obj, false, false); + +// ----------------------------------------------------------------------------- +// Test getter without a return in all contexts. + +function getter3() { + assertSame(obj, this); + accessorCallCount++; + forceDeopt.deopt; +} + +function ConstrG3() { } +obj = Object.defineProperty(new ConstrG3(), "getterProperty", { get: getter3 }); +TestGetterInAllContexts(getter3, obj, undefined, false); +obj = Object.create(obj); +TestGetterInAllContexts(getter3, obj, undefined, false); + +// ----------------------------------------------------------------------------- +// Test getter with too many arguments without a return in all contexts. + +function getter4(a) { + assertSame(obj, this); + assertEquals(undefined, a); + accessorCallCount++; + forceDeopt.deopt; +} + +function ConstrG4() { } +obj = Object.defineProperty(new ConstrG4(), "getterProperty", { get: getter4 }); +TestGetterInAllContexts(getter4, obj, undefined, false); +obj = Object.create(obj); +TestGetterInAllContexts(getter4, obj, undefined, false); + +// ----------------------------------------------------------------------------- +// Test getter with too many arguments with a return in all contexts. + +function getter5(a) { + assertSame(obj, this); + assertEquals(undefined, a); + accessorCallCount++; + forceDeopt.deopt; + return 9876; +} + +function ConstrG5() { } +obj = Object.defineProperty(new ConstrG5(), "getterProperty", { get: getter5 }); +TestGetterInAllContexts(getter5, obj, 9876, false); +obj = Object.create(obj); +TestGetterInAllContexts(getter5, obj, 9876, false); + +// ----------------------------------------------------------------------------- +// Test getter which throws from optimized code. + +function getter6() { + assertSame(obj, this); + accessorCallCount++; + forceDeopt.deopt; + if (accessorCallCount == 4) { 123 in null; } + return 13579; +} + +function ConstrG6() { } +obj = Object.defineProperty(new ConstrG6(), "getterProperty", { get: getter6 }); +TestGetterInAllContexts(getter6, obj, 13579, true); +obj = Object.create(obj); +TestGetterInAllContexts(getter6, obj, 13579, true); + +// ----------------------------------------------------------------------------- +// Helpers for testing inlining of setters. + +function TestInlinedSetter(context, obj, value, expected) { + forceDeopt = { deopt: 0 }; + accessorCallCount = 0; + setterArgument = value; + + assertEquals(expected, context(obj, value)); + assertEquals(value, setterValue); + assertEquals(1, accessorCallCount); + + assertEquals(expected, context(obj, value)); + assertEquals(value, setterValue); + assertEquals(2, accessorCallCount); + + %OptimizeFunctionOnNextCall(context); + assertEquals(expected, context(obj, value)); + assertEquals(value, setterValue); + assertEquals(3, accessorCallCount); + + forceDeopt = { /* empty*/ }; + assertEquals(expected, context(obj, value)); + assertEquals(value, setterValue); + assertEquals(4, accessorCallCount); +} + +function value_context_for_setter(obj, value) { + return obj.setterProperty = value; +} + +function test_context_for_setter(obj, value) { + if (obj.setterProperty = value) { + return 333; + } else { + return 444; + } +} + +function effect_context_for_setter(obj, value) { + obj.setterProperty = value; + return 666; +} + +function TrySetter(context, setter, obj, expectException, value, expected) { + try { + TestInlinedSetter(context, obj, value, expected); + assertFalse(expectException); + } catch (exception) { + assertTrue(expectException); + assertEquals(7, exception.stack.split('\n').length); + } + %DeoptimizeFunction(context); + %ClearFunctionTypeFeedback(context); + %ClearFunctionTypeFeedback(setter); +} + +function TestSetterInAllContexts(setter, obj, expectException) { + TrySetter(value_context_for_setter, setter, obj, expectException, 111, 111); + TrySetter(test_context_for_setter, setter, obj, expectException, true, 333); + TrySetter(test_context_for_setter, setter, obj, expectException, false, 444); + TrySetter(effect_context_for_setter, setter, obj, expectException, 555, 666); +} + +// ----------------------------------------------------------------------------- +// Test setter without a return in all contexts. + +function setter1(value) { + assertSame(obj, this); + accessorCallCount++; + forceDeopt.deopt; + setterValue = value; +} + +function ConstrS1() { } +obj = Object.defineProperty(new ConstrS1(), "setterProperty", { set: setter1 }); +TestSetterInAllContexts(setter1, obj, false); +obj = Object.create(obj); +TestSetterInAllContexts(setter1, obj, false); + +// ----------------------------------------------------------------------------- +// Test setter returning something different than the RHS in all contexts. + +function setter2(value) { + assertSame(obj, this); + accessorCallCount++; + forceDeopt.deopt; + setterValue = value; + return 1000000; +} + +function ConstrS2() { } +obj = Object.defineProperty(new ConstrS2(), "setterProperty", { set: setter2 }); +TestSetterInAllContexts(setter2, obj, false); +obj = Object.create(obj); +TestSetterInAllContexts(setter2, obj, false); + +// ----------------------------------------------------------------------------- +// Test setter with too few arguments without a return in all contexts. + +function setter3() { + assertSame(obj, this); + accessorCallCount++; + forceDeopt.deopt; + setterValue = setterArgument; +} + +function ConstrS3() { } +obj = Object.defineProperty(new ConstrS3(), "setterProperty", { set: setter3 }); +TestSetterInAllContexts(setter3, obj, false); +obj = Object.create(obj); +TestSetterInAllContexts(setter3, obj, false); + +// ----------------------------------------------------------------------------- +// Test setter with too few arguments with a return in all contexts. + +function setter4() { + assertSame(obj, this); + accessorCallCount++; + forceDeopt.deopt; + setterValue = setterArgument; + return 2000000; +} + +function ConstrS4() { } +obj = Object.defineProperty(new ConstrS4(), "setterProperty", { set: setter4 }); +TestSetterInAllContexts(setter4, obj, false); +obj = Object.create(obj); +TestSetterInAllContexts(setter4, obj, false); + +// ----------------------------------------------------------------------------- +// Test setter with too many arguments without a return in all contexts. + +function setter5(value, foo) { + assertSame(obj, this); + assertEquals(undefined, foo); + accessorCallCount++; + forceDeopt.deopt; + setterValue = value; +} + +function ConstrS5() { } +obj = Object.defineProperty(new ConstrS5(), "setterProperty", { set: setter5 }); +TestSetterInAllContexts(setter5, obj, false); +obj = Object.create(obj); +TestSetterInAllContexts(setter5, obj, false); + +// ----------------------------------------------------------------------------- +// Test setter with too many arguments with a return in all contexts. + +function setter6(value, foo) { + assertSame(obj, this); + assertEquals(undefined, foo); + accessorCallCount++; + forceDeopt.deopt; + setterValue = value; + return 3000000; +} + +function ConstrS6() { } +obj = Object.defineProperty(new ConstrS6(), "setterProperty", { set: setter6 }); +TestSetterInAllContexts(setter6, obj, false); +obj = Object.create(obj); +TestSetterInAllContexts(setter6, obj, false); + +// ----------------------------------------------------------------------------- +// Test setter which throws from optimized code. + +function setter7(value) { + accessorCallCount++; + forceDeopt.deopt; + if (accessorCallCount == 4) { 123 in null; } + setterValue = value; +} + +function ConstrS7() { } +obj = Object.defineProperty(new ConstrS7(), "setterProperty", { set: setter7 }); +TestSetterInAllContexts(setter7, obj, true); +obj = Object.create(obj); +TestSetterInAllContexts(setter7, obj, true); diff --git a/src/3rdparty/v8/test/mjsunit/compiler/inline-arguments.js b/src/3rdparty/v8/test/mjsunit/compiler/inline-arguments.js index f8a2476..df1bd22 100644 --- a/src/3rdparty/v8/test/mjsunit/compiler/inline-arguments.js +++ b/src/3rdparty/v8/test/mjsunit/compiler/inline-arguments.js @@ -25,7 +25,7 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Flags: --allow-natives-syntax +// Flags: --allow-natives-syntax --max-opt-count=100 function A() { } @@ -157,6 +157,7 @@ function test_toarr(toarr) { test_toarr(toarr1); test_toarr(toarr2); + // Test that arguments access from inlined function uses correct values. (function () { function inner(x, y) { @@ -174,9 +175,94 @@ test_toarr(toarr2); return inner(x, y); } + %OptimizeFunctionOnNextCall(outer); + %OptimizeFunctionOnNextCall(inner); + assertEquals(2, outer(1, 2)); +})(); + + +(function () { + function inner(x, y) { + "use strict"; + x = 10; + y = 20; + for (var i = 0; i < 1; i++) { + for (var j = 1; j <= arguments.length; j++) { + return arguments[arguments.length - j]; + } + } + } + + function outer(x, y) { + return inner(x, y); + } + assertEquals(2, outer(1, 2)); assertEquals(2, outer(1, 2)); assertEquals(2, outer(1, 2)); %OptimizeFunctionOnNextCall(outer); assertEquals(2, outer(1, 2)); })(); + + +// Test inlining and deoptimization of functions accessing and modifying +// the arguments object in strict mode with mismatched arguments count. +(function () { + "use strict"; + function test(outerCount, middleCount, innerCount) { + var forceDeopt = { deopt:false }; + function inner(x,y) { + x = 0; y = 0; + forceDeopt.deopt; + assertSame(innerCount, arguments.length); + for (var i = 0; i < arguments.length; i++) { + assertSame(30 + i, arguments[i]); + } + } + + function middle(x,y) { + x = 0; y = 0; + if (innerCount == 1) inner(30); + if (innerCount == 2) inner(30, 31); + if (innerCount == 3) inner(30, 31, 32); + assertSame(middleCount, arguments.length); + for (var i = 0; i < arguments.length; i++) { + assertSame(20 + i, arguments[i]); + } + } + + function outer(x,y) { + x = 0; y = 0; + if (middleCount == 1) middle(20); + if (middleCount == 2) middle(20, 21); + if (middleCount == 3) middle(20, 21, 22); + assertSame(outerCount, arguments.length); + for (var i = 0; i < arguments.length; i++) { + assertSame(10 + i, arguments[i]); + } + } + + for (var step = 0; step < 4; step++) { + if (outerCount == 1) outer(10); + if (outerCount == 2) outer(10, 11); + if (outerCount == 3) outer(10, 11, 12); + if (step == 1) %OptimizeFunctionOnNextCall(outer); + if (step == 2) delete forceDeopt.deopt; + } + + %DeoptimizeFunction(outer); + %DeoptimizeFunction(middle); + %DeoptimizeFunction(inner); + %ClearFunctionTypeFeedback(outer); + %ClearFunctionTypeFeedback(middle); + %ClearFunctionTypeFeedback(inner); + } + + for (var a = 1; a <= 3; a++) { + for (var b = 1; b <= 3; b++) { + for (var c = 1; c <= 3; c++) { + test(a,b,c); + } + } + } +})(); diff --git a/src/3rdparty/v8/test/mjsunit/compiler/inline-construct.js b/src/3rdparty/v8/test/mjsunit/compiler/inline-construct.js index 7a3f1e4..fa784cf 100644 --- a/src/3rdparty/v8/test/mjsunit/compiler/inline-construct.js +++ b/src/3rdparty/v8/test/mjsunit/compiler/inline-construct.js @@ -29,63 +29,72 @@ // Test inlining of constructor calls. -function TestInlinedConstructor(closure) { +function TestInlinedConstructor(constructor, closure) { var result; var counter = { value:0 }; - result = closure(11, 12, counter); - assertEquals(23, result); + var noDeopt = { deopt:0 }; + var forceDeopt = { /*empty*/ }; + + result = closure(constructor, 11, noDeopt, counter); + assertEquals(11, result); assertEquals(1, counter.value); - result = closure(23, 19, counter); - assertEquals(42, result); + + result = closure(constructor, 23, noDeopt, counter); + assertEquals(23, result); assertEquals(2, counter.value); + %OptimizeFunctionOnNextCall(closure); - result = closure(1, 42, counter) - assertEquals(43, result); + result = closure(constructor, 42, noDeopt, counter); + assertEquals(42, result); assertEquals(3, counter.value); - result = closure("foo", "bar", counter) - assertEquals("foobar", result) + + result = closure(constructor, 127, forceDeopt, counter); + assertEquals(127, result) assertEquals(4, counter.value); + + %DeoptimizeFunction(closure); + %ClearFunctionTypeFeedback(closure); + %ClearFunctionTypeFeedback(constructor); } -function TestInAllContexts(constructor) { - function value_context(a, b, counter) { - var obj = new constructor(a, b, counter); - return obj.x; - } - function test_context(a, b, counter) { - if (!new constructor(a, b, counter)) { - assertUnreachable("should not happen"); - } - return a + b; - } - function effect_context(a, b, counter) { - new constructor(a, b, counter); - return a + b; +function value_context(constructor, val, deopt, counter) { + var obj = new constructor(val, deopt, counter); + return obj.x; +} + +function test_context(constructor, val, deopt, counter) { + if (!new constructor(val, deopt, counter)) { + assertUnreachable("should not happen"); } - TestInlinedConstructor(value_context); - TestInlinedConstructor(test_context); - TestInlinedConstructor(effect_context); - %DeoptimizeFunction(value_context); - %DeoptimizeFunction(test_context); - %DeoptimizeFunction(effect_context); - %ClearFunctionTypeFeedback(value_context); - %ClearFunctionTypeFeedback(test_context); - %ClearFunctionTypeFeedback(effect_context); + return val; +} + +function effect_context(constructor, val, deopt, counter) { + new constructor(val, deopt, counter); + return val; +} + +function TestInAllContexts(constructor) { + TestInlinedConstructor(constructor, value_context); + TestInlinedConstructor(constructor, test_context); + TestInlinedConstructor(constructor, effect_context); } // Test constructor returning nothing in all contexts. -function c1(a, b, counter) { - this.x = a + b; +function c1(val, deopt, counter) { + deopt.deopt; + this.x = val; counter.value++; } TestInAllContexts(c1); // Test constructor returning an object in all contexts. -function c2(a, b, counter) { - var obj = new Object(); - obj.x = a + b; +function c2(val, deopt, counter) { + var obj = {}; + deopt.deopt; + obj.x = val; counter.value++; return obj; } @@ -93,8 +102,9 @@ TestInAllContexts(c2); // Test constructor returning a primitive value in all contexts. -function c3(a, b, counter) { - this.x = a + b; +function c3(val, deopt, counter) { + deopt.deopt; + this.x = val; counter.value++; return "not an object"; } @@ -133,9 +143,10 @@ assertEquals("foo1", f_too_few("foo")) // Test constructor that cannot be inlined. -function c_unsupported_syntax(a, b, counter) { +function c_unsupported_syntax(val, deopt, counter) { try { - this.x = a + b; + deopt.deopt; + this.x = val; counter.value++; } catch(e) { throw new Error(); @@ -146,9 +157,10 @@ TestInAllContexts(c_unsupported_syntax); // Regression test: Inlined constructors called as functions do not get their // implicit receiver object set to undefined, even in strict mode. -function c_strict(a, b, counter) { +function c_strict(val, deopt, counter) { "use strict"; - this.x = a + b; + deopt.deopt; + this.x = val; counter.value++; } TestInAllContexts(c_strict); diff --git a/src/3rdparty/v8/test/mjsunit/compiler/inline-literals.js b/src/3rdparty/v8/test/mjsunit/compiler/inline-literals.js index f78abe8..1422586 100644 --- a/src/3rdparty/v8/test/mjsunit/compiler/inline-literals.js +++ b/src/3rdparty/v8/test/mjsunit/compiler/inline-literals.js @@ -29,6 +29,26 @@ // Test that we can inline functions containing materialized literals. +function a2(b, c) { + return [b, c, b + c]; +} + +function a1(a, b, c) { + return [a, a2(b, c)]; +} + +function TestArrayLiteral(a, b, c) { + var expected = [a, [b, c, b + c]]; + var result = a1(a, b, c); + assertEquals(expected, result, "TestArrayLiteral"); +} + +TestArrayLiteral(1, 2, 3); +TestArrayLiteral(1, 2, 3); +%OptimizeFunctionOnNextCall(TestArrayLiteral); +TestArrayLiteral(1, 2, 3); +TestArrayLiteral('a', 'b', 'c'); + function o2(b, c) { return { 'b':b, 'c':c, 'y':b + c }; } @@ -48,3 +68,22 @@ TestObjectLiteral(1, 2, 3); %OptimizeFunctionOnNextCall(TestObjectLiteral); TestObjectLiteral(1, 2, 3); TestObjectLiteral('a', 'b', 'c'); + +function r2(s, x, y) { + return s.replace(/a/, x + y); +} + +function r1(s, x, y) { + return r2(s, x, y).replace(/b/, y + x); +} + +function TestRegExpLiteral(s, x, y, expected) { + var result = r1(s, x, y); + assertEquals(expected, result, "TestRegExpLiteral"); +} + +TestRegExpLiteral("a-", "reg", "exp", "regexp-"); +TestRegExpLiteral("-b", "reg", "exp", "-expreg"); +%OptimizeFunctionOnNextCall(TestRegExpLiteral); +TestRegExpLiteral("ab", "reg", "exp", "regexpexpreg"); +TestRegExpLiteral("ab", 12345, 54321, "6666666666"); diff --git a/src/3rdparty/v8/test/mjsunit/compiler/optimized-closures.js b/src/3rdparty/v8/test/mjsunit/compiler/optimized-closures.js new file mode 100644 index 0000000..eaf75f8 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/compiler/optimized-closures.js @@ -0,0 +1,57 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +// Test optimized closures. + +var a = new Array(100); + +function f() { + var x=0; + for (var i=0; i<100; i++) { + var g = function goo(y) { + function h() { + if (goo.arguments[0] == 23) return -42; + return 42; + } + return x + y + h(y); + } + g(0); + %OptimizeFunctionOnNextCall(g); + a[i] = g(i); + } +} + +f(); +assertEquals(42, a[0]); +assertEquals(49, a[7]); +assertEquals(-19, a[23]); + + + + diff --git a/src/3rdparty/v8/test/mjsunit/compiler/proto-chain-load.js b/src/3rdparty/v8/test/mjsunit/compiler/proto-chain-load.js new file mode 100644 index 0000000..60c6431 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/compiler/proto-chain-load.js @@ -0,0 +1,44 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +// Test HLoadNamedField on the proto chain. + +var obj4 = Object.create(null, { f4: {value: 4} }); +var obj3 = Object.create(obj4, { f3: {value: 3} }); +var obj2 = Object.create(obj3, { f2: {value: 2} }); +var obj1 = Object.create(obj2, { f1: {value: 1} }); +var obj0 = Object.create(obj1, { f0: {value: 0} }); + +function get4(obj) { return obj.f4; } + +assertEquals(4, get4(obj0)); +assertEquals(4, get4(obj0)); +%OptimizeFunctionOnNextCall(get4); +assertEquals(4, get4(obj0)); +assertEquals(4, get4(obj0)); diff --git a/src/3rdparty/v8/test/mjsunit/compiler/regress-gvn.js b/src/3rdparty/v8/test/mjsunit/compiler/regress-gvn.js index 358daf7..01b1aa9 100644 --- a/src/3rdparty/v8/test/mjsunit/compiler/regress-gvn.js +++ b/src/3rdparty/v8/test/mjsunit/compiler/regress-gvn.js @@ -25,7 +25,7 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Flags: --noalways-opt +// Flags: --noalways-opt --allow-natives-syntax // // Regression test for global value numbering. @@ -39,10 +39,11 @@ function test(a) { var a = new Array(); -var n = 100000000; +var n = 100; var result = 0; for (var i = 0; i < n; ++i) { + if (i == 10) %OptimizeFunctionOnNextCall(test); a[0] = 0; result += test(a); } diff --git a/src/3rdparty/v8/test/mjsunit/compiler/regress-or.js b/src/3rdparty/v8/test/mjsunit/compiler/regress-or.js index 89f7802..939f2c3 100644 --- a/src/3rdparty/v8/test/mjsunit/compiler/regress-or.js +++ b/src/3rdparty/v8/test/mjsunit/compiler/regress-or.js @@ -25,6 +25,8 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Flags: --allow-natives-syntax + // Test deoptimization inside short-circuited expressions. function f1(x) { var c = "fail"; @@ -36,7 +38,8 @@ function f1(x) { function g1() { try { return 1; } finally {} } -for (var i=0; i<10000000; i++) f1(42); +for (var i = 0; i < 5; i++) f1(42); +%OptimizeFunctionOnNextCall(f1); assertEquals(-1, f1(0)); assertEquals(-43, f1(42)); @@ -52,6 +55,7 @@ function f2(x) { function g2() { try { return 0; } finally {} } -for (var i=0; i<10000000; i++) f2(42); +for (var i = 0; i < 5; i++) f2(42); +%OptimizeFunctionOnNextCall(f2); assertEquals(-1, f2("")); diff --git a/src/3rdparty/v8/test/mjsunit/compiler/rotate.js b/src/3rdparty/v8/test/mjsunit/compiler/rotate.js new file mode 100644 index 0000000..14fe9da --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/compiler/rotate.js @@ -0,0 +1,224 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax --expose-gc + +// Test shift operations that can be replaced by rotate operation. + +function SideEffect() { + with ({}) { } // not inlinable +} + +function Twenty() { + SideEffect(); + return 20; +} + +function Twelve() { + SideEffect(); + return 12; +} + + +function ROR(x, sa) { + return (x >>> sa) | (x << (32 - sa)); +} + +function ROR1(x, sa) { + return (x >>> sa) | (x << (32 - sa)); +} + +function ROR2(x, sa) { + return (x >>> (32 - sa)) | (x << (sa)); +} + +function ROR3(x, sa) { + return (x << (32 - sa)) | (x >>> sa); +} + +function ROR4(x, sa) { + return (x << (sa)) | (x >>> (32 - sa)); +} + +assertEquals(1 << ((2 % 32)), ROR(1, 30)); +assertEquals(1 << ((2 % 32)), ROR(1, 30)); +%OptimizeFunctionOnNextCall(ROR); +assertEquals(1 << ((2 % 32)), ROR(1, 30)); + +assertEquals(0xF0000FFF | 0, ROR1(0x0000FFFF, 4)); +assertEquals(0xF0000FFF | 0, ROR1(0x0000FFFF, 4)); +%OptimizeFunctionOnNextCall(ROR1); +assertEquals(0xF0000FFF | 0, ROR1(0x0000FFFF, 4)); + +assertEquals(0x0FFFF000 | 0, ROR1(0x0000FFFF, 20)); +assertEquals(0x0FFFF000 | 0, ROR1(0x0000FFFF, 20)); +%OptimizeFunctionOnNextCall(ROR1); +assertEquals(0x0FFFF000 | 0, ROR1(0x0000FFFF, 20)); + +assertEquals(0x0FFFF000 | 0, ROR1(0x0000FFFF, Twenty())); +assertEquals(0x0FFFF000 | 0, ROR1(0x0000FFFF, Twenty())); +%OptimizeFunctionOnNextCall(ROR1); +assertEquals(0x0FFFF000 | 0, ROR1(0x0000FFFF, Twenty())); + +for (var i = 0; i <= 100; i++) { + assertEquals(0xFFFFFFFF | 0, ROR1(0xFFFFFFFF, i)); + assertEquals(0xFFFFFFFF | 0, ROR1(0xFFFFFFFF, i)); + %OptimizeFunctionOnNextCall(ROR1); + assertEquals(0xFFFFFFFF | 0, ROR1(0xFFFFFFFF, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(-1, ROR1(-1, i)); + assertEquals(-1, ROR1(-1, i)); + %OptimizeFunctionOnNextCall(ROR1); + assertEquals(-1, ROR1(-1, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(1 << (32 - (i % 32)), ROR1(1, i)); + assertEquals(1 << (32 - (i % 32)), ROR1(1, i)); + %OptimizeFunctionOnNextCall(ROR1); + assertEquals(1 << (32 - (i % 32)), ROR1(1, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(1 << (32 - (i % 32)), ROR1(1.4, i)); + assertEquals(1 << (32 - (i % 32)), ROR1(1.4, i)); + %OptimizeFunctionOnNextCall(ROR1); + assertEquals(1 << (32 - (i % 32)), ROR1(1.4, i)); +} + + + +assertEquals(0xF0000FFF | 0, ROR2(0x0000FFFF, 28)); +assertEquals(0xF0000FFF | 0, ROR2(0x0000FFFF, 28)); +%OptimizeFunctionOnNextCall(ROR2); +assertEquals(0xF0000FFF | 0, ROR2(0x0000FFFF, 28)); + +assertEquals(0x0FFFF000 | 0, ROR2(0x0000FFFF, 12)); +assertEquals(0x0FFFF000 | 0, ROR2(0x0000FFFF, 12)); +%OptimizeFunctionOnNextCall(ROR2); +assertEquals(0x0FFFF000 | 0, ROR2(0x0000FFFF, 12)); + +assertEquals(0x0FFFF000 | 0, ROR2(0x0000FFFF, Twelve())); +assertEquals(0x0FFFF000 | 0, ROR2(0x0000FFFF, Twelve())); +%OptimizeFunctionOnNextCall(ROR2); +assertEquals(0x0FFFF000 | 0, ROR2(0x0000FFFF, Twelve())); + +for (var i = 0; i <= 100; i++) { + assertEquals(0xFFFFFFFF | 0, ROR2(0xFFFFFFFF, i)); + assertEquals(0xFFFFFFFF | 0, ROR2(0xFFFFFFFF, i)); + %OptimizeFunctionOnNextCall(ROR2); + assertEquals(0xFFFFFFFF | 0, ROR2(0xFFFFFFFF, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(-1, ROR2(-1, i)); + assertEquals(-1, ROR2(-1, i)); + %OptimizeFunctionOnNextCall(ROR2); + assertEquals(-1, ROR2(-1, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(1 << ((i % 32)), ROR2(1, i)); + assertEquals(1 << ((i % 32)), ROR2(1, i)); + %OptimizeFunctionOnNextCall(ROR2); + assertEquals(1 << ((i % 32)), ROR2(1, i)); +} + +assertEquals(0xF0000FFF | 0, ROR3(0x0000FFFF, 4)); +assertEquals(0xF0000FFF | 0, ROR3(0x0000FFFF, 4)); +%OptimizeFunctionOnNextCall(ROR3); +assertEquals(0xF0000FFF | 0, ROR3(0x0000FFFF, 4)); + +assertEquals(0x0FFFF000 | 0, ROR3(0x0000FFFF, 20)); +assertEquals(0x0FFFF000 | 0, ROR3(0x0000FFFF, 20)); +%OptimizeFunctionOnNextCall(ROR3); +assertEquals(0x0FFFF000 | 0, ROR3(0x0000FFFF, 20)); + +assertEquals(0x0FFFF000 | 0, ROR3(0x0000FFFF, Twenty())); +assertEquals(0x0FFFF000 | 0, ROR3(0x0000FFFF, Twenty())); +%OptimizeFunctionOnNextCall(ROR3); +assertEquals(0x0FFFF000 | 0, ROR3(0x0000FFFF, Twenty())); + +for (var i = 0; i <= 100; i++) { + assertEquals(0xFFFFFFFF | 0, ROR3(0xFFFFFFFF, i)); + assertEquals(0xFFFFFFFF | 0, ROR3(0xFFFFFFFF, i)); + %OptimizeFunctionOnNextCall(ROR3); + assertEquals(0xFFFFFFFF | 0, ROR3(0xFFFFFFFF, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(-1, ROR3(-1, i)); + assertEquals(-1, ROR3(-1, i)); + %OptimizeFunctionOnNextCall(ROR3); + assertEquals(-1, ROR3(-1, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(1 << (32 - (i % 32)), ROR3(1, i)); + assertEquals(1 << (32 - (i % 32)), ROR3(1, i)); + %OptimizeFunctionOnNextCall(ROR3); + assertEquals(1 << (32 - (i % 32)), ROR3(1, i)); +} + +assertEquals(0xF0000FFF | 0, ROR4(0x0000FFFF, 28)); +assertEquals(0xF0000FFF | 0, ROR4(0x0000FFFF, 28)); +%OptimizeFunctionOnNextCall(ROR4); +assertEquals(0xF0000FFF | 0, ROR4(0x0000FFFF, 28)); + +assertEquals(0x0FFFF000 | 0, ROR4(0x0000FFFF, 12)); +assertEquals(0x0FFFF000 | 0, ROR4(0x0000FFFF, 12)); +%OptimizeFunctionOnNextCall(ROR4); +assertEquals(0x0FFFF000 | 0, ROR4(0x0000FFFF, 12)); + +assertEquals(0x0FFFF000 | 0, ROR4(0x0000FFFF, Twelve())); +assertEquals(0x0FFFF000 | 0, ROR4(0x0000FFFF, Twelve())); +%OptimizeFunctionOnNextCall(ROR4); +assertEquals(0x0FFFF000 | 0, ROR4(0x0000FFFF, Twelve())); + +for (var i = 0; i <= 100; i++) { + assertEquals(0xFFFFFFFF | 0, ROR4(0xFFFFFFFF, i)); + assertEquals(0xFFFFFFFF | 0, ROR4(0xFFFFFFFF, i)); + %OptimizeFunctionOnNextCall(ROR4); + assertEquals(0xFFFFFFFF | 0, ROR4(0xFFFFFFFF, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(-1, ROR4(-1, i)); + assertEquals(-1, ROR4(-1, i)); + %OptimizeFunctionOnNextCall(ROR4); + assertEquals(-1, ROR4(-1, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(1 << ((i % 32)), ROR4(1, i)); + assertEquals(1 << ((i % 32)), ROR4(1, i)); + %OptimizeFunctionOnNextCall(ROR4); + assertEquals(1 << ((i % 32)), ROR4(1, i)); +} + diff --git a/src/3rdparty/v8/test/mjsunit/compiler/uint32.js b/src/3rdparty/v8/test/mjsunit/compiler/uint32.js new file mode 100644 index 0000000..abed285 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/compiler/uint32.js @@ -0,0 +1,173 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax --expose-gc + +// Test uint32 handing in optimized frames. + +var K1 = 0x7fffffff; +var K2 = 0xffffffff; + +var uint32_array = new Uint32Array(2); +uint32_array[0] = K1; +uint32_array[1] = K2; + +function ChangeI2T(arr, i) { + return uint32_array[i]; +} + +assertEquals(K1, ChangeI2T(uint32_array, 0)); +assertEquals(K2, ChangeI2T(uint32_array, 1)); +%OptimizeFunctionOnNextCall(ChangeI2T); +assertEquals(K1, ChangeI2T(uint32_array, 0)); +// Loop to force inline allocation failure and a call into runtime. +for (var i = 0; i < 80000; i++) { + assertEquals(K2, ChangeI2T(uint32_array, 1)); +} + +function SideEffect() { + with ({}) { } // not inlinable +} + +function Deopt(obj, arr, i) { + var x = arr[i]; + SideEffect(); // x will be used by HSimulate. + obj.x; + return x; +} + +assertEquals(K1, Deopt({x: 0}, uint32_array, 0)); +assertEquals(K2, Deopt({x: 0}, uint32_array, 1)); +%OptimizeFunctionOnNextCall(Deopt); +assertEquals(K2, Deopt({}, uint32_array, 1)); + +function ChangeI2D(arr) { + // This addition will have a double type feedback so ChangeI2D will + // be generated for its operands. + return arr[0] + arr[1]; +} + +assertEquals(K1 + K2, ChangeI2D(uint32_array)); +assertEquals(K1 + K2, ChangeI2D(uint32_array)); +%OptimizeFunctionOnNextCall(ChangeI2D); +assertEquals(K1 + K2, ChangeI2D(uint32_array)); + +function ShrShr(val) { + return (val >>> 0) >>> 1; +} + +assertEquals(K1, ShrShr(K2 | 0)); +assertEquals(K1, ShrShr(K2 | 0)); +%OptimizeFunctionOnNextCall(ShrShr); +assertEquals(K1, ShrShr(K2 | 0)); + +function SarShr(val) { + return val >> (-2 >>> 0); +} + +var K3 = 0x80000000; +assertEquals(-2, SarShr(K3 | 0)); +assertEquals(-2, SarShr(K3 | 0)); +%OptimizeFunctionOnNextCall(SarShr); +assertEquals(-2, SarShr(K3 | 0)); + +function Uint32Phi(a, b, c) { + var i = a ? (b >>> 0) : (c >>> 0); + return (i | 0); +} + +var K4 = 0x80000001; +assertEquals(K3 | 0, Uint32Phi(true, K3, K4)); +assertEquals(K4 | 0, Uint32Phi(false, K3, K4)); +assertEquals(K3 | 0, Uint32Phi(true, K3, K4)); +assertEquals(K4 | 0, Uint32Phi(false, K3, K4)); +%OptimizeFunctionOnNextCall(Uint32Phi); +assertEquals(K3 | 0, Uint32Phi(true, K3, K4)); +assertEquals(K4 | 0, Uint32Phi(false, K3, K4)); + +function NonUint32Phi(a, b, c) { + var i = a ? (b >>> 0) : c; + return (i | 0); +} + +assertEquals(K3 | 0, NonUint32Phi(true, K3, K4)); +assertEquals(K4 | 0, NonUint32Phi(false, K3, K4)); +assertEquals(K3 | 0, NonUint32Phi(true, K3, K4)); +assertEquals(K4 | 0, NonUint32Phi(false, K3, K4)); +%OptimizeFunctionOnNextCall(NonUint32Phi); +assertEquals(K3 | 0, NonUint32Phi(true, K3, K4)); +assertEquals(K4 | 0, NonUint32Phi(false, K3, K4)); + +function PhiOfPhi(x) { + var a = (x >>> 0); + for (var i = 0; i < 2; i++) { + for (var j = 0; j < 2; j++) { + a = (a >>> 0); + } + } + return (a | 0); +} + +assertEquals(1, PhiOfPhi(1)); +assertEquals(1, PhiOfPhi(1)); +%OptimizeFunctionOnNextCall(PhiOfPhi); +assertEquals(K3 | 0, PhiOfPhi(K3)); + +function PhiOfPhiUnsafe(x) { + var a = x >>> 0; + for (var i = 0; i < 2; i++) { + for (var j = 0; j < 2; j++) { + a = (a >>> 0); + } + } + return a + a; +} + +assertEquals(2, PhiOfPhiUnsafe(1)); +assertEquals(2, PhiOfPhiUnsafe(1)); +%OptimizeFunctionOnNextCall(PhiOfPhiUnsafe); +assertEquals(2 * K3, PhiOfPhiUnsafe(K3)); + +var old_array = new Array(1000); + +for (var i = 0; i < old_array.length; i++) old_array[i] = null; + +// Force promotion. +gc(); +gc(); + +function FillOldArrayWithHeapNumbers(N) { + for (var i = 0; i < N; i++) { + old_array[i] = uint32_array[1]; + } +} + +FillOldArrayWithHeapNumbers(1); +FillOldArrayWithHeapNumbers(1); +%OptimizeFunctionOnNextCall(FillOldArrayWithHeapNumbers); +FillOldArrayWithHeapNumbers(old_array.length); +gc(); diff --git a/src/3rdparty/v8/test/mjsunit/count-based-osr.js b/src/3rdparty/v8/test/mjsunit/count-based-osr.js index 125c4e2..fbff91e 100644 --- a/src/3rdparty/v8/test/mjsunit/count-based-osr.js +++ b/src/3rdparty/v8/test/mjsunit/count-based-osr.js @@ -25,7 +25,8 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Flags: --count-based-interrupts --interrupt-budget=10 --weighted-back-edges --allow-natives-syntax +// Flags: --count-based-interrupts --interrupt-budget=10 --weighted-back-edges +// Flags: --allow-natives-syntax --noparallel-recompilation // Test that OSR works properly when using count-based interrupting/profiling. diff --git a/src/3rdparty/v8/test/mjsunit/d8-os.js b/src/3rdparty/v8/test/mjsunit/d8-os.js index 239938c..f6b9839 100644 --- a/src/3rdparty/v8/test/mjsunit/d8-os.js +++ b/src/3rdparty/v8/test/mjsunit/d8-os.js @@ -129,13 +129,13 @@ if (this.os && os.system) { have_echo = false; } if (have_sleep) { - assertThrows("os.system('sleep', ['2000'], 200);", "sleep 1"); + assertThrows("os.system('sleep', ['2000'], 20);", "sleep 1"); // Check we time out with total time. - assertThrows("os.system('sleep', ['2000'], -1, 200);", "sleep 2"); + assertThrows("os.system('sleep', ['2000'], -1, 20);", "sleep 2"); // Check that -1 means no timeout. - os.system('sleep', ['1'], -1, -1); + os.system('sleep', ['0.1'], -1, -1); } diff --git a/src/3rdparty/v8/test/mjsunit/date-parse.js b/src/3rdparty/v8/test/mjsunit/date-parse.js index b46e39a..cb4a951 100644 --- a/src/3rdparty/v8/test/mjsunit/date-parse.js +++ b/src/3rdparty/v8/test/mjsunit/date-parse.js @@ -287,6 +287,9 @@ for (var i = 0; i < 24 * 365 * 100; i += 150) { var testCasesNegative = [ 'May 25 2008 1:30 (PM)) UTC', // Bad unmatched ')' after number. 'May 25 2008 1:30( )AM (PM)', // + 'a1', // Issue 126448, 53209. + 'nasfdjklsfjoaifg1', + 'x_2', 'May 25 2008 AAA (GMT)']; // Unknown word after number. testCasesNegative.forEach(function (s) { diff --git a/src/3rdparty/v8/test/mjsunit/date.js b/src/3rdparty/v8/test/mjsunit/date.js index 3e153ab..5aaa3bb 100644 --- a/src/3rdparty/v8/test/mjsunit/date.js +++ b/src/3rdparty/v8/test/mjsunit/date.js @@ -25,6 +25,8 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Flags: --allow-natives-syntax + // Test date construction from other dates. var date0 = new Date(1111); var date1 = new Date(date0); @@ -319,3 +321,23 @@ for (var i = 0; i < 24; i++) { assertEquals(70674603500 - ms, Date.parse(string), string); } } + +assertThrows('Date.prototype.setTime.call("", 1);', TypeError); +assertThrows('Date.prototype.setYear.call("", 1);', TypeError); +assertThrows('Date.prototype.setHours.call("", 1, 2, 3, 4);', TypeError); +assertThrows('Date.prototype.getDate.call("");', TypeError); +assertThrows('Date.prototype.getUTCDate.call("");', TypeError); + +var date = new Date(); +date.getTime(); +date.getTime(); +%OptimizeFunctionOnNextCall(Date.prototype.getTime); +assertThrows(function() { Date.prototype.getTime.call(""); }, TypeError); +assertTrue(%GetOptimizationStatus(Date.prototype.getTime) != 1); + +date.getYear(); +date.getYear(); +%OptimizeFunctionOnNextCall(Date.prototype.getYear); +assertThrows(function() { Date.prototype.getYear.call(""); }, TypeError); +opt_status = %GetOptimizationStatus(Date.prototype.getYear); +assertTrue(%GetOptimizationStatus(Date.prototype.getTime) != 1);
\ No newline at end of file diff --git a/src/3rdparty/v8/test/mjsunit/debug-break-inline.js b/src/3rdparty/v8/test/mjsunit/debug-break-inline.js index 4418fa8..464cb73 100644 --- a/src/3rdparty/v8/test/mjsunit/debug-break-inline.js +++ b/src/3rdparty/v8/test/mjsunit/debug-break-inline.js @@ -26,6 +26,7 @@ // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Flags: --expose-debug-as debug --allow-natives-syntax +// Flags: --noparallel-recompilation // This test tests that deoptimization due to debug breaks works for // inlined functions where the full-code is generated before the diff --git a/src/3rdparty/v8/test/mjsunit/debug-evaluate-locals-optimized-double.js b/src/3rdparty/v8/test/mjsunit/debug-evaluate-locals-optimized-double.js index efbb2cc..8d91b97 100644 --- a/src/3rdparty/v8/test/mjsunit/debug-evaluate-locals-optimized-double.js +++ b/src/3rdparty/v8/test/mjsunit/debug-evaluate-locals-optimized-double.js @@ -25,7 +25,9 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Flags: --expose-debug-as debug --expose-gc --allow-natives-syntax --inline-construct +// Flags: --expose-debug-as debug --expose-gc --allow-natives-syntax +// Flags: --inline-construct + // Get the Debug object exposed from the debug context global object. Debug = debug.Debug @@ -43,13 +45,17 @@ var input = [ ]; var expected = [ - { locals: {a0: 1.01, b0: 2.02}, args: { names: ["i", "x0", "y0"], values: [0, 3.03, 4.04] } }, - { locals: {a1: 3.03, b1: 4.04}, args: { names: ["i", "x1", "y1"], values: [1, 5.05, 6.06] } }, - { locals: {a2: 5.05, b2: 6.06}, args: { names: ["i"], values: [2] } }, - { locals: {a3: 7.07, b3: 8.08}, args: { names: ["i", "x3", "y3", "z3"], - values: [3, 9.09, 10.10, undefined] } - }, - { locals: {a4: 9.09, b4: 10.10}, args: { names: ["i", "x4", "y4"], values: [4, 11.11, 12.12] } } + { locals: {a0: 1.01, b0: 2.02}, + args: { names: ["i", "x0", "y0"], values: [0, 3.03, 4.04] } }, + { locals: {a1: 3.03, b1: 4.04}, + args: { names: ["i", "x1", "y1"], values: [1, 5.05, 6.06] } }, + { locals: {a2: 5.05, b2: 6.06}, + args: { names: ["i"], values: [2] } }, + { locals: {a3: 7.07, b3: 8.08}, + args: { names: ["i", "x3", "y3", "z3"], + values: [3, 9.09, 10.10, undefined] } }, + { locals: {a4: 9.09, b4: 10.10}, + args: { names: ["i", "x4", "y4"], values: [4, 11.11, 12.12] } } ]; function arraySum(arr) { @@ -78,7 +84,8 @@ function listener(event, exec_state, event_data, data) { // All frames except the bottom one have expected arguments. for (var j = 0; j < expected_args.names.length; j++) { assertEquals(expected_args.names[j], frame.argumentName(j)); - assertEquals(expected_args.values[j], frame.argumentValue(j).value()); + assertEquals(expected_args.values[j], + frame.argumentValue(j).value()); } // All frames except the bottom one have two scopes. @@ -87,13 +94,15 @@ function listener(event, exec_state, event_data, data) { assertEquals(debug.ScopeType.Global, frame.scope(1).scopeType()); Object.keys(expected_locals).forEach(function (name) { - assertEquals(expected_locals[name], frame.scope(0).scopeObject().value()[name]); + assertEquals(expected_locals[name], + frame.scope(0).scopeObject().value()[name]); }); for (var j = 0; j < expected_args.names.length; j++) { var arg_name = expected_args.names[j]; var arg_value = expected_args.values[j]; - assertEquals(arg_value, frame.scope(0).scopeObject().value()[arg_name]); + assertEquals(arg_value, + frame.scope(0).scopeObject().value()[arg_name]); } // Evaluate in the inlined frame. @@ -114,7 +123,8 @@ function listener(event, exec_state, event_data, data) { map(function (k) { return expected_locals[k]; })); assertEquals(expected_locals_sum + expected_args_sum, - frame.evaluate(Object.keys(expected_locals).join('+') + ' + ' + + frame.evaluate(Object.keys(expected_locals).join('+') + + ' + ' + expected_args.names.join('+')).value()); var arguments_sum = expected_args.names.map(function(_, idx) { diff --git a/src/3rdparty/v8/test/mjsunit/debug-evaluate-locals-optimized.js b/src/3rdparty/v8/test/mjsunit/debug-evaluate-locals-optimized.js index 9c56a12..f662912 100644 --- a/src/3rdparty/v8/test/mjsunit/debug-evaluate-locals-optimized.js +++ b/src/3rdparty/v8/test/mjsunit/debug-evaluate-locals-optimized.js @@ -25,7 +25,9 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Flags: --expose-debug-as debug --expose-gc --allow-natives-syntax --inline-construct +// Flags: --expose-debug-as debug --expose-gc --allow-natives-syntax +// Flags: --inline-construct + // Get the Debug object exposed from the debug context global object. Debug = debug.Debug @@ -35,11 +37,16 @@ var exception = false; var testingConstructCall = false; var expected = [ - { locals: {a0: 1, b0: 2}, args: { names: ["i", "x0", "y0"], values: [0, 3, 4] } }, - { locals: {a1: 3, b1: 4}, args: { names: ["i", "x1", "y1"], values: [1, 5, 6] } }, - { locals: {a2: 5, b2: 6}, args: { names: ["i"], values: [2] } }, - { locals: {a3: 7, b3: 8}, args: { names: ["i", "x3", "y3", "z3"], values: [3, 9, 10, undefined] } }, - { locals: {a4: 9, b4: 10}, args: { names: ["i", "x4", "y4"], values: [4, 11, 12] } } + { locals: {a0: 1, b0: 2}, + args: { names: ["i", "x0", "y0"], values: [0, 3, 4] } }, + { locals: {a1: 3, b1: 4}, + args: { names: ["i", "x1", "y1"], values: [1, 5, 6] } }, + { locals: {a2: 5, b2: 6}, + args: { names: ["i"], values: [2] } }, + { locals: {a3: 7, b3: 8}, + args: { names: ["i", "x3", "y3", "z3"], values: [3, 9, 10, undefined] } }, + { locals: {a4: 9, b4: 10}, + args: { names: ["i", "x4", "y4"], values: [4, 11, 12] } } ]; function arraySum(arr) { @@ -68,7 +75,8 @@ function listener(event, exec_state, event_data, data) { // All frames except the bottom one have expected arguments. for (var j = 0; j < expected_args.names.length; j++) { assertEquals(expected_args.names[j], frame.argumentName(j)); - assertEquals(expected_args.values[j], frame.argumentValue(j).value()); + assertEquals(expected_args.values[j], + frame.argumentValue(j).value()); } // All frames except the bottom one have two scopes. @@ -77,13 +85,15 @@ function listener(event, exec_state, event_data, data) { assertEquals(debug.ScopeType.Global, frame.scope(1).scopeType()); Object.keys(expected_locals).forEach(function (name) { - assertEquals(expected_locals[name], frame.scope(0).scopeObject().value()[name]); + assertEquals(expected_locals[name], + frame.scope(0).scopeObject().value()[name]); }); for (var j = 0; j < expected_args.names.length; j++) { var arg_name = expected_args.names[j]; var arg_value = expected_args.values[j]; - assertEquals(arg_value, frame.scope(0).scopeObject().value()[arg_name]); + assertEquals(arg_value, + frame.scope(0).scopeObject().value()[arg_name]); } // Evaluate in the inlined frame. @@ -104,7 +114,8 @@ function listener(event, exec_state, event_data, data) { map(function (k) { return expected_locals[k]; })); assertEquals(expected_locals_sum + expected_args_sum, - frame.evaluate(Object.keys(expected_locals).join('+') + ' + ' + + frame.evaluate(Object.keys(expected_locals).join('+') + + ' + ' + expected_args.names.join('+')).value()); var arguments_sum = expected_args.names.map(function(_, idx) { diff --git a/src/3rdparty/v8/test/mjsunit/debug-liveedit-double-call.js b/src/3rdparty/v8/test/mjsunit/debug-liveedit-double-call.js new file mode 100644 index 0000000..1df806a --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/debug-liveedit-double-call.js @@ -0,0 +1,142 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-debug-as debug +// Get the Debug object exposed from the debug context global object. + +Debug = debug.Debug + + +function TestCase(test_scenario, expected_output) { + // Global variable, accessed from eval'd script. + test_output = ""; + + var script_text_generator = (function() { + var variables = { a: 1, b: 1, c: 1, d: 1, e: 1, f: 1 }; + + return { + get: function() { + return "(function() {\n " + + " function A() {\n " + + " test_output += 'a' + " + variables.a + ";\n " + + " test_output += '=';\n " + + " debugger;\n " + + " return 'Capybara';\n " + + " }\n " + + " function B(p1, p2) {\n " + + " test_output += 'b' + " + variables.b + ";\n " + + " return A();\n " + + " }\n " + + " function C() {\n " + + " test_output += 'c' + " + variables.c + ";\n " + + " // Function call with argument adaptor is intentional.\n " + + " return B();\n " + + " }\n " + + " function D() {\n " + + " test_output += 'd' + " + variables.d + ";\n " + + " // Function call with argument adaptor is intentional.\n " + + " return C(1, 2);\n " + + " }\n " + + " function E() {\n " + + " test_output += 'e' + " + variables.e + ";\n " + + " return D();\n " + + " }\n " + + " function F() {\n " + + " test_output += 'f' + " + variables.f + ";\n " + + " return E();\n " + + " }\n " + + " return F();\n " + + "})\n"; + }, + change: function(var_name) { + variables[var_name]++; + } + }; + })(); + + var test_fun = eval(script_text_generator.get()); + + var script = Debug.findScript(test_fun); + + var scenario_pos = 0; + + function DebuggerStatementHandler() { + while (true) { + assertTrue(scenario_pos < test_scenario.length); + var change_var = test_scenario[scenario_pos++]; + if (change_var == '=') { + // Continue. + return; + } + script_text_generator.change(change_var); + try { + Debug.LiveEdit.SetScriptSource(script, script_text_generator.get(), + false, []); + } catch (e) { + print("LiveEdit exception: " + e); + throw e; + } + } + } + + var saved_exception = null; + + function listener(event, exec_state, event_data, data) { + if (event == Debug.DebugEvent.Break) { + try { + DebuggerStatementHandler(); + } catch (e) { + saved_exception = e; + } + } else { + print("Other: " + event); + } + } + + Debug.setListener(listener); + assertEquals("Capybara", test_fun()); + Debug.setListener(null); + + if (saved_exception) { + print("Exception: " + saved_exception); + assertUnreachable(); + } + + print(test_output); + + assertEquals(expected_output, test_output); +} + +TestCase(['='], "f1e1d1c1b1a1="); + +TestCase(['c', '=', '='], "f1e1d1c1b1a1=c2b1a1="); + +TestCase(['b', 'c', 'd', 'e', '=', '='], "f1e1d1c1b1a1=e2d2c2b2a1="); + +TestCase(['b', 'c', '=', 'b', 'c', 'd', 'e', '=', '='], "f1e1d1c1b1a1=c2b2a1=e2d2c3b3a1="); + +TestCase(['e', 'f', '=', '='], "f1e1d1c1b1a1=f2e2d1c1b1a1="); diff --git a/src/3rdparty/v8/test/mjsunit/debug-liveedit-restart-frame.js b/src/3rdparty/v8/test/mjsunit/debug-liveedit-restart-frame.js new file mode 100644 index 0000000..d978a97 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/debug-liveedit-restart-frame.js @@ -0,0 +1,153 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-debug-as debug +// Get the Debug object exposed from the debug context global object. + +Debug = debug.Debug + +function FindCallFrame(exec_state, frame_code) { + var number = Number(frame_code); + if (number >= 0) { + return exec_state.frame(number); + } else { + for (var i = 0; i < exec_state.frameCount(); i++) { + var frame = exec_state.frame(i); + var func_mirror = frame.func(); + if (frame_code == func_mirror.name()) { + return frame; + } + } + } + throw new Error("Failed to find function name " + function_name); +} + +function TestCase(test_scenario, expected_output) { + // Global variable, accessed from eval'd script. + test_output = ""; + + function TestCode() { + function A() { + // Extra stack variable. To make function not slim. + // Restarter doesn't work on slim function when stopped on 'debugger' + // statement. (There is no padding for 'debugger' statement). + var o = {}; + test_output += 'A'; + test_output += '='; + debugger; + return 'Capybara'; + } + function B(p1, p2) { + test_output += 'B'; + return A(); + } + function C() { + test_output += 'C'; + // Function call with argument adaptor is intentional. + return B(); + } + function D() { + test_output += 'D'; + // Function call with argument adaptor is intentional. + return C(1, 2); + } + function E() { + test_output += 'E'; + return D(); + } + function F() { + test_output += 'F'; + return E(); + } + return F(); + } + + var scenario_pos = 0; + + function DebuggerStatementHandler(exec_state) { + while (true) { + assertTrue(scenario_pos < test_scenario.length); + var change_code = test_scenario[scenario_pos++]; + if (change_code == '=') { + // Continue. + return; + } + var frame = FindCallFrame(exec_state, change_code); + // Throws if fails. + Debug.LiveEdit.RestartFrame(frame); + } + } + + var saved_exception = null; + + function listener(event, exec_state, event_data, data) { + if (saved_exception != null) { + return; + } + if (event == Debug.DebugEvent.Break) { + try { + DebuggerStatementHandler(exec_state); + } catch (e) { + saved_exception = e; + } + } else { + print("Other: " + event); + } + } + + Debug.setListener(listener); + assertEquals("Capybara", TestCode()); + Debug.setListener(null); + + if (saved_exception) { + print("Exception: " + saved_exception); + print("Stack: " + saved_exception.stack); + assertUnreachable(); + } + + print(test_output); + + assertEquals(expected_output, test_output); +} + +TestCase('0==', "FEDCBA=A="); +TestCase('1==', "FEDCBA=BA="); +TestCase('2==', "FEDCBA=CBA="); +TestCase('3==', "FEDCBA=DCBA="); +TestCase('4==', "FEDCBA=EDCBA="); +TestCase('5==', "FEDCBA=FEDCBA="); + +TestCase('=', "FEDCBA="); + +TestCase('C==', "FEDCBA=CBA="); + +TestCase('B=C=A=D==', "FEDCBA=BA=CBA=A=DCBA="); + +// Successive restarts don't work now and require additional fix. +//TestCase('BCDE==', "FEDCBA=EDCBA="); +//TestCase('BC=BCDE==', "FEDCBA=CBA=EDCBA="); +//TestCase('EF==', "FEDCBA=FEDCBA="); diff --git a/src/3rdparty/v8/test/mjsunit/debug-multiple-breakpoints.js b/src/3rdparty/v8/test/mjsunit/debug-multiple-breakpoints.js index 1047410..d8b1d94 100644 --- a/src/3rdparty/v8/test/mjsunit/debug-multiple-breakpoints.js +++ b/src/3rdparty/v8/test/mjsunit/debug-multiple-breakpoints.js @@ -89,7 +89,7 @@ g(); assertEquals(3, break_point_hit_count); // Finally test with many break points. -test_count = 100; +test_count = 10; bps = new Array(test_count); break_point_hit_count = 0; for (var i = 0; i < test_count; i++) { diff --git a/src/3rdparty/v8/test/mjsunit/debug-script-breakpoints-closure.js b/src/3rdparty/v8/test/mjsunit/debug-script-breakpoints-closure.js new file mode 100644 index 0000000..7c89718 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/debug-script-breakpoints-closure.js @@ -0,0 +1,67 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-debug-as debug +// Get the Debug object exposed from the debug context global object. +Debug = debug.Debug + +// Simple debug event handler which just counts the number of break points hit. +var break_point_hit_count = 0; + +function listener(event, exec_state, event_data, data) { + if (event == Debug.DebugEvent.Break) { + break_point_hit_count++; + } +}; + +// Add the debug event listener. +Debug.setListener(listener); + +function makeClosure() { + var x; + return function() { + return x; // Breakpoint line ( #47 ) + }; +} + +// Create closure before break point is set. +var closure = makeClosure(); + +// The debugger triggers re-compilation. +assertEquals(0, Debug.scriptBreakPoints().length); +var scr = Debug.findScript(makeClosure); +var sbp = Debug.setScriptBreakPointById(scr.id, 47); +assertEquals(1, Debug.scriptBreakPoints().length); + +// Ensure the closure actually triggers a break point hit. +closure(); +assertEquals(1, break_point_hit_count); + +// Remove script break point. +assertEquals(1, Debug.scriptBreakPoints().length); +Debug.clearBreakPoint(sbp); +assertEquals(0, Debug.scriptBreakPoints().length); diff --git a/src/3rdparty/v8/test/mjsunit/debug-script-breakpoints-nested.js b/src/3rdparty/v8/test/mjsunit/debug-script-breakpoints-nested.js new file mode 100644 index 0000000..ce25c17 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/debug-script-breakpoints-nested.js @@ -0,0 +1,82 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-debug-as debug +// Get the Debug object exposed from the debug context global object. +Debug = debug.Debug + +// Simple debug event handler which just counts the number of break points hit. +var break_point_hit_count = 0; + +function listener(event, exec_state, event_data, data) { + if (event == Debug.DebugEvent.Break) { + break_point_hit_count++; + } +}; + +// Add the debug event listener. +Debug.setListener(listener); + +eval( + "var inner;\n" + + "function outer() {\n" + // Non-trivial outer closure. + " var x = 5;\n" + + " function a() {\n" + + " var foo = 0, y = 7;\n" + + " function b() {\n" + + " var bar = 0, baz = 0, z = 11;\n" + + " function c() {\n" + + " return x + y + z;\n" + // Breakpoint line ( #8 ) + " }\n" + + " inner = c;\n" + + " return c();\n" + + " }\n" + + " return b();\n" + + " }\n" + + " return a();\n" + + "}" +); + +var script = Debug.findScript(outer); + +// The debugger triggers compilation of inner closures. +assertEquals(0, Debug.scriptBreakPoints().length); +var sbp = Debug.setScriptBreakPointById(script.id, 8); +assertEquals(1, Debug.scriptBreakPoints().length); + +// The compiled outer closure should behave correctly. +assertEquals(23, outer()); +assertEquals(1, break_point_hit_count); + +// The compiled inner closure should behave correctly. +assertEquals(23, inner()); +assertEquals(2, break_point_hit_count); + +// Remove script break point. +assertEquals(1, Debug.scriptBreakPoints().length); +Debug.clearBreakPoint(sbp); +assertEquals(0, Debug.scriptBreakPoints().length); diff --git a/src/3rdparty/v8/test/mjsunit/debug-script.js b/src/3rdparty/v8/test/mjsunit/debug-script.js index 9767888..b9dbc07 100644 --- a/src/3rdparty/v8/test/mjsunit/debug-script.js +++ b/src/3rdparty/v8/test/mjsunit/debug-script.js @@ -25,9 +25,11 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Flags: --expose-debug-as debug --expose-gc +// Flags: --expose-debug-as debug --expose-gc --noparallel-recompilation +// Flags: --send-idle-notification + // Get the Debug object exposed from the debug context global object. -Debug = debug.Debug +Debug = debug.Debug; Date(); RegExp(); diff --git a/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part1.js b/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part1.js new file mode 100644 index 0000000..f2f9d91 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part1.js @@ -0,0 +1,190 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-debug-as debug --expose-natives-as=builtins + +// Check that the ScopeIterator can properly recreate the scope at +// every point when stepping through functions. + +var Debug = debug.Debug; + +function listener(event, exec_state, event_data, data) { + if (event == Debug.DebugEvent.Break) { + // Access scope details. + var scope_count = exec_state.frame().scopeCount(); + for (var i = 0; i < scope_count; i++) { + var scope = exec_state.frame().scope(i); + // assertTrue(scope.isScope()); + scope.scopeType(); + scope.scopeObject(); + } + + // Do steps until we reach the global scope again. + if (true) { + exec_state.prepareStep(Debug.StepAction.StepInMin, 1); + } + } +} + +Debug.setListener(listener); + + +function test1() { + debugger; + with ({x:1}) { + x = 2; + } +} +test1(); + + +function test2() { + if (true) { + with ({}) { + debugger; + } + } else { + with ({}) { + return 10; + } + } +} +test2(); + + +function test3() { + if (true) { + debugger; + } else { + with ({}) { + return 10; + } + } +} +test3(); + + +function test4() { + debugger; + with ({x:1}) x = 1 +} +test4(); + + +function test5() { + debugger; + var dummy = 1; + with ({}) { + with ({}) { + dummy = 2; + } + } + dummy = 3; +} +test5(); + + +function test6() { + debugger; + try { + throw 'stuff'; + } catch (e) { + e = 1; + } +} +test6(); + + +function test7() { + debugger; + function foo() {} +} +test7(); + + +function test8() { + debugger; + (function foo() {})(); +} +test8(); + + +function test10() { + debugger; + with ({}) { + return 10; + } +} +test10(); + + +function test11() { + debugger; + try { + throw 'stuff'; + } catch (e) { + return 10; + } +} +test11(); + + +var prefixes = [ + "debugger; ", + "if (false) { try { throw 0; } catch(x) { return x; } }; debugger; " ]; + + +// Return from function constructed with Function constructor. +var anon = 12; +for (var i = 0; i < prefixes.length; ++i) { + var pre = prefixes[i]; + Function(pre + "return 42")(); + Function(pre + "return 42 ")(); + Function(pre + "return 42;")(); + Function(pre + "return 42; ")(); + Function(pre + "return anon")(); + Function(pre + "return anon ")(); + Function(pre + "return anon;")(); + Function(pre + "return anon; ")(); +} + + +try { + with({}) { + debugger; + eval("{}$%:^"); + } +} catch(e) { + nop(); +} + + +function nop() {} + + +// With block as the last(!) statement in global code. +with ({}) { debugger; }
\ No newline at end of file diff --git a/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part2.js b/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part2.js new file mode 100644 index 0000000..121c7b7 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part2.js @@ -0,0 +1,83 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-debug-as debug --expose-natives-as=builtins + +// Check that the ScopeIterator can properly recreate the scope at +// every point when stepping through functions. + +var Debug = debug.Debug; + +function listener(event, exec_state, event_data, data) { + if (event == Debug.DebugEvent.Break) { + // Access scope details. + var scope_count = exec_state.frame().scopeCount(); + for (var i = 0; i < scope_count; i++) { + var scope = exec_state.frame().scope(i); + // assertTrue(scope.isScope()); + scope.scopeType(); + scope.scopeObject(); + } + + // Do steps until we reach the global scope again. + if (true) { + exec_state.prepareStep(Debug.StepAction.StepInMin, 1); + } + } +} + +Debug.setListener(listener); + +var q = 42; +var prefixes = [ "debugger; ", + "if (false) { try { throw 0; } catch(x) { return x; } }; debugger; " ]; +var bodies = [ "1", + "1 ", + "1;", + "1; ", + "q", + "q ", + "q;", + "q; ", + "try { throw 'stuff' } catch (e) { e = 1; }", + "try { throw 'stuff' } catch (e) { e = 1; } ", + "try { throw 'stuff' } catch (e) { e = 1; };", + "try { throw 'stuff' } catch (e) { e = 1; }; " ]; + + +function test9() { + debugger; + for (var i = 0; i < prefixes.length; ++i) { + var pre = prefixes[i]; + for (var j = 0; j < bodies.length; ++j) { + var body = bodies[j]; + eval(pre + body); + eval("'use strict'; " + pre + body); + } + } +} +test9(); diff --git a/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part3.js b/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part3.js new file mode 100644 index 0000000..16b085e --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part3.js @@ -0,0 +1,80 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-debug-as debug --expose-natives-as=builtins + +// Check that the ScopeIterator can properly recreate the scope at +// every point when stepping through functions. + +var Debug = debug.Debug; + +function listener(event, exec_state, event_data, data) { + if (event == Debug.DebugEvent.Break) { + // Access scope details. + var scope_count = exec_state.frame().scopeCount(); + for (var i = 0; i < scope_count; i++) { + var scope = exec_state.frame().scope(i); + // assertTrue(scope.isScope()); + scope.scopeType(); + scope.scopeObject(); + } + + // Do steps until we reach the global scope again. + if (true) { + exec_state.prepareStep(Debug.StepAction.StepInMin, 1); + } + } +} + +Debug.setListener(listener); + +var q = 42; +var prefixes = [ + "debugger; ", + "if (false) { try { throw 0; } catch(x) { return x; } }; debugger; " ]; +var with_bodies = [ "with ({}) {}", + "with ({x:1}) x", + "with ({x:1}) x = 1", + "with ({x:1}) x ", + "with ({x:1}) x = 1 ", + "with ({x:1}) x;", + "with ({x:1}) x = 1;", + "with ({x:1}) x; ", + "with ({x:1}) x = 1; " ]; + + +function test9() { + debugger; + for (var i = 0; i < prefixes.length; ++i) { + var pre = prefixes[i]; + for (var j = 0; j < with_bodies.length; ++j) { + var body = with_bodies[j]; + eval(pre + body); + } + } +} +test9(); diff --git a/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part4.js b/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part4.js new file mode 100644 index 0000000..48f4347 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part4.js @@ -0,0 +1,80 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-debug-as debug --expose-natives-as=builtins + +// Check that the ScopeIterator can properly recreate the scope at +// every point when stepping through functions. + +var Debug = debug.Debug; + +function listener(event, exec_state, event_data, data) { + if (event == Debug.DebugEvent.Break) { + // Access scope details. + var scope_count = exec_state.frame().scopeCount(); + for (var i = 0; i < scope_count; i++) { + var scope = exec_state.frame().scope(i); + // assertTrue(scope.isScope()); + scope.scopeType(); + scope.scopeObject(); + } + + // Do steps until we reach the global scope again. + if (true) { + exec_state.prepareStep(Debug.StepAction.StepInMin, 1); + } + } +} + +Debug.setListener(listener); + +var q = 42; +var prefixes = [ + "debugger; ", + "if (false) { try { throw 0; } catch(x) { return x; } }; debugger; " ]; +var bodies = [ "1", + "1 ", + "1;", + "1; ", + "q", + "q ", + "q;", + "q; ", + "try { throw 'stuff' } catch (e) { e = 1; }", + "try { throw 'stuff' } catch (e) { e = 1; } ", + "try { throw 'stuff' } catch (e) { e = 1; };", + "try { throw 'stuff' } catch (e) { e = 1; }; " ]; + + +// Test global eval and function constructor. +for (var i = 0; i < prefixes.length; ++i) { + var pre = prefixes[i]; + for (var j = 0; j < bodies.length; ++j) { + var body = bodies[j]; + eval(pre + body); + } +} diff --git a/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part5.js b/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part5.js new file mode 100644 index 0000000..f060ec3 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part5.js @@ -0,0 +1,77 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-debug-as debug --expose-natives-as=builtins + +// Check that the ScopeIterator can properly recreate the scope at +// every point when stepping through functions. + +var Debug = debug.Debug; + +function listener(event, exec_state, event_data, data) { + if (event == Debug.DebugEvent.Break) { + // Access scope details. + var scope_count = exec_state.frame().scopeCount(); + for (var i = 0; i < scope_count; i++) { + var scope = exec_state.frame().scope(i); + // assertTrue(scope.isScope()); + scope.scopeType(); + scope.scopeObject(); + } + + // Do steps until we reach the global scope again. + if (true) { + exec_state.prepareStep(Debug.StepAction.StepInMin, 1); + } + } +} + +Debug.setListener(listener); + +var q = 42; +var prefixes = [ "debugger; ", + "if (false) { try { throw 0; } catch(x) { return x; } }; debugger; " ]; +var with_bodies = [ "with ({}) {}", + "with ({x:1}) x", + "with ({x:1}) x = 1", + "with ({x:1}) x ", + "with ({x:1}) x = 1 ", + "with ({x:1}) x;", + "with ({x:1}) x = 1;", + "with ({x:1}) x; ", + "with ({x:1}) x = 1; " ]; + + +// Test global eval and function constructor. +for (var i = 0; i < prefixes.length; ++i) { + var pre = prefixes[i]; + for (var j = 0; j < with_bodies.length; ++j) { + var body = with_bodies[j]; + eval(pre + body); + Function(pre + body)(); + } +} diff --git a/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part6.js b/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part6.js new file mode 100644 index 0000000..f7c8df0 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part6.js @@ -0,0 +1,79 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-debug-as debug --expose-natives-as=builtins + +// Check that the ScopeIterator can properly recreate the scope at +// every point when stepping through functions. + +var Debug = debug.Debug; + +function listener(event, exec_state, event_data, data) { + if (event == Debug.DebugEvent.Break) { + // Access scope details. + var scope_count = exec_state.frame().scopeCount(); + for (var i = 0; i < scope_count; i++) { + var scope = exec_state.frame().scope(i); + // assertTrue(scope.isScope()); + scope.scopeType(); + scope.scopeObject(); + } + + // Do steps until we reach the global scope again. + if (true) { + exec_state.prepareStep(Debug.StepAction.StepInMin, 1); + } + } +} + +Debug.setListener(listener); + +var q = 42; +var prefixes = [ "debugger; ", + "if (false) { try { throw 0; } catch(x) { return x; } }; debugger; " ]; +var bodies = [ "1", + "1 ", + "1;", + "1; ", + "q", + "q ", + "q;", + "q; ", + "try { throw 'stuff' } catch (e) { e = 1; }", + "try { throw 'stuff' } catch (e) { e = 1; } ", + "try { throw 'stuff' } catch (e) { e = 1; };", + "try { throw 'stuff' } catch (e) { e = 1; }; " ]; + + +// Test global eval and function constructor. +for (var i = 0; i < prefixes.length; ++i) { + var pre = prefixes[i]; + for (var j = 0; j < bodies.length; ++j) { + var body = bodies[j]; + eval("'use strict'; " + pre + body); + } +} diff --git a/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part7.js b/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part7.js new file mode 100644 index 0000000..4f0c066 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part7.js @@ -0,0 +1,79 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-debug-as debug --expose-natives-as=builtins + +// Check that the ScopeIterator can properly recreate the scope at +// every point when stepping through functions. + +var Debug = debug.Debug; + +function listener(event, exec_state, event_data, data) { + if (event == Debug.DebugEvent.Break) { + // Access scope details. + var scope_count = exec_state.frame().scopeCount(); + for (var i = 0; i < scope_count; i++) { + var scope = exec_state.frame().scope(i); + // assertTrue(scope.isScope()); + scope.scopeType(); + scope.scopeObject(); + } + + // Do steps until we reach the global scope again. + if (true) { + exec_state.prepareStep(Debug.StepAction.StepInMin, 1); + } + } +} + +Debug.setListener(listener); + +var q = 42; +var prefixes = [ "debugger; ", + "if (false) { try { throw 0; } catch(x) { return x; } }; debugger; " ]; +var bodies = [ "1", + "1 ", + "1;", + "1; ", + "q", + "q ", + "q;", + "q; ", + "try { throw 'stuff' } catch (e) { e = 1; }", + "try { throw 'stuff' } catch (e) { e = 1; } ", + "try { throw 'stuff' } catch (e) { e = 1; };", + "try { throw 'stuff' } catch (e) { e = 1; }; " ]; + + +// Test global eval and function constructor. +for (var i = 0; i < prefixes.length; ++i) { + var pre = prefixes[i]; + for (var j = 0; j < bodies.length; ++j) { + var body = bodies[j]; + Function(pre + body)(); + } +} diff --git a/src/3rdparty/v8/test/mjsunit/debug-stepout-scope.js b/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part8.js index 9c040da..f91fab5 100644 --- a/src/3rdparty/v8/test/mjsunit/debug-stepout-scope.js +++ b/src/3rdparty/v8/test/mjsunit/debug-stepout-scope-part8.js @@ -53,191 +53,6 @@ function listener(event, exec_state, event_data, data) { Debug.setListener(listener); -function test1() { - debugger; - with ({x:1}) { - x = 2; - } -} -test1(); - - -function test2() { - if (true) { - with ({}) { - debugger; - } - } else { - with ({}) { - return 10; - } - } -} -test2(); - - -function test3() { - if (true) { - debugger; - } else { - with ({}) { - return 10; - } - } -} -test3(); - - -function test4() { - debugger; - with ({x:1}) x = 1 -} -test4(); - - -function test5() { - debugger; - var dummy = 1; - with ({}) { - with ({}) { - dummy = 2; - } - } - dummy = 3; -} -test5(); - - -function test6() { - debugger; - try { - throw 'stuff'; - } catch (e) { - e = 1; - } -} -test6(); - - -function test7() { - debugger; - function foo() {} -} -test7(); - - -function test8() { - debugger; - (function foo() {})(); -} -test8(); - - -var q = 42; -var prefixes = [ "debugger; ", - "if (false) { try { throw 0; } catch(x) { return x; } }; debugger; " ]; -var bodies = [ "1", - "1 ", - "1;", - "1; ", - "q", - "q ", - "q;", - "q; ", - "try { throw 'stuff' } catch (e) { e = 1; }", - "try { throw 'stuff' } catch (e) { e = 1; } ", - "try { throw 'stuff' } catch (e) { e = 1; };", - "try { throw 'stuff' } catch (e) { e = 1; }; " ]; -var with_bodies = [ "with ({}) {}", - "with ({x:1}) x", - "with ({x:1}) x = 1", - "with ({x:1}) x ", - "with ({x:1}) x = 1 ", - "with ({x:1}) x;", - "with ({x:1}) x = 1;", - "with ({x:1}) x; ", - "with ({x:1}) x = 1; " ]; - - -function test9() { - debugger; - for (var i = 0; i < prefixes.length; ++i) { - var pre = prefixes[i]; - for (var j = 0; j < bodies.length; ++j) { - var body = bodies[j]; - eval(pre + body); - eval("'use strict'; " + pre + body); - } - for (var j = 0; j < with_bodies.length; ++j) { - var body = with_bodies[j]; - eval(pre + body); - } - } -} -test9(); - - -function test10() { - debugger; - with ({}) { - return 10; - } -} -test10(); - - -function test11() { - debugger; - try { - throw 'stuff'; - } catch (e) { - return 10; - } -} -test11(); - - -// Test global eval and function constructor. -for (var i = 0; i < prefixes.length; ++i) { - var pre = prefixes[i]; - for (var j = 0; j < bodies.length; ++j) { - var body = bodies[j]; - eval(pre + body); - eval("'use strict'; " + pre + body); - Function(pre + body)(); - } - for (var j = 0; j < with_bodies.length; ++j) { - var body = with_bodies[j]; - eval(pre + body); - Function(pre + body)(); - } -} - - -try { - with({}) { - debugger; - eval("{}$%:^"); - } -} catch(e) { - nop(); -} - -// Return from function constructed with Function constructor. -var anon = 12; -for (var i = 0; i < prefixes.length; ++i) { - var pre = prefixes[i]; - Function(pre + "return 42")(); - Function(pre + "return 42 ")(); - Function(pre + "return 42;")(); - Function(pre + "return 42; ")(); - Function(pre + "return anon")(); - Function(pre + "return anon ")(); - Function(pre + "return anon;")(); - Function(pre + "return anon; ")(); -} - - function nop() {} @@ -417,7 +232,3 @@ function stress() { } stress(); - - -// With block as the last(!) statement in global code. -with ({}) { debugger; }
\ No newline at end of file diff --git a/src/3rdparty/v8/test/mjsunit/deopt-minus-zero.js b/src/3rdparty/v8/test/mjsunit/deopt-minus-zero.js new file mode 100644 index 0000000..ee09831 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/deopt-minus-zero.js @@ -0,0 +1,56 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax --expose-gc + +/** + * The possible optimization states of a function. Must be in sync with the + * return values of Runtime_GetOptimizationStatus() in runtime.cc! + */ +var OptimizationState = { + YES: 1, + NO: 2, + ALWAYS: 3, + NEVER: 4 +}; + +function mul (a, b) { + return a * b; +} + +mul(-1, -1); +mul(0x80000001|0, -1); +mul(0x80000001|0, -1); +%OptimizeFunctionOnNextCall(mul); +mul(0, -1); +%OptimizeFunctionOnNextCall(mul); +mul(0, -1); + +var raw_optimized = %GetOptimizationStatus(mul); +assertFalse(raw_optimized == OptimizationState.NO); +gc(); + diff --git a/src/3rdparty/v8/test/mjsunit/elements-kind.js b/src/3rdparty/v8/test/mjsunit/elements-kind.js index 4aa79de..b74a212 100644 --- a/src/3rdparty/v8/test/mjsunit/elements-kind.js +++ b/src/3rdparty/v8/test/mjsunit/elements-kind.js @@ -34,7 +34,7 @@ // in this test case. Depending on whether smi-only arrays are actually // enabled, this test takes the appropriate code path to check smi-only arrays. -support_smi_only_arrays = %HasFastSmiOnlyElements(new Array(1,2,3,4,5,6,7,8)); +support_smi_only_arrays = %HasFastSmiElements(new Array(1,2,3,4,5,6,7,8)); if (support_smi_only_arrays) { print("Tests include smi-only arrays."); @@ -59,8 +59,8 @@ var elements_kind = { } function getKind(obj) { - if (%HasFastSmiOnlyElements(obj)) return elements_kind.fast_smi_only; - if (%HasFastElements(obj)) return elements_kind.fast; + if (%HasFastSmiElements(obj)) return elements_kind.fast_smi_only; + if (%HasFastObjectElements(obj)) return elements_kind.fast; if (%HasFastDoubleElements(obj)) return elements_kind.fast_double; if (%HasDictionaryElements(obj)) return elements_kind.dictionary; // Every external kind is also an external array. @@ -116,7 +116,7 @@ if (support_smi_only_arrays) { assertKind(elements_kind.fast_smi_only, too); } -// Make sure the element kind transitions from smionly when a non-smi is stored. +// Make sure the element kind transitions from smi when a non-smi is stored. var you = new Array(); assertKind(elements_kind.fast_smi_only, you); for (var i = 0; i < 1337; i++) { @@ -143,7 +143,7 @@ assertKind(elements_kind.external_int, new Int32Array(0xF)); assertKind(elements_kind.external_unsigned_int, new Uint32Array(23)); assertKind(elements_kind.external_float, new Float32Array(7)); assertKind(elements_kind.external_double, new Float64Array(0)); -assertKind(elements_kind.external_pixel, new PixelArray(512)); +assertKind(elements_kind.external_pixel, new Uint8ClampedArray(512)); // Crankshaft support for smi-only array elements. function monomorphic(array) { @@ -224,9 +224,11 @@ if (support_smi_only_arrays) { for (var i = 0; i < 3; i++) { convert_mixed(doubles, "three", elements_kind.fast); } + convert_mixed(construct_smis(), "three", elements_kind.fast); + convert_mixed(construct_doubles(), "three", elements_kind.fast); + %OptimizeFunctionOnNextCall(convert_mixed); smis = construct_smis(); doubles = construct_doubles(); - %OptimizeFunctionOnNextCall(convert_mixed); convert_mixed(smis, 1, elements_kind.fast); convert_mixed(doubles, 1, elements_kind.fast); assertTrue(%HaveSameMap(smis, doubles)); diff --git a/src/3rdparty/v8/test/mjsunit/elements-length-no-holey.js b/src/3rdparty/v8/test/mjsunit/elements-length-no-holey.js new file mode 100644 index 0000000..5bac296 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/elements-length-no-holey.js @@ -0,0 +1,33 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +a = [1,2,3]; +a.length = 1; +assertFalse(%HasFastHoleyElements(a)); +assertTrue(%HasFastSmiElements(a)); diff --git a/src/3rdparty/v8/test/mjsunit/elements-transition-hoisting.js b/src/3rdparty/v8/test/mjsunit/elements-transition-hoisting.js index 5e78f10..017e7ec 100644 --- a/src/3rdparty/v8/test/mjsunit/elements-transition-hoisting.js +++ b/src/3rdparty/v8/test/mjsunit/elements-transition-hoisting.js @@ -1,4 +1,4 @@ -// Copyright 2011 the V8 project authors. All rights reserved. +// Copyright 2012 the V8 project authors. All rights reserved. // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: @@ -25,13 +25,13 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Flags: --allow-natives-syntax --smi-only-arrays --expose-gc +// Flags: --allow-natives-syntax --smi-only-arrays --noparallel-recompilation // Ensure that ElementsKind transitions in various situations are hoisted (or // not hoisted) correctly, don't change the semantics programs and don't trigger // deopt through hoisting in important situations. -support_smi_only_arrays = %HasFastSmiOnlyElements(new Array(1,2,3,4,5,6)); +support_smi_only_arrays = %HasFastSmiElements(new Array(1,2,3,4,5,6)); if (support_smi_only_arrays) { print("Tests include smi-only arrays."); @@ -39,11 +39,6 @@ if (support_smi_only_arrays) { print("Tests do NOT include smi-only arrays."); } -// Force existing ICs from previous stress runs to be flushed, otherwise the -// assumptions in this test about when deoptimizations get triggered are not -// valid. -gc(); - if (support_smi_only_arrays) { // Make sure that a simple elements array transitions inside a loop before // stores to an array gets hoisted in a way that doesn't generate a deopt in @@ -58,10 +53,14 @@ if (support_smi_only_arrays) { } testDoubleConversion4(new Array(5)); + testDoubleConversion4(new Array(5)); // Call twice to make sure that second + // store is a transition and not + // optimistically MONOMORPHIC %OptimizeFunctionOnNextCall(testDoubleConversion4); testDoubleConversion4(new Array(5)); testDoubleConversion4(new Array(5)); assertTrue(2 != %GetOptimizationStatus(testDoubleConversion4)); + %ClearFunctionTypeFeedback(testDoubleConversion4); // Make sure that non-element related map checks that are not preceded by // transitions in a loop still get hoisted in a way that doesn't generate a @@ -73,17 +72,21 @@ if (support_smi_only_arrays) { a[1] = 1; var count = 3; do { - a.foo = object; // This map check should be hoistable + a.foo = object; // This map check should be hoistable a[1] = object; result = a.foo == object && a[1] == object; } while (--count > 0); } testExactMapHoisting(new Array(5)); + testExactMapHoisting(new Array(5)); // Call twice to make sure that second + // store is a transition and not + // optimistically MONOMORPHIC %OptimizeFunctionOnNextCall(testExactMapHoisting); testExactMapHoisting(new Array(5)); testExactMapHoisting(new Array(5)); assertTrue(2 != %GetOptimizationStatus(testExactMapHoisting)); + %ClearFunctionTypeFeedback(testExactMapHoisting); // Make sure that non-element related map checks do NOT get hoisted if they // depend on an elements transition before them and it's not possible to hoist @@ -98,19 +101,24 @@ if (support_smi_only_arrays) { if (a.bar === undefined) { a[1] = 2.5; } - a.foo = object; // This map check should NOT be hoistable because it - // includes a check for the FAST_ELEMENTS map as well as - // the FAST_DOUBLE_ELEMENTS map, which depends on the - // double transition above in the if, which cannot be - // hoisted. + a.foo = object; // This map check should NOT be hoistable because it + // includes a check for the FAST_ELEMENTS map as well as + // the FAST_DOUBLE_ELEMENTS map, which depends on the + // double transition above in the if, which cannot be + // hoisted. } while (--count > 0); } testExactMapHoisting2(new Array(5)); + testExactMapHoisting2(new Array(5)); // Call twice to make sure that second + // store is a transition and not + // optimistically MONOMORPHIC %OptimizeFunctionOnNextCall(testExactMapHoisting2); testExactMapHoisting2(new Array(5)); testExactMapHoisting2(new Array(5)); - assertTrue(2 != %GetOptimizationStatus(testExactMapHoisting2)); + // Temporarily disabled - see bug 2176. + // assertTrue(2 != %GetOptimizationStatus(testExactMapHoisting2)); + %ClearFunctionTypeFeedback(testExactMapHoisting2); // Make sure that non-element related map checks do get hoisted if they use // the transitioned map for the check and all transitions that they depend @@ -123,19 +131,23 @@ if (support_smi_only_arrays) { var count = 3; do { a[1] = 2.5; - a.foo = object; // This map check should be hoistable because all elements - // transitions in the loop can also be hoisted. + a.foo = object; // This map check should be hoistable because all elements + // transitions in the loop can also be hoisted. } while (--count > 0); } var add_transition = new Array(5); add_transition.foo = 0; - add_transition[0] = new Object(); // For FAST_ELEMENT transition to be created + add_transition[0] = new Object(); // For FAST_ELEMENT transition to be created testExactMapHoisting3(new Array(5)); + testExactMapHoisting3(new Array(5)); // Call twice to make sure that second + // store is a transition and not + // optimistically MONOMORPHIC %OptimizeFunctionOnNextCall(testExactMapHoisting3); testExactMapHoisting3(new Array(5)); testExactMapHoisting3(new Array(5)); assertTrue(2 != %GetOptimizationStatus(testExactMapHoisting3)); + %ClearFunctionTypeFeedback(testExactMapHoisting3); function testDominatingTransitionHoisting1(a) { var object = new Object(); @@ -149,11 +161,21 @@ if (support_smi_only_arrays) { } while (--count > 3); } + /* testDominatingTransitionHoisting1(new Array(5)); + testDominatingTransitionHoisting1(new Array(5)); // Call twice to make sure + // that second store is a + // transition and not + // optimistically MONOMORPHIC %OptimizeFunctionOnNextCall(testDominatingTransitionHoisting1); testDominatingTransitionHoisting1(new Array(5)); testDominatingTransitionHoisting1(new Array(5)); + // TODO(verwaest) With current changes the elements transition gets hoisted + // above the access, causing a deopt. We should update the type of access + // rather than forbid hoisting the transition. assertTrue(2 != %GetOptimizationStatus(testDominatingTransitionHoisting1)); + %ClearFunctionTypeFeedback(testDominatingTransitionHoisting1); + */ function testHoistingWithSideEffect(a) { var object = new Object(); @@ -166,10 +188,14 @@ if (support_smi_only_arrays) { } testHoistingWithSideEffect(new Array(5)); + testHoistingWithSideEffect(new Array(5)); // Call twice to make sure that + // second store is a transition and + // not optimistically MONOMORPHIC %OptimizeFunctionOnNextCall(testHoistingWithSideEffect); testHoistingWithSideEffect(new Array(5)); testHoistingWithSideEffect(new Array(5)); assertTrue(2 != %GetOptimizationStatus(testHoistingWithSideEffect)); + %ClearFunctionTypeFeedback(testHoistingWithSideEffect); function testStraightLineDupeElinination(a,b,c,d,e,f) { var count = 3; @@ -179,7 +205,7 @@ if (support_smi_only_arrays) { a[1] = c; a[2] = d; assertTrue(true); - a[3] = e; // TransitionElementsKind should be eliminated despite call. + a[3] = e; // TransitionElementsKind should be eliminated despite call. a[4] = f; } while (--count > 3); } @@ -205,7 +231,8 @@ if (support_smi_only_arrays) { testStraightLineDupeElinination(new Array(5),0,0,0,.5,0); testStraightLineDupeElinination(new Array(5),0,0,0,0,.5); %OptimizeFunctionOnNextCall(testStraightLineDupeElinination); - testStraightLineDupeElinination(new Array(5)); - testStraightLineDupeElinination(new Array(5)); + testStraightLineDupeElinination(new Array(5),0,0,0,0,0); + testStraightLineDupeElinination(new Array(5),0,0,0,0,0); assertTrue(2 != %GetOptimizationStatus(testStraightLineDupeElinination)); + %ClearFunctionTypeFeedback(testStraightLineDupeElinination); } diff --git a/src/3rdparty/v8/test/mjsunit/elements-transition.js b/src/3rdparty/v8/test/mjsunit/elements-transition.js index 60e051b..0dffd37 100644 --- a/src/3rdparty/v8/test/mjsunit/elements-transition.js +++ b/src/3rdparty/v8/test/mjsunit/elements-transition.js @@ -27,7 +27,7 @@ // Flags: --allow-natives-syntax --smi-only-arrays -support_smi_only_arrays = %HasFastSmiOnlyElements(new Array(1,2,3,4,5,6,7,8)); +support_smi_only_arrays = %HasFastSmiElements(new Array(1,2,3,4,5,6,7,8)); if (support_smi_only_arrays) { print("Tests include smi-only arrays."); @@ -44,8 +44,8 @@ if (support_smi_only_arrays) { var array_1 = new Array(length); var array_2 = new Array(length); - assertTrue(%HasFastSmiOnlyElements(array_1)); - assertTrue(%HasFastSmiOnlyElements(array_2)); + assertTrue(%HasFastSmiElements(array_1)); + assertTrue(%HasFastSmiElements(array_2)); for (var i = 0; i < length; i++) { if (i == length - 5 && test_double) { // Trigger conversion to fast double elements at length-5. @@ -57,8 +57,8 @@ if (support_smi_only_arrays) { // Trigger conversion to fast object elements at length-3. set(array_1, i, 'object'); set(array_2, i, 'object'); - assertTrue(%HasFastElements(array_1)); - assertTrue(%HasFastElements(array_2)); + assertTrue(%HasFastObjectElements(array_1)); + assertTrue(%HasFastObjectElements(array_2)); } else if (i != length - 7) { // Set the element to an integer but leave a hole at length-7. set(array_1, i, 2*i+1); diff --git a/src/3rdparty/v8/test/mjsunit/error-accessors.js b/src/3rdparty/v8/test/mjsunit/error-accessors.js new file mode 100644 index 0000000..9581050 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/error-accessors.js @@ -0,0 +1,54 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Test that the message property of error objects is a data property. + +var o; + +// message is constructed using the constructor. +var error1 = new Error("custom message"); +o = {}; +o.__proto__ = error1; + +assertEquals("custom message", + Object.getOwnPropertyDescriptor(error1, "message").value); +o.message = "another message"; +assertEquals("another message", o.message); +assertEquals("custom message", error1.message); + +// message is constructed by the runtime. +var error2; +try { x.x } catch (e) { error2 = e; } +o = {}; +o.__proto__ = error2; + +assertEquals("x is not defined", + Object.getOwnPropertyDescriptor(error2, "message").value); +o.message = "another message"; +assertEquals("another message", o.message); +assertEquals("x is not defined", error2.message); + diff --git a/src/3rdparty/v8/test/mjsunit/eval-stack-trace.js b/src/3rdparty/v8/test/mjsunit/eval-stack-trace.js new file mode 100644 index 0000000..723d522 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/eval-stack-trace.js @@ -0,0 +1,203 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Return the stack frames of an Error object. +Error.prototype.getFrames = function() { + Error.prepareStackTrace = function(error, frames) { + return frames; + } + var frames = this.stack; + Error.prepareStackTrace = undefined; + return frames; +} + +String.prototype.contains = function(pattern) { + return this.indexOf(pattern) > -1; +} + +// Check for every frame that a certain method returns the +// expected value for every frame. +Array.prototype.verifyEquals = function(frames, func_name) { + this.forEach( + function(element, index) { + var frame = frames[index]; + if (element === null) return; + assertEquals(element, (frame[func_name])()); + } + ); +} + +// Check for every frame that a certain method has a return value +// that contains the expected pattern for every frame. +Array.prototype.verifyContains = function(frames, func_name) { + this.forEach( + function(element, index) { + var frame = frames[index]; + if (element === null) return; + assertTrue((frame[func_name])().contains(element)); + } + ); +} + +// Check for every frame that a certain method returns undefined +// when expected. +Array.prototype.verifyUndefined = function(frames, func_name) { + this.forEach( + function(element, index) { + var frame = frames[index]; + if (element === null) return; + assertEquals(element, (frame[func_name])() === undefined); + } + ); +} + + +// Simple eval. +var code1 = "function f() { \n" + + " throw new Error(3); \n" + // Line 2 + "} \n" + + "f(); \n"; // Line 4 + +function g() { + eval(code1); +} + +try { + g(); +} catch (e) { + // We expect something like + // f (eval at g (eval-stack.js:87:8), <anonymous>:2:9) + // eval (eval at g (eval-stack.js:87:8), <anonymous>:4:1) + // g (eval-stack.js:87:3) + // eval-stack.js:94:3 + var frames = e.getFrames(); + assertEquals(4, frames.length); + ["f", "eval", "g"] + .verifyEquals(frames, "getFunctionName"); + [2, 4] + .verifyEquals(frames, "getLineNumber"); + ["<anonymous>:2:", "<anonymous>:4:"] + .verifyContains(frames, "toString"); + [true, true, false, false] + .verifyUndefined(frames, "getFileName"); + ["eval at g", "eval at g"] + .verifyContains(frames, "getEvalOrigin"); +} + + +// Nested eval. +var code2 = "function h() { \n" + + " // Empty \n" + + " eval(code1); \n" + // Line 3 + "} \n" + + "h(); \n"; // Line 5 + +try { + eval(code2); +} catch (e) { + // We expect something like + // f (eval at h (eval at <anonymous> (eval-stack.js:116:8)), + // <anonymous>:2:9) + // eval (eval at h (eval at <anonymous> (eval-stack.js:116:8)), + // <anonymous>:4:1) + // h (eval at <anonymous> (eval-stack.js:116:8), <anonymous>:3:3) + // eval (eval at <anonymous> (eval-stack.js:116:8), <anonymous>:5:1) + // eval-stack.js:116:3 + var frames = e.getFrames(); + assertEquals(5, frames.length); + ["f", "eval", "h", "eval"] + .verifyEquals(frames, "getFunctionName"); + [2, 4, 3, 5] + .verifyEquals(frames, "getLineNumber"); + ["<anonymous>:2:", "<anonymous>:4:", "<anonymous>:3:", "<anonymous>:5:"] + .verifyContains(frames, "toString"); + [true, true, true, true, false] + .verifyUndefined(frames, "getFileName"); + ["eval at h (eval at <anonymous> (", + "eval at h (eval at <anonymous> (", + "eval at <anonymous> (", + "eval at <anonymous> ("] + .verifyContains(frames, "getEvalOrigin"); +} + + +// Nested eval calling through non-eval defined function. +var code3 = "function h() { \n" + + " // Empty \n" + + " g(); \n" + // Line 3 + "} \n" + + "h(); \n"; // Line 5 + +try { + eval(code3); +} catch (e) { + // We expect something like + // f (eval at g (test.js:83:8), <anonymous>:2:9) + // eval (eval at g (test.js:83:8), <anonymous>:4:1) + // g (test.js:83:3) + // h (eval at <anonymous> (test.js:149:8), <anonymous>:3:3) + // eval (eval at <anonymous> (test.js:149:8), <anonymous>:5:1) + // test.js:149:3 + var frames = e.getFrames(); + assertEquals(6, frames.length); + ["f", "eval", "g", "h", "eval"] + .verifyEquals(frames, "getFunctionName"); + [2, 4, null, 3, 5] + .verifyEquals(frames, "getLineNumber"); + ["<anonymous>:2:", "<anonymous>:4:", null, "<anonymous>:3:", "<anonymous>:5:"] + .verifyContains(frames, "toString"); + [true, true, false, true, true, false] + .verifyUndefined(frames, "getFileName"); + ["eval at g (", + "eval at g (", + null, + "eval at <anonymous> (", + "eval at <anonymous> ("] + .verifyContains(frames, "getEvalOrigin"); +} + + +// Calling function defined in eval. +eval("function f() { \n" + + " throw new Error(3); \n" + + "} \n"); + +try { + f(); +} catch (e) { + // We expect something like + // f (eval at <anonymous> (test.js:182:40), <anonymous>:2:9) + // test.js:186:3 + var frames = e.getFrames(); + assertEquals(2, frames.length); + ["f"].verifyEquals(frames, "getFunctionName"); + [2].verifyEquals(frames, "getLineNumber"); + ["<anonymous>:2:"].verifyContains(frames, "toString"); + [true, false].verifyUndefined(frames, "getFileName"); + ["eval at <anonymous> ("].verifyContains(frames, "getEvalOrigin"); +} + diff --git a/src/3rdparty/v8/test/mjsunit/external-array.js b/src/3rdparty/v8/test/mjsunit/external-array.js index 32f78a7..85a8cc5 100644 --- a/src/3rdparty/v8/test/mjsunit/external-array.js +++ b/src/3rdparty/v8/test/mjsunit/external-array.js @@ -27,6 +27,12 @@ // Flags: --allow-natives-syntax --expose-gc +// Helper +function assertInstance(o, f) { + assertSame(o.constructor, f); + assertInstanceof(o, f); +} + // This is a regression test for overlapping key and value registers. function f(a) { a[0] = 0; @@ -51,14 +57,63 @@ assertThrows(abfunc1); // Test derivation from an ArrayBuffer var ab = new ArrayBuffer(12); +assertInstance(ab, ArrayBuffer); var derived_uint8 = new Uint8Array(ab); +assertInstance(derived_uint8, Uint8Array); +assertSame(ab, derived_uint8.buffer); assertEquals(12, derived_uint8.length); +assertEquals(12, derived_uint8.byteLength); +assertEquals(0, derived_uint8.byteOffset); +assertEquals(1, derived_uint8.BYTES_PER_ELEMENT); +var derived_uint8_2 = new Uint8Array(ab,7); +assertInstance(derived_uint8_2, Uint8Array); +assertSame(ab, derived_uint8_2.buffer); +assertEquals(5, derived_uint8_2.length); +assertEquals(5, derived_uint8_2.byteLength); +assertEquals(7, derived_uint8_2.byteOffset); +assertEquals(1, derived_uint8_2.BYTES_PER_ELEMENT); +var derived_int16 = new Int16Array(ab); +assertInstance(derived_int16, Int16Array); +assertSame(ab, derived_int16.buffer); +assertEquals(6, derived_int16.length); +assertEquals(12, derived_int16.byteLength); +assertEquals(0, derived_int16.byteOffset); +assertEquals(2, derived_int16.BYTES_PER_ELEMENT); +var derived_int16_2 = new Int16Array(ab,6); +assertInstance(derived_int16_2, Int16Array); +assertSame(ab, derived_int16_2.buffer); +assertEquals(3, derived_int16_2.length); +assertEquals(6, derived_int16_2.byteLength); +assertEquals(6, derived_int16_2.byteOffset); +assertEquals(2, derived_int16_2.BYTES_PER_ELEMENT); var derived_uint32 = new Uint32Array(ab); +assertInstance(derived_uint32, Uint32Array); +assertSame(ab, derived_uint32.buffer); assertEquals(3, derived_uint32.length); +assertEquals(12, derived_uint32.byteLength); +assertEquals(0, derived_uint32.byteOffset); +assertEquals(4, derived_uint32.BYTES_PER_ELEMENT); var derived_uint32_2 = new Uint32Array(ab,4); +assertInstance(derived_uint32_2, Uint32Array); +assertSame(ab, derived_uint32_2.buffer); assertEquals(2, derived_uint32_2.length); +assertEquals(8, derived_uint32_2.byteLength); +assertEquals(4, derived_uint32_2.byteOffset); +assertEquals(4, derived_uint32_2.BYTES_PER_ELEMENT); var derived_uint32_3 = new Uint32Array(ab,4,1); +assertInstance(derived_uint32_3, Uint32Array); +assertSame(ab, derived_uint32_3.buffer); assertEquals(1, derived_uint32_3.length); +assertEquals(4, derived_uint32_3.byteLength); +assertEquals(4, derived_uint32_3.byteOffset); +assertEquals(4, derived_uint32_3.BYTES_PER_ELEMENT); +var derived_float64 = new Float64Array(ab,0,1); +assertInstance(derived_float64, Float64Array); +assertSame(ab, derived_float64.buffer); +assertEquals(1, derived_float64.length); +assertEquals(8, derived_float64.byteLength); +assertEquals(0, derived_float64.byteOffset); +assertEquals(8, derived_float64.BYTES_PER_ELEMENT); // If a given byteOffset and length references an area beyond the end of the // ArrayBuffer an exception is raised. @@ -87,6 +142,25 @@ function abfunc6() { } assertThrows(abfunc6); +// Test that an array constructed without an array buffer creates one properly. +a = new Uint8Array(31); +assertEquals(a.byteLength, a.buffer.byteLength); +assertEquals(a.length, a.buffer.byteLength); +assertEquals(a.length * a.BYTES_PER_ELEMENT, a.buffer.byteLength); +a = new Int16Array(5); +assertEquals(a.byteLength, a.buffer.byteLength); +assertEquals(a.length * a.BYTES_PER_ELEMENT, a.buffer.byteLength); +a = new Float64Array(7); +assertEquals(a.byteLength, a.buffer.byteLength); +assertEquals(a.length * a.BYTES_PER_ELEMENT, a.buffer.byteLength); + +// Test that an implicitly created buffer is a valid buffer. +a = new Float64Array(7); +assertSame(a.buffer, (new Uint16Array(a.buffer)).buffer); +assertSame(a.buffer, (new Float32Array(a.buffer,4)).buffer); +assertSame(a.buffer, (new Int8Array(a.buffer,3,51)).buffer); +assertInstance(a.buffer, ArrayBuffer); + // Test the correct behavior of the |BYTES_PER_ELEMENT| property (which is // "constant", but not read-only). a = new Int32Array(2); @@ -140,7 +214,7 @@ assertEquals(4, array_with_length_from_non_number.length); // Test loads and stores. types = [Array, Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, - Uint32Array, PixelArray, Float32Array, Float64Array]; + Uint32Array, Uint8ClampedArray, Float32Array, Float64Array]; test_result_nan = [NaN, 0, 0, 0, 0, 0, 0, 0, NaN, NaN]; test_result_low_int = [-1, -1, 255, -1, 65535, -1, 0xFFFFFFFF, 0, -1, -1]; @@ -351,3 +425,292 @@ assertTrue(isNaN(float64_array[0])); %OptimizeFunctionOnNextCall(store_float64_undefined); store_float64_undefined(float64_array); assertTrue(isNaN(float64_array[0])); + + +// Check handling of 0-sized buffers and arrays. +ab = new ArrayBuffer(0); +assertInstance(ab, ArrayBuffer); +assertEquals(0, ab.byteLength); +a = new Int8Array(ab); +assertInstance(a, Int8Array); +assertEquals(0, a.byteLength); +assertEquals(0, a.length); +a[0] = 1; +assertEquals(undefined, a[0]); +ab = new ArrayBuffer(16); +assertInstance(ab, ArrayBuffer); +a = new Float32Array(ab,4,0); +assertInstance(a, Float32Array); +assertEquals(0, a.byteLength); +assertEquals(0, a.length); +a[0] = 1; +assertEquals(undefined, a[0]); +a = new Uint16Array(0); +assertInstance(a, Uint16Array); +assertEquals(0, a.byteLength); +assertEquals(0, a.length); +a[0] = 1; +assertEquals(undefined, a[0]); + + +// Check construction from arrays. +a = new Uint32Array([]); +assertInstance(a, Uint32Array); +assertEquals(0, a.length); +assertEquals(0, a.byteLength); +assertEquals(0, a.buffer.byteLength); +assertEquals(4, a.BYTES_PER_ELEMENT); +assertInstance(a.buffer, ArrayBuffer); +a = new Uint16Array([1,2,3]); +assertInstance(a, Uint16Array); +assertEquals(3, a.length); +assertEquals(6, a.byteLength); +assertEquals(6, a.buffer.byteLength); +assertEquals(2, a.BYTES_PER_ELEMENT); +assertEquals(1, a[0]); +assertEquals(3, a[2]); +assertInstance(a.buffer, ArrayBuffer); +a = new Uint32Array(a); +assertInstance(a, Uint32Array); +assertEquals(3, a.length); +assertEquals(12, a.byteLength); +assertEquals(12, a.buffer.byteLength); +assertEquals(4, a.BYTES_PER_ELEMENT); +assertEquals(1, a[0]); +assertEquals(3, a[2]); +assertInstance(a.buffer, ArrayBuffer); + +// Check subarrays. +a = new Uint16Array([1,2,3,4,5,6]); +aa = a.subarray(3); +assertInstance(aa, Uint16Array); +assertEquals(3, aa.length); +assertEquals(6, aa.byteLength); +assertEquals(2, aa.BYTES_PER_ELEMENT); +assertSame(a.buffer, aa.buffer); +aa = a.subarray(3,5); +assertInstance(aa, Uint16Array); +assertEquals(2, aa.length); +assertEquals(4, aa.byteLength); +assertEquals(2, aa.BYTES_PER_ELEMENT); +assertSame(a.buffer, aa.buffer); +aa = a.subarray(4,8); +assertInstance(aa, Uint16Array); +assertEquals(2, aa.length); +assertEquals(4, aa.byteLength); +assertEquals(2, aa.BYTES_PER_ELEMENT); +assertSame(a.buffer, aa.buffer); +aa = a.subarray(9); +assertInstance(aa, Uint16Array); +assertEquals(0, aa.length); +assertEquals(0, aa.byteLength); +assertEquals(2, aa.BYTES_PER_ELEMENT); +assertSame(a.buffer, aa.buffer); +aa = a.subarray(-4); +assertInstance(aa, Uint16Array); +assertEquals(4, aa.length); +assertEquals(8, aa.byteLength); +assertEquals(2, aa.BYTES_PER_ELEMENT); +assertSame(a.buffer, aa.buffer); +aa = a.subarray(-3,-1); +assertInstance(aa, Uint16Array); +assertEquals(2, aa.length); +assertEquals(4, aa.byteLength); +assertEquals(2, aa.BYTES_PER_ELEMENT); +assertSame(a.buffer, aa.buffer); +aa = a.subarray(3,2); +assertInstance(aa, Uint16Array); +assertEquals(0, aa.length); +assertEquals(0, aa.byteLength); +assertEquals(2, aa.BYTES_PER_ELEMENT); +assertSame(a.buffer, aa.buffer); +aa = a.subarray(-3,-4); +assertInstance(aa, Uint16Array); +assertEquals(0, aa.length); +assertEquals(0, aa.byteLength); +assertEquals(2, aa.BYTES_PER_ELEMENT); +assertSame(a.buffer, aa.buffer); +aa = a.subarray(0,-8); +assertInstance(aa, Uint16Array); +assertEquals(0, aa.length); +assertEquals(0, aa.byteLength); +assertEquals(2, aa.BYTES_PER_ELEMENT); +assertSame(a.buffer, aa.buffer); + +assertThrows(function(){ a.subarray.call({}, 0) }); +assertThrows(function(){ a.subarray.call([], 0) }); +assertThrows(function(){ a.subarray.call(a) }); + + +// Call constructors directly as functions, and through .call and .apply + +b = ArrayBuffer(100) +a = Int8Array(b, 5, 77) +assertInstance(b, ArrayBuffer) +assertInstance(a, Int8Array) +assertSame(b, a.buffer) +assertEquals(5, a.byteOffset) +assertEquals(77, a.byteLength) +b = ArrayBuffer.call(null, 10) +a = Uint16Array.call(null, b, 2, 4) +assertInstance(b, ArrayBuffer) +assertInstance(a, Uint16Array) +assertSame(b, a.buffer) +assertEquals(2, a.byteOffset) +assertEquals(8, a.byteLength) +b = ArrayBuffer.apply(null, [1000]) +a = Float32Array.apply(null, [b, 128, 1]) +assertInstance(b, ArrayBuffer) +assertInstance(a, Float32Array) +assertSame(b, a.buffer) +assertEquals(128, a.byteOffset) +assertEquals(4, a.byteLength) + + +// Test array.set in different combinations. + +function assertArrayPrefix(expected, array) { + for (var i = 0; i < expected.length; ++i) { + assertEquals(expected[i], array[i]); + } +} + +var a11 = new Int16Array([1, 2, 3, 4, 0, -1]) +var a12 = new Uint16Array(15) +a12.set(a11, 3) +assertArrayPrefix([0, 0, 0, 1, 2, 3, 4, 0, 0xffff, 0, 0], a12) +assertThrows(function(){ a11.set(a12) }) + +var a21 = [1, undefined, 10, NaN, 0, -1, {valueOf: function() {return 3}}] +var a22 = new Int32Array(12) +a22.set(a21, 2) +assertArrayPrefix([0, 0, 1, 0, 10, 0, 0, -1, 3, 0], a22) + +var a31 = new Float32Array([2, 4, 6, 8, 11, NaN, 1/0, -3]) +var a32 = a31.subarray(2, 6) +a31.set(a32, 4) +assertArrayPrefix([2, 4, 6, 8, 6, 8, 11, NaN], a31) +assertArrayPrefix([6, 8, 6, 8], a32) + +var a4 = new Uint8ClampedArray([3,2,5,6]) +a4.set(a4) +assertArrayPrefix([3, 2, 5, 6], a4) + +// Cases with overlapping backing store but different element sizes. +var b = new ArrayBuffer(4) +var a5 = new Int16Array(b) +var a50 = new Int8Array(b) +var a51 = new Int8Array(b, 0, 2) +var a52 = new Int8Array(b, 1, 2) +var a53 = new Int8Array(b, 2, 2) + +a5.set([0x5050, 0x0a0a]) +assertArrayPrefix([0x50, 0x50, 0x0a, 0x0a], a50) +assertArrayPrefix([0x50, 0x50], a51) +assertArrayPrefix([0x50, 0x0a], a52) +assertArrayPrefix([0x0a, 0x0a], a53) + +a50.set([0x50, 0x50, 0x0a, 0x0a]) +a51.set(a5) +assertArrayPrefix([0x50, 0x0a, 0x0a, 0x0a], a50) + +a50.set([0x50, 0x50, 0x0a, 0x0a]) +a52.set(a5) +assertArrayPrefix([0x50, 0x50, 0x0a, 0x0a], a50) + +a50.set([0x50, 0x50, 0x0a, 0x0a]) +a53.set(a5) +assertArrayPrefix([0x50, 0x50, 0x50, 0x0a], a50) + +a50.set([0x50, 0x51, 0x0a, 0x0b]) +a5.set(a51) +assertArrayPrefix([0x0050, 0x0051], a5) + +a50.set([0x50, 0x51, 0x0a, 0x0b]) +a5.set(a52) +assertArrayPrefix([0x0051, 0x000a], a5) + +a50.set([0x50, 0x51, 0x0a, 0x0b]) +a5.set(a53) +assertArrayPrefix([0x000a, 0x000b], a5) + +// Mixed types of same size. +var a61 = new Float32Array([1.2, 12.3]) +var a62 = new Int32Array(2) +a62.set(a61) +assertArrayPrefix([1, 12], a62) +a61.set(a62) +assertArrayPrefix([1, 12], a61) + +// Invalid source +assertThrows(function() { a.set(0) }) +assertThrows(function() { a.set({}) }) + + +// Test arraybuffer.slice + +var a0 = new Int8Array([1, 2, 3, 4, 5, 6]) +var b0 = a0.buffer + +var b1 = b0.slice(0) +assertEquals(b0.byteLength, b1.byteLength) +assertArrayPrefix([1, 2, 3, 4, 5, 6], Int8Array(b1)) + +var b2 = b0.slice(3) +assertEquals(b0.byteLength - 3, b2.byteLength) +assertArrayPrefix([4, 5, 6], Int8Array(b2)) + +var b3 = b0.slice(2, 4) +assertEquals(2, b3.byteLength) +assertArrayPrefix([3, 4], Int8Array(b3)) + +function goo(a, i) { + return a[i]; +} + +function boo(a, i, v) { + return a[i] = v; +} + +function do_tagged_index_external_array_test(constructor) { + var t_array = new constructor([1, 2, 3, 4, 5, 6]); + assertEquals(1, goo(t_array, 0)); + assertEquals(1, goo(t_array, 0)); + boo(t_array, 0, 13); + assertEquals(13, goo(t_array, 0)); + %OptimizeFunctionOnNextCall(goo); + %OptimizeFunctionOnNextCall(boo); + boo(t_array, 0, 15); + assertEquals(15, goo(t_array, 0)); + %ClearFunctionTypeFeedback(goo); + %ClearFunctionTypeFeedback(boo); +} + +do_tagged_index_external_array_test(Int8Array); +do_tagged_index_external_array_test(Uint8Array); +do_tagged_index_external_array_test(Int16Array); +do_tagged_index_external_array_test(Uint16Array); +do_tagged_index_external_array_test(Int32Array); +do_tagged_index_external_array_test(Uint32Array); +do_tagged_index_external_array_test(Float32Array); +do_tagged_index_external_array_test(Float64Array); + +var built_in_array = new Array(1, 2, 3, 4, 5, 6); +assertEquals(1, goo(built_in_array, 0)); +assertEquals(1, goo(built_in_array, 0)); +%OptimizeFunctionOnNextCall(goo); +%OptimizeFunctionOnNextCall(boo); +boo(built_in_array, 0, 11); +assertEquals(11, goo(built_in_array, 0)); +%ClearFunctionTypeFeedback(goo); +%ClearFunctionTypeFeedback(boo); + +built_in_array = new Array(1.5, 2, 3, 4, 5, 6); +assertEquals(1.5, goo(built_in_array, 0)); +assertEquals(1.5, goo(built_in_array, 0)); +%OptimizeFunctionOnNextCall(goo); +%OptimizeFunctionOnNextCall(boo); +boo(built_in_array, 0, 2.5); +assertEquals(2.5, goo(built_in_array, 0)); +%ClearFunctionTypeFeedback(goo); +%ClearFunctionTypeFeedback(boo); diff --git a/src/3rdparty/v8/test/mjsunit/fast-array-length.js b/src/3rdparty/v8/test/mjsunit/fast-array-length.js new file mode 100644 index 0000000..42f2c38 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/fast-array-length.js @@ -0,0 +1,37 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +// This is a regression test for overlapping key and value registers. + + +var a = [0, 1, 2, 3, 4, 5]; +assertTrue(%HasFastSmiElements(a)); +a.length = (1 << 30); +assertFalse(%HasFastSmiElements(a)); + diff --git a/src/3rdparty/v8/test/mjsunit/fast-non-keyed.js b/src/3rdparty/v8/test/mjsunit/fast-non-keyed.js new file mode 100644 index 0000000..c2f7fc7 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/fast-non-keyed.js @@ -0,0 +1,113 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +// Check that keyed stores make things go dict mode faster than non-keyed +// stores. + +function AddProps(obj) { + for (var i = 0; i < 26; i++) { + obj["x" + i] = 0; + } +} + + +function AddPropsNonKeyed(obj) { + obj.x0 = 0; + obj.x1 = 0; + obj.x2 = 0; + obj.x3 = 0; + obj.x4 = 0; + obj.x5 = 0; + obj.x6 = 0; + obj.x7 = 0; + obj.x8 = 0; + obj.x9 = 0; + obj.x10 = 0; + obj.x11 = 0; + obj.x12 = 0; + obj.x13 = 0; + obj.x14 = 0; + obj.x15 = 0; + obj.x16 = 0; + obj.x17 = 0; + obj.x18 = 0; + obj.x19 = 0; + obj.x20 = 0; + obj.x21 = 0; + obj.x22 = 0; + obj.x23 = 0; + obj.x24 = 0; + obj.x25 = 0; +} + +function AddProps3(obj) { + obj["x0"] = 0; + obj["x1"] = 0; + obj["x2"] = 0; + obj["x3"] = 0; + obj["x4"] = 0; + obj["x5"] = 0; + obj["x6"] = 0; + obj["x7"] = 0; + obj["x8"] = 0; + obj["x9"] = 0; + obj["x10"] = 0; + obj["x11"] = 0; + obj["x12"] = 0; + obj["x13"] = 0; + obj["x14"] = 0; + obj["x15"] = 0; + obj["x16"] = 0; + obj["x17"] = 0; + obj["x18"] = 0; + obj["x19"] = 0; + obj["x20"] = 0; + obj["x21"] = 0; + obj["x22"] = 0; + obj["x23"] = 0; + obj["x24"] = 0; + obj["x25"] = 0; +} + + +var keyed = {}; +AddProps(keyed); +assertFalse(%HasFastProperties(keyed)); + +var non_keyed = {}; +AddPropsNonKeyed(non_keyed); +assertTrue(%HasFastProperties(non_keyed)); + +var obj3 = {}; +AddProps3(obj3); +assertTrue(%HasFastProperties(obj3)); + +var bad_name = {}; +bad_name[".foo"] = 0; +assertFalse(%HasFastProperties(bad_name)); diff --git a/src/3rdparty/v8/test/mjsunit/fast-prototype.js b/src/3rdparty/v8/test/mjsunit/fast-prototype.js new file mode 100644 index 0000000..7fd73a4 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/fast-prototype.js @@ -0,0 +1,113 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +// Check that objects that are used for prototypes are in the fast mode. + +function Super() { +} + + +function Sub() { +} + + +function AddProps(obj) { + for (var i = 0; i < 26; i++) { + obj["x" + i] = 0; + } +} + + +function DoProtoMagic(proto, set__proto__) { + if (set__proto__) { + (new Sub()).__proto__ = proto; + } else { + Sub.prototype = proto; + } +} + + +function test(use_new, add_first, set__proto__, same_map_as) { + var proto = use_new ? new Super() : {}; + + // New object is fast. + assertTrue(%HasFastProperties(proto)); + + if (add_first) { + AddProps(proto); + // Adding this many properties makes it slow. + assertFalse(%HasFastProperties(proto)); + DoProtoMagic(proto, set__proto__); + // Making it a prototype makes it fast again. + assertTrue(%HasFastProperties(proto)); + } else { + DoProtoMagic(proto, set__proto__); + // Still fast + assertTrue(%HasFastProperties(proto)); + AddProps(proto); + // After we add all those properties it went slow mode again :-( + assertFalse(%HasFastProperties(proto)); + } + if (same_map_as && !add_first) { + assertTrue(%HaveSameMap(same_map_as, proto)); + } + return proto; +} + + +for (var i = 0; i < 4; i++) { + var set__proto__ = ((i & 1) != 0); + var use_new = ((i & 2) != 0); + + test(use_new, true, set__proto__); + + var last = test(use_new, false, set__proto__); + test(use_new, false, set__proto__, last); +} + + +var x = {a: 1, b: 2, c: 3}; +var o = { __proto__: x }; +assertTrue(%HasFastProperties(x)); +for (key in x) { + assertTrue(key == 'a'); + break; +} +delete x.b; +for (key in x) { + assertTrue(key == 'a'); + break; +} +assertFalse(%HasFastProperties(x)); +x.d = 4; +assertFalse(%HasFastProperties(x)); +for (key in x) { + assertTrue(key == 'a'); + break; +} diff --git a/src/3rdparty/v8/test/mjsunit/fuzz-natives.js b/src/3rdparty/v8/test/mjsunit/fuzz-natives-part1.js index 2965e74..6941d80 100644 --- a/src/3rdparty/v8/test/mjsunit/fuzz-natives.js +++ b/src/3rdparty/v8/test/mjsunit/fuzz-natives-part1.js @@ -149,6 +149,7 @@ var knownProblems = { "PushBlockContext": true, "LazyCompile": true, "LazyRecompile": true, + "ParallelRecompile": true, "NotifyDeoptimized": true, "NotifyOSR": true, "CreateObjectLiteralBoilerplate": true, @@ -204,7 +205,9 @@ var currentlyUncallable = { function testNatives() { var allNatives = %ListNatives(); - for (var i = 0; i < allNatives.length; i++) { + var start = 0; + var stop = (allNatives.length >> 2); + for (var i = start; i < stop; i++) { var nativeInfo = allNatives[i]; var name = nativeInfo[0]; if (name in knownProblems || name in currentlyUncallable) diff --git a/src/3rdparty/v8/test/mjsunit/fuzz-natives-part2.js b/src/3rdparty/v8/test/mjsunit/fuzz-natives-part2.js new file mode 100644 index 0000000..ea8a2cf --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/fuzz-natives-part2.js @@ -0,0 +1,222 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +var RUN_WITH_ALL_ARGUMENT_ENTRIES = false; +var kOnManyArgumentsRemove = 5; + +function makeArguments() { + var result = [ ]; + result.push(17); + result.push(-31); + result.push(new Array(100)); + result.push(new Array(100003)); + result.push(Number.MIN_VALUE); + result.push("whoops"); + result.push("x"); + result.push({"x": 1, "y": 2}); + var slowCaseObj = {"a": 3, "b": 4, "c": 5}; + delete slowCaseObj.c; + result.push(slowCaseObj); + result.push(function () { return 8; }); + return result; +} + +var kArgObjects = makeArguments().length; + +function makeFunction(name, argc) { + var args = []; + for (var i = 0; i < argc; i++) + args.push("x" + i); + var argsStr = args.join(", "); + return new Function(args.join(", "), "return %" + name + "(" + argsStr + ");"); +} + +function testArgumentCount(name, argc) { + for (var i = 0; i < 10; i++) { + var func = null; + try { + func = makeFunction(name, i); + } catch (e) { + if (e != "SyntaxError: Illegal access") throw e; + } + if (func === null && i == argc) { + throw "unexpected exception"; + } + var args = [ ]; + for (var j = 0; j < i; j++) + args.push(0); + try { + func.apply(void 0, args); + } catch (e) { + // we don't care what happens as long as we don't crash + } + } +} + +function testArgumentTypes(name, argc) { + var type = 0; + var hasMore = true; + var func = makeFunction(name, argc); + while (hasMore) { + var argPool = makeArguments(); + // When we have 5 or more arguments we lower the amount of tests cases + // by randomly removing kOnManyArgumentsRemove entries + var numArguments = RUN_WITH_ALL_ARGUMENT_ENTRIES ? + kArgObjects : kArgObjects-kOnManyArgumentsRemove; + if (argc >= 5 && !RUN_WITH_ALL_ARGUMENT_ENTRIES) { + for (var i = 0; i < kOnManyArgumentsRemove; i++) { + var rand = Math.floor(Math.random() * (kArgObjects - i)); + argPool.splice(rand,1); + } + } + var current = type; + var hasMore = false; + var argList = [ ]; + for (var i = 0; i < argc; i++) { + var index = current % numArguments; + current = (current / numArguments) << 0; + if (index != (numArguments - 1)) + hasMore = true; + argList.push(argPool[index]); + } + try { + func.apply(void 0, argList); + } catch (e) { + // we don't care what happens as long as we don't crash + } + type++; + } +} + +var knownProblems = { + "Abort": true, + + // Avoid calling the concat operation, because weird lengths + // may lead to out-of-memory. Ditto for StringBuilderJoin. + "StringBuilderConcat": true, + "StringBuilderJoin": true, + + // These functions use pseudo-stack-pointers and are not robust + // to unexpected integer values. + "DebugEvaluate": true, + + // These functions do nontrivial error checking in recursive calls, + // which means that we have to propagate errors back. + "SetFunctionBreakPoint": true, + "SetScriptBreakPoint": true, + "PrepareStep": true, + + // Too slow. + "DebugReferencedBy": true, + + // Calling disable/enable access checks may interfere with the + // the rest of the tests. + "DisableAccessChecks": true, + "EnableAccessChecks": true, + + // These functions should not be callable as runtime functions. + "NewFunctionContext": true, + "NewArgumentsFast": true, + "NewStrictArgumentsFast": true, + "PushWithContext": true, + "PushCatchContext": true, + "PushBlockContext": true, + "LazyCompile": true, + "LazyRecompile": true, + "ParallelRecompile": true, + "NotifyDeoptimized": true, + "NotifyOSR": true, + "CreateObjectLiteralBoilerplate": true, + "CloneLiteralBoilerplate": true, + "CloneShallowLiteralBoilerplate": true, + "CreateArrayLiteralBoilerplate": true, + "IS_VAR": true, + "ResolvePossiblyDirectEval": true, + "Log": true, + "DeclareGlobals": true, + + "PromoteScheduledException": true, + "DeleteHandleScopeExtensions": true, + + // Vararg with minimum number > 0. + "Call": true, + + // Requires integer arguments to be non-negative. + "Apply": true, + + // That can only be invoked on Array.prototype. + "FinishArrayPrototypeSetup": true, + + "_SwapElements": true, + + // Performance critical functions which cannot afford type checks. + "_IsNativeOrStrictMode": true, + "_CallFunction": true, + + // Tries to allocate based on argument, and (correctly) throws + // out-of-memory if the request is too large. In practice, the + // size will be the number of captures of a RegExp. + "RegExpConstructResult": true, + "_RegExpConstructResult": true, + + // This functions perform some checks compile time (they require one of their + // arguments to be a compile time smi). + "_DateField": true, + "_GetFromCache": true, + + // This function expects its first argument to be a non-smi. + "_IsStringWrapperSafeForDefaultValueOf" : true, + + // Only applicable to strings. + "_HasCachedArrayIndex": true, + "_GetCachedArrayIndex": true +}; + +var currentlyUncallable = { + // We need to find a way to test this without breaking the system. + "SystemBreak": true +}; + +function testNatives() { + var allNatives = %ListNatives(); + var start = allNatives.length >> 2; + var stop = (allNatives.length >> 2)*2; + for (var i = start; i < stop; i++) { + var nativeInfo = allNatives[i]; + var name = nativeInfo[0]; + if (name in knownProblems || name in currentlyUncallable) + continue; + print(name); + var argc = nativeInfo[1]; + testArgumentCount(name, argc); + testArgumentTypes(name, argc); + } +} + +testNatives(); diff --git a/src/3rdparty/v8/test/mjsunit/fuzz-natives-part3.js b/src/3rdparty/v8/test/mjsunit/fuzz-natives-part3.js new file mode 100644 index 0000000..ecfdf97 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/fuzz-natives-part3.js @@ -0,0 +1,222 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +var RUN_WITH_ALL_ARGUMENT_ENTRIES = false; +var kOnManyArgumentsRemove = 5; + +function makeArguments() { + var result = [ ]; + result.push(17); + result.push(-31); + result.push(new Array(100)); + result.push(new Array(100003)); + result.push(Number.MIN_VALUE); + result.push("whoops"); + result.push("x"); + result.push({"x": 1, "y": 2}); + var slowCaseObj = {"a": 3, "b": 4, "c": 5}; + delete slowCaseObj.c; + result.push(slowCaseObj); + result.push(function () { return 8; }); + return result; +} + +var kArgObjects = makeArguments().length; + +function makeFunction(name, argc) { + var args = []; + for (var i = 0; i < argc; i++) + args.push("x" + i); + var argsStr = args.join(", "); + return new Function(args.join(", "), "return %" + name + "(" + argsStr + ");"); +} + +function testArgumentCount(name, argc) { + for (var i = 0; i < 10; i++) { + var func = null; + try { + func = makeFunction(name, i); + } catch (e) { + if (e != "SyntaxError: Illegal access") throw e; + } + if (func === null && i == argc) { + throw "unexpected exception"; + } + var args = [ ]; + for (var j = 0; j < i; j++) + args.push(0); + try { + func.apply(void 0, args); + } catch (e) { + // we don't care what happens as long as we don't crash + } + } +} + +function testArgumentTypes(name, argc) { + var type = 0; + var hasMore = true; + var func = makeFunction(name, argc); + while (hasMore) { + var argPool = makeArguments(); + // When we have 5 or more arguments we lower the amount of tests cases + // by randomly removing kOnManyArgumentsRemove entries + var numArguments = RUN_WITH_ALL_ARGUMENT_ENTRIES ? + kArgObjects : kArgObjects-kOnManyArgumentsRemove; + if (argc >= 5 && !RUN_WITH_ALL_ARGUMENT_ENTRIES) { + for (var i = 0; i < kOnManyArgumentsRemove; i++) { + var rand = Math.floor(Math.random() * (kArgObjects - i)); + argPool.splice(rand,1); + } + } + var current = type; + var hasMore = false; + var argList = [ ]; + for (var i = 0; i < argc; i++) { + var index = current % numArguments; + current = (current / numArguments) << 0; + if (index != (numArguments - 1)) + hasMore = true; + argList.push(argPool[index]); + } + try { + func.apply(void 0, argList); + } catch (e) { + // we don't care what happens as long as we don't crash + } + type++; + } +} + +var knownProblems = { + "Abort": true, + + // Avoid calling the concat operation, because weird lengths + // may lead to out-of-memory. Ditto for StringBuilderJoin. + "StringBuilderConcat": true, + "StringBuilderJoin": true, + + // These functions use pseudo-stack-pointers and are not robust + // to unexpected integer values. + "DebugEvaluate": true, + + // These functions do nontrivial error checking in recursive calls, + // which means that we have to propagate errors back. + "SetFunctionBreakPoint": true, + "SetScriptBreakPoint": true, + "PrepareStep": true, + + // Too slow. + "DebugReferencedBy": true, + + // Calling disable/enable access checks may interfere with the + // the rest of the tests. + "DisableAccessChecks": true, + "EnableAccessChecks": true, + + // These functions should not be callable as runtime functions. + "NewFunctionContext": true, + "NewArgumentsFast": true, + "NewStrictArgumentsFast": true, + "PushWithContext": true, + "PushCatchContext": true, + "PushBlockContext": true, + "LazyCompile": true, + "LazyRecompile": true, + "ParallelRecompile": true, + "NotifyDeoptimized": true, + "NotifyOSR": true, + "CreateObjectLiteralBoilerplate": true, + "CloneLiteralBoilerplate": true, + "CloneShallowLiteralBoilerplate": true, + "CreateArrayLiteralBoilerplate": true, + "IS_VAR": true, + "ResolvePossiblyDirectEval": true, + "Log": true, + "DeclareGlobals": true, + + "PromoteScheduledException": true, + "DeleteHandleScopeExtensions": true, + + // Vararg with minimum number > 0. + "Call": true, + + // Requires integer arguments to be non-negative. + "Apply": true, + + // That can only be invoked on Array.prototype. + "FinishArrayPrototypeSetup": true, + + "_SwapElements": true, + + // Performance critical functions which cannot afford type checks. + "_IsNativeOrStrictMode": true, + "_CallFunction": true, + + // Tries to allocate based on argument, and (correctly) throws + // out-of-memory if the request is too large. In practice, the + // size will be the number of captures of a RegExp. + "RegExpConstructResult": true, + "_RegExpConstructResult": true, + + // This functions perform some checks compile time (they require one of their + // arguments to be a compile time smi). + "_DateField": true, + "_GetFromCache": true, + + // This function expects its first argument to be a non-smi. + "_IsStringWrapperSafeForDefaultValueOf" : true, + + // Only applicable to strings. + "_HasCachedArrayIndex": true, + "_GetCachedArrayIndex": true +}; + +var currentlyUncallable = { + // We need to find a way to test this without breaking the system. + "SystemBreak": true +}; + +function testNatives() { + var allNatives = %ListNatives(); + var start = (allNatives.length >> 2)*2; + var stop = (allNatives.length >> 2)*3; + for (var i = start; i < stop; i++) { + var nativeInfo = allNatives[i]; + var name = nativeInfo[0]; + if (name in knownProblems || name in currentlyUncallable) + continue; + print(name); + var argc = nativeInfo[1]; + testArgumentCount(name, argc); + testArgumentTypes(name, argc); + } +} + +testNatives(); diff --git a/src/3rdparty/v8/test/mjsunit/fuzz-natives-part4.js b/src/3rdparty/v8/test/mjsunit/fuzz-natives-part4.js new file mode 100644 index 0000000..da04596 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/fuzz-natives-part4.js @@ -0,0 +1,222 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +var RUN_WITH_ALL_ARGUMENT_ENTRIES = false; +var kOnManyArgumentsRemove = 5; + +function makeArguments() { + var result = [ ]; + result.push(17); + result.push(-31); + result.push(new Array(100)); + result.push(new Array(100003)); + result.push(Number.MIN_VALUE); + result.push("whoops"); + result.push("x"); + result.push({"x": 1, "y": 2}); + var slowCaseObj = {"a": 3, "b": 4, "c": 5}; + delete slowCaseObj.c; + result.push(slowCaseObj); + result.push(function () { return 8; }); + return result; +} + +var kArgObjects = makeArguments().length; + +function makeFunction(name, argc) { + var args = []; + for (var i = 0; i < argc; i++) + args.push("x" + i); + var argsStr = args.join(", "); + return new Function(args.join(", "), "return %" + name + "(" + argsStr + ");"); +} + +function testArgumentCount(name, argc) { + for (var i = 0; i < 10; i++) { + var func = null; + try { + func = makeFunction(name, i); + } catch (e) { + if (e != "SyntaxError: Illegal access") throw e; + } + if (func === null && i == argc) { + throw "unexpected exception"; + } + var args = [ ]; + for (var j = 0; j < i; j++) + args.push(0); + try { + func.apply(void 0, args); + } catch (e) { + // we don't care what happens as long as we don't crash + } + } +} + +function testArgumentTypes(name, argc) { + var type = 0; + var hasMore = true; + var func = makeFunction(name, argc); + while (hasMore) { + var argPool = makeArguments(); + // When we have 5 or more arguments we lower the amount of tests cases + // by randomly removing kOnManyArgumentsRemove entries + var numArguments = RUN_WITH_ALL_ARGUMENT_ENTRIES ? + kArgObjects : kArgObjects-kOnManyArgumentsRemove; + if (argc >= 5 && !RUN_WITH_ALL_ARGUMENT_ENTRIES) { + for (var i = 0; i < kOnManyArgumentsRemove; i++) { + var rand = Math.floor(Math.random() * (kArgObjects - i)); + argPool.splice(rand,1); + } + } + var current = type; + var hasMore = false; + var argList = [ ]; + for (var i = 0; i < argc; i++) { + var index = current % numArguments; + current = (current / numArguments) << 0; + if (index != (numArguments - 1)) + hasMore = true; + argList.push(argPool[index]); + } + try { + func.apply(void 0, argList); + } catch (e) { + // we don't care what happens as long as we don't crash + } + type++; + } +} + +var knownProblems = { + "Abort": true, + + // Avoid calling the concat operation, because weird lengths + // may lead to out-of-memory. Ditto for StringBuilderJoin. + "StringBuilderConcat": true, + "StringBuilderJoin": true, + + // These functions use pseudo-stack-pointers and are not robust + // to unexpected integer values. + "DebugEvaluate": true, + + // These functions do nontrivial error checking in recursive calls, + // which means that we have to propagate errors back. + "SetFunctionBreakPoint": true, + "SetScriptBreakPoint": true, + "PrepareStep": true, + + // Too slow. + "DebugReferencedBy": true, + + // Calling disable/enable access checks may interfere with the + // the rest of the tests. + "DisableAccessChecks": true, + "EnableAccessChecks": true, + + // These functions should not be callable as runtime functions. + "NewFunctionContext": true, + "NewArgumentsFast": true, + "NewStrictArgumentsFast": true, + "PushWithContext": true, + "PushCatchContext": true, + "PushBlockContext": true, + "LazyCompile": true, + "LazyRecompile": true, + "ParallelRecompile": true, + "NotifyDeoptimized": true, + "NotifyOSR": true, + "CreateObjectLiteralBoilerplate": true, + "CloneLiteralBoilerplate": true, + "CloneShallowLiteralBoilerplate": true, + "CreateArrayLiteralBoilerplate": true, + "IS_VAR": true, + "ResolvePossiblyDirectEval": true, + "Log": true, + "DeclareGlobals": true, + + "PromoteScheduledException": true, + "DeleteHandleScopeExtensions": true, + + // Vararg with minimum number > 0. + "Call": true, + + // Requires integer arguments to be non-negative. + "Apply": true, + + // That can only be invoked on Array.prototype. + "FinishArrayPrototypeSetup": true, + + "_SwapElements": true, + + // Performance critical functions which cannot afford type checks. + "_IsNativeOrStrictMode": true, + "_CallFunction": true, + + // Tries to allocate based on argument, and (correctly) throws + // out-of-memory if the request is too large. In practice, the + // size will be the number of captures of a RegExp. + "RegExpConstructResult": true, + "_RegExpConstructResult": true, + + // This functions perform some checks compile time (they require one of their + // arguments to be a compile time smi). + "_DateField": true, + "_GetFromCache": true, + + // This function expects its first argument to be a non-smi. + "_IsStringWrapperSafeForDefaultValueOf" : true, + + // Only applicable to strings. + "_HasCachedArrayIndex": true, + "_GetCachedArrayIndex": true +}; + +var currentlyUncallable = { + // We need to find a way to test this without breaking the system. + "SystemBreak": true +}; + +function testNatives() { + var allNatives = %ListNatives(); + var start = (allNatives.length >> 2)*3; + var stop = allNatives.length; + for (var i = start; i < stop; i++) { + var nativeInfo = allNatives[i]; + var name = nativeInfo[0]; + if (name in knownProblems || name in currentlyUncallable) + continue; + print(name); + var argc = nativeInfo[1]; + testArgumentCount(name, argc); + testArgumentTypes(name, argc); + } +} + +testNatives(); diff --git a/src/3rdparty/v8/test/mjsunit/greedy.js b/src/3rdparty/v8/test/mjsunit/greedy.js index d357f0c..8c49e41 100644 --- a/src/3rdparty/v8/test/mjsunit/greedy.js +++ b/src/3rdparty/v8/test/mjsunit/greedy.js @@ -25,7 +25,7 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Flags: --gc-greedy +// Flags: --gc-greedy --noverify-heap function IterativeFib(n) { var f0 = 0, f1 = 1; diff --git a/src/3rdparty/v8/test/mjsunit/harmony/block-conflicts.js b/src/3rdparty/v8/test/mjsunit/harmony/block-conflicts.js index 8388504..3aa9d22 100644 --- a/src/3rdparty/v8/test/mjsunit/harmony/block-conflicts.js +++ b/src/3rdparty/v8/test/mjsunit/harmony/block-conflicts.js @@ -35,7 +35,8 @@ function CheckException(e) { var string = e.toString(); assertTrue(string.indexOf("has already been declared") >= 0 || - string.indexOf("redeclaration") >= 0); return 'Conflict'; + string.indexOf("redeclaration") >= 0); + return 'Conflict'; } diff --git a/src/3rdparty/v8/test/mjsunit/harmony/block-let-crankshaft.js b/src/3rdparty/v8/test/mjsunit/harmony/block-let-crankshaft.js index 1db1792..d01e5c0 100644 --- a/src/3rdparty/v8/test/mjsunit/harmony/block-let-crankshaft.js +++ b/src/3rdparty/v8/test/mjsunit/harmony/block-let-crankshaft.js @@ -25,7 +25,7 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Flags: --harmony-scoping --allow-natives-syntax +// Flags: --harmony-scoping --allow-natives-syntax --noparallel-recompilation // TODO(ES6): properly activate extended mode "use strict"; diff --git a/src/3rdparty/v8/test/mjsunit/harmony/collections.js b/src/3rdparty/v8/test/mjsunit/harmony/collections.js index 412e6f1..0219f39 100644 --- a/src/3rdparty/v8/test/mjsunit/harmony/collections.js +++ b/src/3rdparty/v8/test/mjsunit/harmony/collections.js @@ -1,4 +1,4 @@ -// Copyright 2011 the V8 project authors. All rights reserved. +// Copyright 2012 the V8 project authors. All rights reserved. // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: @@ -65,9 +65,11 @@ TestInvalidCalls(new WeakMap); // Test expected behavior for Sets function TestSet(set, key) { assertFalse(set.has(key)); - set.add(key); + assertSame(undefined, set.add(key)); assertTrue(set.has(key)); - set.delete(key); + assertTrue(set.delete(key)); + assertFalse(set.has(key)); + assertFalse(set.delete(key)); assertFalse(set.has(key)); } function TestSetBehavior(set) { @@ -87,7 +89,7 @@ TestSetBehavior(new Set); // Test expected mapping behavior for Maps and WeakMaps function TestMapping(map, key, value) { - map.set(key, value); + assertSame(undefined, map.set(key, value)); assertSame(value, map.get(key)); } function TestMapBehavior1(m) { @@ -117,12 +119,12 @@ TestMapBehavior2(new Map); // Test expected querying behavior of Maps and WeakMaps function TestQuery(m) { var key = new Object; - TestMapping(m, key, 'to-be-present'); - assertTrue(m.has(key)); - assertFalse(m.has(new Object)); - TestMapping(m, key, undefined); - assertFalse(m.has(key)); - assertFalse(m.has(new Object)); + var values = [ 'x', 0, +Infinity, -Infinity, true, false, null, undefined ]; + for (var i = 0; i < values.length; i++) { + TestMapping(m, key, values[i]); + assertTrue(m.has(key)); + assertFalse(m.has(new Object)); + } } TestQuery(new Map); TestQuery(new WeakMap); @@ -311,4 +313,60 @@ TestBogusReceivers(bogusReceiversTestSet); // Stress Test // There is a proposed stress-test available at the es-discuss mailing list // which cannot be reasonably automated. Check it out by hand if you like: -// https://mail.mozilla.org/pipermail/es-discuss/2011-May/014096.html
\ No newline at end of file +// https://mail.mozilla.org/pipermail/es-discuss/2011-May/014096.html + + +// Set and Map size getters +var setSizeDescriptor = Object.getOwnPropertyDescriptor(Set.prototype, 'size'); +assertEquals(undefined, setSizeDescriptor.value); +assertEquals(undefined, setSizeDescriptor.set); +assertTrue(setSizeDescriptor.get instanceof Function); +assertEquals(undefined, setSizeDescriptor.get.prototype); +assertFalse(setSizeDescriptor.enumerable); +assertTrue(setSizeDescriptor.configurable); + +var s = new Set(); +assertFalse(s.hasOwnProperty('size')); +for (var i = 0; i < 10; i++) { + assertEquals(i, s.size); + s.add(i); +} +for (var i = 9; i >= 0; i--) { + s.delete(i); + assertEquals(i, s.size); +} + + +var mapSizeDescriptor = Object.getOwnPropertyDescriptor(Map.prototype, 'size'); +assertEquals(undefined, mapSizeDescriptor.value); +assertEquals(undefined, mapSizeDescriptor.set); +assertTrue(mapSizeDescriptor.get instanceof Function); +assertEquals(undefined, mapSizeDescriptor.get.prototype); +assertFalse(mapSizeDescriptor.enumerable); +assertTrue(mapSizeDescriptor.configurable); + +var m = new Map(); +assertFalse(m.hasOwnProperty('size')); +for (var i = 0; i < 10; i++) { + assertEquals(i, m.size); + m.set(i, i); +} +for (var i = 9; i >= 0; i--) { + m.delete(i); + assertEquals(i, m.size); +} + +// Test clear +var a = new Set(); +s.add(42); +assertTrue(s.has(42)); +s.clear(); +assertFalse(s.has(42)); +assertEquals(0, s.size); + +var m = new Map(); +m.set(42, true); +assertTrue(m.has(42)); +m.clear(); +assertFalse(m.has(42)); +assertEquals(0, m.size); diff --git a/src/3rdparty/v8/test/mjsunit/harmony/debug-blockscopes.js b/src/3rdparty/v8/test/mjsunit/harmony/debug-blockscopes.js index 10aac2d..ca2ab9e 100644 --- a/src/3rdparty/v8/test/mjsunit/harmony/debug-blockscopes.js +++ b/src/3rdparty/v8/test/mjsunit/harmony/debug-blockscopes.js @@ -376,7 +376,7 @@ listener_delegate = function(exec_state) { debug.ScopeType.Global], exec_state); CheckScopeContent({x:'y'}, 0, exec_state); // The function scope contains a temporary iteration variable. - CheckScopeContent({x:'y'}, 1, exec_state); + CheckScopeContent({'.for.x':'y'}, 1, exec_state); }; for_loop_1(); EndTest(); @@ -401,7 +401,7 @@ listener_delegate = function(exec_state) { CheckScopeContent({x:3}, 0, exec_state); CheckScopeContent({x:'y'}, 1, exec_state); // The function scope contains a temporary iteration variable. - CheckScopeContent({x:'y'}, 2, exec_state); + CheckScopeContent({'.for.x':'y'}, 2, exec_state); }; for_loop_2(); EndTest(); diff --git a/src/3rdparty/v8/test/mjsunit/harmony/module-linking.js b/src/3rdparty/v8/test/mjsunit/harmony/module-linking.js index 13ca6f7..a4b272f 100644 --- a/src/3rdparty/v8/test/mjsunit/harmony/module-linking.js +++ b/src/3rdparty/v8/test/mjsunit/harmony/module-linking.js @@ -27,10 +27,188 @@ // Flags: --harmony-modules --harmony-scoping -// Test basic module linking. +// Test basic module linking and initialization. "use strict"; +module R { + // At this point, only functions and modules are initialized. + assertEquals(undefined, v) + assertEquals(undefined, vv) + assertEquals(undefined, R.v) + assertEquals(undefined, M.v) + assertEquals(undefined, MM.v) + assertEquals(undefined, F.v) + assertEquals(undefined, G.v) + assertThrows(function() { l }, ReferenceError) + assertThrows(function() { ll }, ReferenceError) + assertThrows(function() { R.l }, ReferenceError) + assertThrows(function() { M.l }, ReferenceError) + assertThrows(function() { MM.l }, ReferenceError) + assertThrows(function() { F.l }, ReferenceError) + assertThrows(function() { G.l }, ReferenceError) + assertThrows(function() { c }, ReferenceError) + assertThrows(function() { cc }, ReferenceError) + assertThrows(function() { R.c }, ReferenceError) + assertThrows(function() { M.c }, ReferenceError) + assertThrows(function() { MM.c }, ReferenceError) + assertThrows(function() { F.c }, ReferenceError) + assertThrows(function() { G.c }, ReferenceError) + assertEquals(4, f()) + assertEquals(24, ff()) + assertEquals(4, R.f()) + assertEquals(14, M.f()) + assertEquals(34, MM.f()) + assertEquals(44, F.f()) + assertEquals(14, G.f()) + + // All properties should already exist on the instance objects, though. + assertTrue("v" in R) + assertTrue("v" in RR) + assertTrue("v" in M) + assertTrue("v" in MM) + assertTrue("v" in F) + assertTrue("v" in G) + assertTrue("l" in R) + assertTrue("l" in RR) + assertTrue("l" in M) + assertTrue("l" in MM) + assertTrue("l" in F) + assertTrue("l" in G) + assertTrue("c" in R) + assertTrue("c" in RR) + assertTrue("c" in M) + assertTrue("c" in MM) + assertTrue("c" in F) + assertTrue("c" in G) + assertTrue("f" in R) + assertTrue("f" in RR) + assertTrue("f" in M) + assertTrue("f" in MM) + assertTrue("f" in F) + assertTrue("f" in G) + assertTrue("M" in R) + assertTrue("M" in RR) + assertTrue("RR" in R) + assertTrue("RR" in RR) + + // And aliases should be identical. + assertSame(R, RR) + assertSame(R, R.RR) + assertSame(M, R.M) + assertSame(M, G) + + // We can only assign to var. + assertEquals(-1, v = -1) + assertEquals(-2, R.v = -2) + assertEquals(-2, v) + assertEquals(-2, R.v) + + assertThrows(function() { l = -1 }, ReferenceError) + assertThrows(function() { R.l = -2 }, ReferenceError) + assertThrows(function() { l }, ReferenceError) + assertThrows(function() { R.l }, ReferenceError) + + assertThrows(function() { eval("c = -1") }, SyntaxError) + assertThrows(function() { R.c = -2 }, TypeError) + + // Initialize first bunch or variables. + export var v = 1 + export let l = 2 + export const c = 3 + export function f() { return 4 } + + assertEquals(1, v) + assertEquals(1, R.v) + assertEquals(2, l) + assertEquals(2, R.l) + assertEquals(3, c) + assertEquals(3, R.c) + + assertEquals(-3, v = -3) + assertEquals(-4, R.v = -4) + assertEquals(-3, l = -3) + assertEquals(-4, R.l = -4) + assertThrows(function() { eval("c = -3") }, SyntaxError) + assertThrows(function() { R.c = -4 }, TypeError) + + assertEquals(-4, v) + assertEquals(-4, R.v) + assertEquals(-4, l) + assertEquals(-4, R.l) + assertEquals(3, c) + assertEquals(3, R.c) + + // Initialize nested module. + export module M { + export var v = 11 + export let l = 12 + export const c = 13 + export function f() { return 14 } + } + + assertEquals(11, M.v) + assertEquals(11, G.v) + assertEquals(12, M.l) + assertEquals(12, G.l) + assertEquals(13, M.c) + assertEquals(13, G.c) + + // Initialize non-exported variables. + var vv = 21 + let ll = 22 + const cc = 23 + function ff() { return 24 } + + assertEquals(21, vv) + assertEquals(22, ll) + assertEquals(23, cc) + + // Initialize non-exported module. + module MM { + export var v = 31 + export let l = 32 + export const c = 33 + export function f() { return 34 } + } + + assertEquals(31, MM.v) + assertEquals(32, MM.l) + assertEquals(33, MM.c) + + // Recursive self reference. + export module RR = R +} + +// Initialize sibling module that was forward-used. +module F { + assertEquals(undefined, v) + assertEquals(undefined, F.v) + assertThrows(function() { l }, ReferenceError) + assertThrows(function() { F.l }, ReferenceError) + assertThrows(function() { c }, ReferenceError) + assertThrows(function() { F.c }, ReferenceError) + + export var v = 41 + export let l = 42 + export const c = 43 + export function f() { return 44 } + + assertEquals(41, v) + assertEquals(41, F.v) + assertEquals(42, l) + assertEquals(42, F.l) + assertEquals(43, c) + assertEquals(43, F.c) +} + +// Define recursive module alias. +module G = R.M + + + +// Second test with side effects and more module nesting. + let log = ""; export let x = (log += "1"); @@ -117,5 +295,4 @@ assertSame(M2, M1.A2); assertSame(M1, M1.A2.A1); assertSame(M2, M2.A1.A2); -// TODO(rossberg): inner declarations are not executed yet. -// assertEquals("1234567890", log); +assertEquals("1234567890", log); diff --git a/src/3rdparty/v8/test/mjsunit/harmony/module-parsing.js b/src/3rdparty/v8/test/mjsunit/harmony/module-parsing.js index cdd0a2e..8a9103d 100644 --- a/src/3rdparty/v8/test/mjsunit/harmony/module-parsing.js +++ b/src/3rdparty/v8/test/mjsunit/harmony/module-parsing.js @@ -116,6 +116,11 @@ x , y +var +x +, +y + export var v1 = 1 @@ -157,3 +162,29 @@ try {} catch (module) {} module v = 20 + + + +// Check that module declarations are rejected in eval or local scope. + +module M { export let x; } + +assertThrows("export x;", SyntaxError); // It's using eval, so should throw. +assertThrows("export let x;", SyntaxError); +assertThrows("import x from M;", SyntaxError); +assertThrows("module M {};", SyntaxError); + +assertThrows("{ export x; }", SyntaxError); +assertThrows("{ export let x; }", SyntaxError); +assertThrows("{ import x from M; }", SyntaxError); +assertThrows("{ module M {}; }", SyntaxError); + +assertThrows("function f() { export x; }", SyntaxError); +assertThrows("function f() { export let x; }", SyntaxError); +assertThrows("function f() { import x from M; }", SyntaxError); +assertThrows("function f() { module M {}; }", SyntaxError); + +assertThrows("function f() { { export x; } }", SyntaxError); +assertThrows("function f() { { export let x; } }", SyntaxError); +assertThrows("function f() { { import x from M; } }", SyntaxError); +assertThrows("function f() { { module M {}; } }", SyntaxError); diff --git a/src/3rdparty/v8/test/mjsunit/harmony/module-recompile.js b/src/3rdparty/v8/test/mjsunit/harmony/module-recompile.js new file mode 100644 index 0000000..23f5bfc --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/harmony/module-recompile.js @@ -0,0 +1,87 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --harmony-modules + +// Test that potential recompilation of the global scope does not screw up. + +"use strict"; + +var N = 1e5; // Number of loop iterations that trigger optimization. + +module A { + export var x = 1 + export function f() { return x } +} +var f = A.f + +assertEquals(1, A.x) +assertEquals(1, A.f()) +assertEquals(1, f()) + +A.x = 2 + +assertEquals(2, A.x) +assertEquals(2, A.f()) +assertEquals(2, f()) + +for (var i = 0; i < N; i++) { + if (i > N) print("impossible"); +} + +assertEquals(2, A.x) +assertEquals(2, A.f()) +assertEquals(2, f()) + + +// Same test with loop inside a module. + +module B { + module A { + export var x = 1 + export function f() { return x } + } + var f = A.f + + assertEquals(1, A.x) + assertEquals(1, A.f()) + assertEquals(1, f()) + + A.x = 2 + + assertEquals(2, A.x) + assertEquals(2, A.f()) + assertEquals(2, f()) + + for (var i = 0; i < N; i++) { + if (i > N) print("impossible"); + } + + assertEquals(2, A.x) + assertEquals(2, A.f()) + assertEquals(2, f()) +} diff --git a/src/3rdparty/v8/test/mjsunit/harmony/module-resolution.js b/src/3rdparty/v8/test/mjsunit/harmony/module-resolution.js index a1b9917..1a95347 100644 --- a/src/3rdparty/v8/test/mjsunit/harmony/module-resolution.js +++ b/src/3rdparty/v8/test/mjsunit/harmony/module-resolution.js @@ -33,6 +33,7 @@ print("begin.") + export let x = print("0") export module B = A.B @@ -44,15 +45,25 @@ export module A { module BB = B export BB, x let x = print("2") - let y = print("3") + var y = print("3") let Ax = A.x + try { A.y } catch (e) {} // throws + let Az = A.z // undefined + let Az2 = z // undefined + A.g() // hoisted + g() // hoisted let ABx = A.B.x - let Ay = A.y + let ABy = A.B.y + let Bx = B.x + let By = B.y let BBx = BB.x + let BBy = BB.y let Af = A.f function f(x,y) { return x } } export let y = print("4") + export var z = print("4.1") + export function g() {} let Ax = A.x let Bx = B.x let ABx = A.B.x @@ -92,6 +103,8 @@ export module E { let Bx = B.x // TODO(rossberg): Handle import *. // import A.* + module B = A.B + let y = A.y } export module M1 { diff --git a/src/3rdparty/v8/test/mjsunit/harmony/object-observe.js b/src/3rdparty/v8/test/mjsunit/harmony/object-observe.js new file mode 100644 index 0000000..945841b --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/harmony/object-observe.js @@ -0,0 +1,591 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --harmony-observation + +var allObservers = []; +function reset() { + allObservers.forEach(function(observer) { observer.reset(); }); +} + +function createObserver() { + "use strict"; // So that |this| in callback can be undefined. + + var observer = { + records: undefined, + callbackCount: 0, + reset: function() { + this.records = undefined; + this.callbackCount = 0; + }, + assertNotCalled: function() { + assertEquals(undefined, this.records); + assertEquals(0, this.callbackCount); + }, + assertCalled: function() { + assertEquals(1, this.callbackCount); + }, + assertRecordCount: function(count) { + this.assertCalled(); + assertEquals(count, this.records.length); + }, + assertCallbackRecords: function(recs) { + this.assertRecordCount(recs.length); + for (var i = 0; i < recs.length; i++) { + assertSame(this.records[i].object, recs[i].object); + assertEquals('string', typeof recs[i].type); + assertPropertiesEqual(this.records[i], recs[i]); + } + } + }; + + observer.callback = function(r) { + assertEquals(undefined, this); + assertEquals('object', typeof r); + assertTrue(r instanceof Array) + observer.records = r; + observer.callbackCount++; + }; + + observer.reset(); + allObservers.push(observer); + return observer; +} + +var observer = createObserver(); +assertEquals("function", typeof observer.callback); +var obj = {}; + +function frozenFunction() {} +Object.freeze(frozenFunction); +var nonFunction = {}; +var changeRecordWithAccessor = { type: 'foo' }; +var recordCreated = false; +Object.defineProperty(changeRecordWithAccessor, 'name', { + get: function() { + recordCreated = true; + return "bar"; + }, + enumerable: true +}) + +// Object.observe +assertThrows(function() { Object.observe("non-object", observer.callback); }, TypeError); +assertThrows(function() { Object.observe(obj, nonFunction); }, TypeError); +assertThrows(function() { Object.observe(obj, frozenFunction); }, TypeError); + +// Object.unobserve +assertThrows(function() { Object.unobserve(4, observer.callback); }, TypeError); + +// Object.getNotifier +var notifier = Object.getNotifier(obj); +assertSame(notifier, Object.getNotifier(obj)); +assertEquals(null, Object.getNotifier(Object.freeze({}))); +assertFalse(notifier.hasOwnProperty('notify')); +assertEquals([], Object.keys(notifier)); +var notifyDesc = Object.getOwnPropertyDescriptor(notifier.__proto__, 'notify'); +assertTrue(notifyDesc.configurable); +assertTrue(notifyDesc.writable); +assertFalse(notifyDesc.enumerable); +assertThrows(function() { notifier.notify({}); }, TypeError); +assertThrows(function() { notifier.notify({ type: 4 }); }, TypeError); +var notify = notifier.notify; +assertThrows(function() { notify.call(undefined, { type: 'a' }); }, TypeError); +assertThrows(function() { notify.call(null, { type: 'a' }); }, TypeError); +assertThrows(function() { notify.call(5, { type: 'a' }); }, TypeError); +assertThrows(function() { notify.call('hello', { type: 'a' }); }, TypeError); +assertThrows(function() { notify.call(false, { type: 'a' }); }, TypeError); +assertThrows(function() { notify.call({}, { type: 'a' }); }, TypeError); +assertFalse(recordCreated); +notifier.notify(changeRecordWithAccessor); +assertFalse(recordCreated); // not observed yet + +// Object.deliverChangeRecords +assertThrows(function() { Object.deliverChangeRecords(nonFunction); }, TypeError); + +// Multiple records are delivered. +Object.observe(obj, observer.callback); +notifier.notify({ + type: 'updated', + name: 'foo', + expando: 1 +}); + +notifier.notify({ + object: notifier, // object property is ignored + type: 'deleted', + name: 'bar', + expando2: 'str' +}); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: obj, name: 'foo', type: 'updated', expando: 1 }, + { object: obj, name: 'bar', type: 'deleted', expando2: 'str' } +]); + +// No delivery takes place if no records are pending +reset(); +Object.deliverChangeRecords(observer.callback); +observer.assertNotCalled(); + +// Multiple observation has no effect. +reset(); +Object.observe(obj, observer.callback); +Object.observe(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', +}); +Object.deliverChangeRecords(observer.callback); +observer.assertCalled(); + +// Observation can be stopped. +reset(); +Object.unobserve(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', +}); +Object.deliverChangeRecords(observer.callback); +observer.assertNotCalled(); + +// Multiple unobservation has no effect +reset(); +Object.unobserve(obj, observer.callback); +Object.unobserve(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', +}); +Object.deliverChangeRecords(observer.callback); +observer.assertNotCalled(); + +// Re-observation works and only includes changeRecords after of call. +reset(); +Object.getNotifier(obj).notify({ + type: 'foo', +}); +Object.observe(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', +}); +records = undefined; +Object.deliverChangeRecords(observer.callback); +observer.assertRecordCount(1); + +// Observing a continuous stream of changes, while itermittantly unobserving. +reset(); +Object.observe(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', + val: 1 +}); + +Object.unobserve(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', + val: 2 +}); + +Object.observe(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', + val: 3 +}); + +Object.unobserve(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', + val: 4 +}); + +Object.observe(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', + val: 5 +}); + +Object.unobserve(obj, observer.callback); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: obj, type: 'foo', val: 1 }, + { object: obj, type: 'foo', val: 3 }, + { object: obj, type: 'foo', val: 5 } +]); + +// Observing multiple objects; records appear in order. +reset(); +var obj2 = {}; +var obj3 = {} +Object.observe(obj, observer.callback); +Object.observe(obj3, observer.callback); +Object.observe(obj2, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo1', +}); +Object.getNotifier(obj2).notify({ + type: 'foo2', +}); +Object.getNotifier(obj3).notify({ + type: 'foo3', +}); +Object.observe(obj3, observer.callback); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: obj, type: 'foo1' }, + { object: obj2, type: 'foo2' }, + { object: obj3, type: 'foo3' } +]); + +// Observing named properties. +reset(); +var obj = {a: 1} +Object.observe(obj, observer.callback); +obj.a = 2; +obj["a"] = 3; +delete obj.a; +obj.a = 4; +obj.a = 4; // ignored +obj.a = 5; +Object.defineProperty(obj, "a", {value: 6}); +Object.defineProperty(obj, "a", {writable: false}); +obj.a = 7; // ignored +Object.defineProperty(obj, "a", {value: 8}); +Object.defineProperty(obj, "a", {value: 7, writable: true}); +Object.defineProperty(obj, "a", {get: function() {}}); +Object.defineProperty(obj, "a", {get: function() {}}); +delete obj.a; +delete obj.a; +Object.defineProperty(obj, "a", {get: function() {}, configurable: true}); +Object.defineProperty(obj, "a", {value: 9, writable: true}); +obj.a = 10; +delete obj.a; +Object.defineProperty(obj, "a", {value: 11, configurable: true}); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: obj, name: "a", type: "updated", oldValue: 1 }, + { object: obj, name: "a", type: "updated", oldValue: 2 }, + { object: obj, name: "a", type: "deleted", oldValue: 3 }, + { object: obj, name: "a", type: "new" }, + { object: obj, name: "a", type: "updated", oldValue: 4 }, + { object: obj, name: "a", type: "updated", oldValue: 5 }, + { object: obj, name: "a", type: "reconfigured", oldValue: 6 }, + { object: obj, name: "a", type: "updated", oldValue: 6 }, + { object: obj, name: "a", type: "reconfigured", oldValue: 8 }, + { object: obj, name: "a", type: "reconfigured", oldValue: 7 }, + { object: obj, name: "a", type: "reconfigured" }, + { object: obj, name: "a", type: "deleted" }, + { object: obj, name: "a", type: "new" }, + { object: obj, name: "a", type: "reconfigured" }, + { object: obj, name: "a", type: "updated", oldValue: 9 }, + { object: obj, name: "a", type: "deleted", oldValue: 10 }, + { object: obj, name: "a", type: "new" }, +]); + +// Observing indexed properties. +reset(); +var obj = {'1': 1} +Object.observe(obj, observer.callback); +obj[1] = 2; +obj[1] = 3; +delete obj[1]; +obj[1] = 4; +obj[1] = 4; // ignored +obj[1] = 5; +Object.defineProperty(obj, "1", {value: 6}); +Object.defineProperty(obj, "1", {writable: false}); +obj[1] = 7; // ignored +Object.defineProperty(obj, "1", {value: 8}); +Object.defineProperty(obj, "1", {value: 7, writable: true}); +Object.defineProperty(obj, "1", {get: function() {}}); +delete obj[1]; +delete obj[1]; +Object.defineProperty(obj, "1", {get: function() {}, configurable: true}); +Object.defineProperty(obj, "1", {value: 9, writable: true}); +obj[1] = 10; +delete obj[1]; +Object.defineProperty(obj, "1", {value: 11, configurable: true}); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: obj, name: "1", type: "updated", oldValue: 1 }, + { object: obj, name: "1", type: "updated", oldValue: 2 }, + { object: obj, name: "1", type: "deleted", oldValue: 3 }, + { object: obj, name: "1", type: "new" }, + { object: obj, name: "1", type: "updated", oldValue: 4 }, + { object: obj, name: "1", type: "updated", oldValue: 5 }, + { object: obj, name: "1", type: "reconfigured", oldValue: 6 }, + { object: obj, name: "1", type: "updated", oldValue: 6 }, + { object: obj, name: "1", type: "reconfigured", oldValue: 8 }, + { object: obj, name: "1", type: "reconfigured", oldValue: 7 }, + // TODO(observe): oldValue should not be present below. + { object: obj, name: "1", type: "deleted", oldValue: undefined }, + { object: obj, name: "1", type: "new" }, + // TODO(observe): oldValue should be absent below, and type = "reconfigured". + { object: obj, name: "1", type: "updated", oldValue: undefined }, + { object: obj, name: "1", type: "updated", oldValue: 9 }, + { object: obj, name: "1", type: "deleted", oldValue: 10 }, + { object: obj, name: "1", type: "new" }, +]); + +// Observing array length (including truncation) +reset(); +var arr = ['a', 'b', 'c', 'd']; +var arr2 = ['alpha', 'beta']; +var arr3 = ['hello']; +arr3[2] = 'goodbye'; +arr3.length = 6; +// TODO(adamk): Enable this test case when it can run in a reasonable +// amount of time. +//var slow_arr = new Array(1000000000); +//slow_arr[500000000] = 'hello'; +Object.defineProperty(arr, '0', {configurable: false}); +Object.defineProperty(arr, '2', {get: function(){}}); +Object.defineProperty(arr2, '0', {get: function(){}, configurable: false}); +Object.observe(arr, observer.callback); +Object.observe(arr2, observer.callback); +Object.observe(arr3, observer.callback); +arr.length = 2; +arr.length = 0; +arr.length = 10; +arr2.length = 0; +arr2.length = 1; // no change expected +arr3.length = 0; +Object.defineProperty(arr3, 'length', {value: 5}); +Object.defineProperty(arr3, 'length', {value: 10, writable: false}); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: arr, name: '3', type: 'deleted', oldValue: 'd' }, + // TODO(adamk): oldValue should not be present below + { object: arr, name: '2', type: 'deleted', oldValue: undefined }, + { object: arr, name: 'length', type: 'updated', oldValue: 4 }, + { object: arr, name: '1', type: 'deleted', oldValue: 'b' }, + { object: arr, name: 'length', type: 'updated', oldValue: 2 }, + { object: arr, name: 'length', type: 'updated', oldValue: 1 }, + { object: arr2, name: '1', type: 'deleted', oldValue: 'beta' }, + { object: arr2, name: 'length', type: 'updated', oldValue: 2 }, + { object: arr3, name: '2', type: 'deleted', oldValue: 'goodbye' }, + { object: arr3, name: '0', type: 'deleted', oldValue: 'hello' }, + { object: arr3, name: 'length', type: 'updated', oldValue: 6 }, + { object: arr3, name: 'length', type: 'updated', oldValue: 0 }, + { object: arr3, name: 'length', type: 'updated', oldValue: 5 }, + // TODO(adamk): This record should be merged with the above + { object: arr3, name: 'length', type: 'reconfigured' }, +]); + +// Assignments in loops (checking different IC states). +reset(); +var obj = {}; +Object.observe(obj, observer.callback); +for (var i = 0; i < 5; i++) { + obj["a" + i] = i; +} +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: obj, name: "a0", type: "new" }, + { object: obj, name: "a1", type: "new" }, + { object: obj, name: "a2", type: "new" }, + { object: obj, name: "a3", type: "new" }, + { object: obj, name: "a4", type: "new" }, +]); + +reset(); +var obj = {}; +Object.observe(obj, observer.callback); +for (var i = 0; i < 5; i++) { + obj[i] = i; +} +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: obj, name: "0", type: "new" }, + { object: obj, name: "1", type: "new" }, + { object: obj, name: "2", type: "new" }, + { object: obj, name: "3", type: "new" }, + { object: obj, name: "4", type: "new" }, +]); + +// Adding elements past the end of an array should notify on length +reset(); +var arr = [1, 2, 3]; +Object.observe(arr, observer.callback); +arr[3] = 10; +arr[100] = 20; +Object.defineProperty(arr, '200', {value: 7}); +Object.defineProperty(arr, '400', {get: function(){}}); +arr[50] = 30; // no length change expected +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: arr, name: '3', type: 'new' }, + { object: arr, name: 'length', type: 'updated', oldValue: 3 }, + { object: arr, name: '100', type: 'new' }, + { object: arr, name: 'length', type: 'updated', oldValue: 4 }, + { object: arr, name: '200', type: 'new' }, + { object: arr, name: 'length', type: 'updated', oldValue: 101 }, + { object: arr, name: '400', type: 'new' }, + { object: arr, name: 'length', type: 'updated', oldValue: 201 }, + { object: arr, name: '50', type: 'new' }, +]); + +// Tests for array methods, first on arrays and then on plain objects +// +// === ARRAYS === +// +// Push +reset(); +var array = [1, 2]; +Object.observe(array, observer.callback); +array.push(3, 4); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '2', type: 'new' }, + { object: array, name: 'length', type: 'updated', oldValue: 2 }, + { object: array, name: '3', type: 'new' }, + { object: array, name: 'length', type: 'updated', oldValue: 3 }, +]); + +// Pop +reset(); +var array = [1, 2]; +Object.observe(array, observer.callback); +array.pop(); +array.pop(); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '1', type: 'deleted', oldValue: 2 }, + { object: array, name: 'length', type: 'updated', oldValue: 2 }, + { object: array, name: '0', type: 'deleted', oldValue: 1 }, + { object: array, name: 'length', type: 'updated', oldValue: 1 }, +]); + +// Shift +reset(); +var array = [1, 2]; +Object.observe(array, observer.callback); +array.shift(); +array.shift(); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '0', type: 'updated', oldValue: 1 }, + { object: array, name: '1', type: 'deleted', oldValue: 2 }, + { object: array, name: 'length', type: 'updated', oldValue: 2 }, + { object: array, name: '0', type: 'deleted', oldValue: 2 }, + { object: array, name: 'length', type: 'updated', oldValue: 1 }, +]); + +// Unshift +reset(); +var array = [1, 2]; +Object.observe(array, observer.callback); +array.unshift(3, 4); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '3', type: 'new' }, + { object: array, name: 'length', type: 'updated', oldValue: 2 }, + { object: array, name: '2', type: 'new' }, + { object: array, name: '0', type: 'updated', oldValue: 1 }, + { object: array, name: '1', type: 'updated', oldValue: 2 }, +]); + +// Splice +reset(); +var array = [1, 2, 3]; +Object.observe(array, observer.callback); +array.splice(1, 1, 4, 5); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '3', type: 'new' }, + { object: array, name: 'length', type: 'updated', oldValue: 3 }, + { object: array, name: '1', type: 'updated', oldValue: 2 }, + { object: array, name: '2', type: 'updated', oldValue: 3 }, +]); + +// +// === PLAIN OBJECTS === +// +// Push +reset() +var array = {0: 1, 1: 2, length: 2} +Object.observe(array, observer.callback); +Array.prototype.push.call(array, 3, 4); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '2', type: 'new' }, + { object: array, name: '3', type: 'new' }, + { object: array, name: 'length', type: 'updated', oldValue: 2 }, +]); + +// Pop +reset() +var array = {0: 1, 1: 2, length: 2}; +Object.observe(array, observer.callback); +Array.prototype.pop.call(array); +Array.prototype.pop.call(array); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '1', type: 'deleted', oldValue: 2 }, + { object: array, name: 'length', type: 'updated', oldValue: 2 }, + { object: array, name: '0', type: 'deleted', oldValue: 1 }, + { object: array, name: 'length', type: 'updated', oldValue: 1 }, +]); + +// Shift +reset() +var array = {0: 1, 1: 2, length: 2}; +Object.observe(array, observer.callback); +Array.prototype.shift.call(array); +Array.prototype.shift.call(array); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '0', type: 'updated', oldValue: 1 }, + { object: array, name: '1', type: 'deleted', oldValue: 2 }, + { object: array, name: 'length', type: 'updated', oldValue: 2 }, + { object: array, name: '0', type: 'deleted', oldValue: 2 }, + { object: array, name: 'length', type: 'updated', oldValue: 1 }, +]); + +// Unshift +reset() +var array = {0: 1, 1: 2, length: 2}; +Object.observe(array, observer.callback); +Array.prototype.unshift.call(array, 3, 4); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '3', type: 'new' }, + { object: array, name: '2', type: 'new' }, + { object: array, name: '0', type: 'updated', oldValue: 1 }, + { object: array, name: '1', type: 'updated', oldValue: 2 }, + { object: array, name: 'length', type: 'updated', oldValue: 2 }, +]); + +// Splice +reset() +var array = {0: 1, 1: 2, 2: 3, length: 3}; +Object.observe(array, observer.callback); +Array.prototype.splice.call(array, 1, 1, 4, 5); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '3', type: 'new' }, + { object: array, name: '1', type: 'updated', oldValue: 2 }, + { object: array, name: '2', type: 'updated', oldValue: 3 }, + { object: array, name: 'length', type: 'updated', oldValue: 3 }, +]); diff --git a/src/3rdparty/v8/test/mjsunit/harmony/proxies-json.js b/src/3rdparty/v8/test/mjsunit/harmony/proxies-json.js new file mode 100644 index 0000000..539c5a8 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/harmony/proxies-json.js @@ -0,0 +1,178 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --harmony + +function testStringify(expected, object) { + // Test fast case that bails out to slow case. + assertEquals(expected, JSON.stringify(object)); + // Test slow case. + assertEquals(expected, JSON.stringify(object, undefined, 0)); +} + +// Test serializing a proxy, function proxy and objects that contain them. +var handler1 = { + get: function(target, name) { + return name.toUpperCase(); + }, + enumerate: function(target) { + return ['a', 'b', 'c']; + }, + getOwnPropertyDescriptor: function(target, name) { + return { enumerable: true }; + } +} + +var proxy1 = Proxy.create(handler1); +testStringify('{"a":"A","b":"B","c":"C"}', proxy1); + +var proxy_fun = Proxy.createFunction(handler1, function() { return 1; }); +testStringify(undefined, proxy_fun); +testStringify('[1,null]', [1, proxy_fun]); + +var parent1a = { b: proxy1 }; +testStringify('{"b":{"a":"A","b":"B","c":"C"}}', parent1a); + +var parent1b = { a: 123, b: proxy1, c: true }; +testStringify('{"a":123,"b":{"a":"A","b":"B","c":"C"},"c":true}', parent1b); + +var parent1c = [123, proxy1, true]; +testStringify('[123,{"a":"A","b":"B","c":"C"},true]', parent1c); + +// Proxy with side effect. +var handler2 = { + get: function(target, name) { + delete parent2.c; + return name.toUpperCase(); + }, + enumerate: function(target) { + return ['a', 'b', 'c']; + }, + getOwnPropertyDescriptor: function(target, name) { + return { enumerable: true }; + } +} + +var proxy2 = Proxy.create(handler2); +var parent2 = { a: "delete", b: proxy2, c: "remove" }; +var expected2 = '{"a":"delete","b":{"a":"A","b":"B","c":"C"}}'; +assertEquals(expected2, JSON.stringify(parent2)); +parent2.c = "remove"; // Revert side effect. +assertEquals(expected2, JSON.stringify(parent2, undefined, 0)); + +// Proxy with a get function that uses the first argument. +var handler3 = { + get: function(target, name) { + if (name == 'valueOf') return function() { return "proxy" }; + return name + "(" + target + ")"; + }, + enumerate: function(target) { + return ['a', 'b', 'c']; + }, + getOwnPropertyDescriptor: function(target, name) { + return { enumerable: true }; + } +} + +var proxy3 = Proxy.create(handler3); +var parent3 = { x: 123, y: proxy3 } +testStringify('{"x":123,"y":{"a":"a(proxy)","b":"b(proxy)","c":"c(proxy)"}}', + parent3); + +// Empty proxy. +var handler4 = { + get: function(target, name) { + return 0; + }, + enumerate: function(target) { + return []; + }, + getOwnPropertyDescriptor: function(target, name) { + return { enumerable: false }; + } +} + +var proxy4 = Proxy.create(handler4); +testStringify('{}', proxy4); +testStringify('{"a":{}}', { a: proxy4 }); + +// Proxy that provides a toJSON function that uses this. +var handler5 = { + get: function(target, name) { + if (name == 'z') return 97000; + return function(key) { return key.charCodeAt(0) + this.z; }; + }, + enumerate: function(target) { + return ['toJSON', 'z']; + }, + getOwnPropertyDescriptor: function(target, name) { + return { enumerable: true }; + } +} + +var proxy5 = Proxy.create(handler5); +testStringify('{"a":97097}', { a: proxy5 }); + +// Proxy that provides a toJSON function that returns undefined. +var handler6 = { + get: function(target, name) { + return function(key) { return undefined; }; + }, + enumerate: function(target) { + return ['toJSON']; + }, + getOwnPropertyDescriptor: function(target, name) { + return { enumerable: true }; + } +} + +var proxy6 = Proxy.create(handler6); +testStringify('[1,null,true]', [1, proxy6, true]); +testStringify('{"a":1,"c":true}', {a: 1, b: proxy6, c: true}); + +// Object containing a proxy that changes the parent's properties. +var handler7 = { + get: function(target, name) { + delete parent7.a; + delete parent7.c; + parent7.e = "5"; + return name.toUpperCase(); + }, + enumerate: function(target) { + return ['a', 'b', 'c']; + }, + getOwnPropertyDescriptor: function(target, name) { + return { enumerable: true }; + } +} + +var proxy7 = Proxy.create(handler7); +var parent7 = { a: "1", b: proxy7, c: "3", d: "4" }; +assertEquals('{"a":"1","b":{"a":"A","b":"B","c":"C"},"d":"4"}', + JSON.stringify(parent7)); +assertEquals('{"b":{"a":"A","b":"B","c":"C"},"d":"4","e":"5"}', + JSON.stringify(parent7)); diff --git a/src/3rdparty/v8/test/mjsunit/harmony/proxies.js b/src/3rdparty/v8/test/mjsunit/harmony/proxies.js index 8d8f839..04fc769 100644 --- a/src/3rdparty/v8/test/mjsunit/harmony/proxies.js +++ b/src/3rdparty/v8/test/mjsunit/harmony/proxies.js @@ -572,15 +572,16 @@ TestSetThrow(Proxy.create({ })) +var rec var key var val -function TestSetForDerived(handler) { - TestWithProxies(TestSetForDerived2, handler) +function TestSetForDerived(trap) { + TestWithProxies(TestSetForDerived2, trap) } -function TestSetForDerived2(create, handler) { - var p = create(handler) +function TestSetForDerived2(create, trap) { + var p = create({getPropertyDescriptor: trap, getOwnPropertyDescriptor: trap}) var o = Object.create(p, {x: {value: 88, writable: true}, '1': {value: 89, writable: true}}) @@ -607,10 +608,16 @@ function TestSetForDerived2(create, handler) { assertEquals(45, o.p_nonwritable = 45) assertEquals("p_nonwritable", key) - assertEquals(45, o.p_nonwritable) + assertFalse(Object.prototype.hasOwnProperty.call(o, "p_nonwritable")) + + assertThrows(function(){ "use strict"; o.p_nonwritable = 45 }, TypeError) + assertEquals("p_nonwritable", key) + assertFalse(Object.prototype.hasOwnProperty.call(o, "p_nonwritable")) + val = "" assertEquals(46, o.p_setter = 46) assertEquals("p_setter", key) + assertSame(o, rec) assertEquals(46, val) // written to parent assertFalse(Object.prototype.hasOwnProperty.call(o, "p_setter")) @@ -624,32 +631,48 @@ function TestSetForDerived2(create, handler) { assertThrows(function(){ "use strict"; o.p_nosetter = 50 }, TypeError) assertEquals("p_nosetter", key) assertEquals("", val) // not written at all + assertFalse(Object.prototype.hasOwnProperty.call(o, "p_nosetter")); assertThrows(function(){ o.p_nonconf = 53 }, TypeError) assertEquals("p_nonconf", key) + assertFalse(Object.prototype.hasOwnProperty.call(o, "p_nonconf")); assertThrows(function(){ o.p_throw = 51 }, "myexn") assertEquals("p_throw", key) + assertFalse(Object.prototype.hasOwnProperty.call(o, "p_throw")); assertThrows(function(){ o.p_setterthrow = 52 }, "myexn") assertEquals("p_setterthrow", key) + assertFalse(Object.prototype.hasOwnProperty.call(o, "p_setterthrow")); } -TestSetForDerived({ - getPropertyDescriptor: function(k) { + +TestSetForDerived( + function(k) { + // TODO(yangguo): issue 2398 - throwing an error causes formatting of + // the message string, which can be observable through this handler. + // We ignore keys that occur when formatting the message string. + if (k == "toString" || k == "valueOf") return; + key = k; switch (k) { case "p_writable": return {writable: true, configurable: true} case "p_nonwritable": return {writable: false, configurable: true} - case "p_setter":return {set: function(x) { val = x }, configurable: true} - case "p_nosetter": return {get: function() { return 1 }, configurable: true} - case "p_nonconf":return {} + case "p_setter": return { + set: function(x) { rec = this; val = x }, + configurable: true + } + case "p_nosetter": return { + get: function() { return 1 }, + configurable: true + } + case "p_nonconf": return {} case "p_throw": throw "myexn" case "p_setterthrow": return {set: function(x) { throw "myexn" }} default: return undefined } } -}) +) // Evil proxy-induced side-effects shouldn't crash. @@ -1630,8 +1653,8 @@ TestPropertyNames([], { getOwnPropertyNames: function() { return [] } }) -TestPropertyNames(["a", "zz", " ", "0"], { - getOwnPropertyNames: function() { return ["a", "zz", " ", 0] } +TestPropertyNames(["a", "zz", " ", "0", "toString"], { + getOwnPropertyNames: function() { return ["a", "zz", " ", 0, "toString"] } }) TestPropertyNames(["throw", "function "], { @@ -1678,8 +1701,8 @@ TestKeys([], { keys: function() { return [] } }) -TestKeys(["a", "zz", " ", "0"], { - keys: function() { return ["a", "zz", " ", 0] } +TestKeys(["a", "zz", " ", "0", "toString"], { + keys: function() { return ["a", "zz", " ", 0, "toString"] } }) TestKeys(["throw", "function "], { diff --git a/src/3rdparty/v8/test/mjsunit/json-recursive.js b/src/3rdparty/v8/test/mjsunit/json-recursive.js new file mode 100644 index 0000000..7a8c547 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/json-recursive.js @@ -0,0 +1,61 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +var a = {}; +for (i = 0; i < 10000; i++) { + var current = {}; + current.a = a; + a = current; +} + +function rec(a,b,c,d,e,f,g,h,i,j,k,l,m,n) { + JSON.stringify(a); + rec(a,b,c,d,e,f,g,h,i,j,k,l,m,n); +} + +assertThrows(function() { rec(1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4) }, + RangeError); + + +var depth = 10000; +var deepArray = []; +for (var i = 0; i < depth; i++) deepArray = [deepArray]; +assertThrows(function() { JSON.stringify(deepArray); }, RangeError); + + +var deepObject = {}; +for (var i = 0; i < depth; i++) deepObject = { next: deepObject }; +assertThrows(function() { JSON.stringify(deepObject); }, RangeError); + + +var str = "[1]"; +for (var i = 0; i < 100000; i++) { + str = "[1," + str + "]"; +} + +assertThrows(function() { JSON.parse(str); }, RangeError); diff --git a/src/3rdparty/v8/test/mjsunit/json.js b/src/3rdparty/v8/test/mjsunit/json.js index bead376..6e91725 100644 --- a/src/3rdparty/v8/test/mjsunit/json.js +++ b/src/3rdparty/v8/test/mjsunit/json.js @@ -257,6 +257,42 @@ assertEquals("[1,2,[3,[4],5],6,7]", assertEquals("[2,4,[6,[8],10],12,14]", JSON.stringify([1, 2, [3, [4], 5], 6, 7], DoubleNumbers)); assertEquals('["a","ab","abc"]', JSON.stringify(["a","ab","abc"])); +assertEquals('{"a":1,"c":true}', + JSON.stringify({ a : 1, + b : function() { 1 }, + c : true, + d : function() { 2 } })); +assertEquals('[1,null,true,null]', + JSON.stringify([1, function() { 1 }, true, function() { 2 }])); +assertEquals('"toJSON 123"', + JSON.stringify({ toJSON : function() { return 'toJSON 123'; } })); +assertEquals('{"a":321}', + JSON.stringify({ a : { toJSON : function() { return 321; } } })); +var counter = 0; +assertEquals('{"getter":123}', + JSON.stringify({ get getter() { counter++; return 123; } })); +assertEquals(1, counter); +assertEquals('{"a":"abc","b":"\u1234bc"}', + JSON.stringify({ a : "abc", b : "\u1234bc" })); + + +var a = { a : 1, b : 2 }; +delete a.a; +assertEquals('{"b":2}', JSON.stringify(a)); + +var b = {}; +b.__proto__ = { toJSON : function() { return 321;} }; +assertEquals("321", JSON.stringify(b)); + +var array = [""]; +var expected = '""'; +for (var i = 0; i < 10000; i++) { + array.push(""); + expected = '"",' + expected; +} +expected = '[' + expected + ']'; +assertEquals(expected, JSON.stringify(array)); + var circular = [1, 2, 3]; circular[2] = circular; @@ -428,5 +464,5 @@ var o = JSON.parse('{"__proto__":5}'); assertEquals(Object.prototype, o.__proto__); // __proto__ isn't changed. assertEquals(0, Object.keys(o).length); // __proto__ isn't added as enumerable. - - +var json = '{"stuff before slash\\\\stuff after slash":"whatever"}'; +assertEquals(json, JSON.stringify(JSON.parse(json))); diff --git a/src/3rdparty/v8/test/mjsunit/json2.js b/src/3rdparty/v8/test/mjsunit/json2.js new file mode 100644 index 0000000..4c0b8f5 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/json2.js @@ -0,0 +1,153 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +// Test JSON.stringify on the global object. +var a = 12345; +assertTrue(JSON.stringify(this).indexOf('"a":12345') > 0); + +// Test JSON.stringify of array in dictionary mode. +var array_1 = []; +var array_2 = []; +array_1[100000] = 1; +array_2[100000] = function() { return 1; }; +var nulls = ""; +for (var i = 0; i < 100000; i++) { + nulls += 'null,'; +} +expected_1 = '[' + nulls + '1]'; +expected_2 = '[' + nulls + 'null]'; +assertEquals(expected_1, JSON.stringify(array_1)); +assertEquals(expected_2, JSON.stringify(array_2)); + +// Test JSValue with custom prototype. +var num_wrapper = Object(42); +num_wrapper.__proto__ = { __proto__: null, + toString: function() { return true; } }; +assertEquals('1', JSON.stringify(num_wrapper)); + +var str_wrapper = Object('2'); +str_wrapper.__proto__ = { __proto__: null, + toString: function() { return true; } }; +assertEquals('"true"', JSON.stringify(str_wrapper)); + +var bool_wrapper = Object(false); +bool_wrapper.__proto__ = { __proto__: null, + toString: function() { return true; } }; +// Note that toString function is not evaluated here! +assertEquals('false', JSON.stringify(bool_wrapper)); + +// Test getters. +var counter = 0; +var getter_obj = { get getter() { + counter++; + return 123; + } }; +assertEquals('{"getter":123}', JSON.stringify(getter_obj)); +assertEquals(1, counter); + +// Test toJSON function. +var tojson_obj = { toJSON: function() { + counter++; + return [1, 2]; + }, + a: 1}; +assertEquals('[1,2]', JSON.stringify(tojson_obj)); +assertEquals(2, counter); + +// Test that we don't recursively look for the toJSON function. +var tojson_proto_obj = { a: 'fail' }; +tojson_proto_obj.__proto__ = { toJSON: function() { + counter++; + return tojson_obj; + } }; +assertEquals('{"a":1}', JSON.stringify(tojson_proto_obj)); + +// Test toJSON produced by a getter. +var tojson_via_getter = { get toJSON() { + return function(x) { + counter++; + return 321; + }; + }, + a: 1 }; +assertEquals('321', JSON.stringify(tojson_via_getter)); + +// Test toJSON with key. +tojson_obj = { toJSON: function(key) { return key + key; } }; +var tojson_with_key_1 = { a: tojson_obj, b: tojson_obj }; +assertEquals('{"a":"aa","b":"bb"}', JSON.stringify(tojson_with_key_1)); +var tojson_with_key_2 = [ tojson_obj, tojson_obj ]; +assertEquals('["00","11"]', JSON.stringify(tojson_with_key_2)); + +// Test toJSON with exception. +var tojson_ex = { toJSON: function(key) { throw "123" } }; +assertThrows(function() { JSON.stringify(tojson_ex); }); + +// Test toJSON with access to this. +var obj = { toJSON: function(key) { return this.a + key; }, a: "x" }; +assertEquals('{"y":"xy"}', JSON.stringify({y: obj})); + +// Test holes in arrays. +var fast_smi = [1, 2, 3, 4]; +fast_smi.__proto__ = [7, 7, 7, 7]; +delete fast_smi[2]; +assertTrue(%HasFastSmiElements(fast_smi)); +assertEquals("[1,2,7,4]", JSON.stringify(fast_smi)); + +var fast_double = [1.1, 2, 3, 4]; +fast_double.__proto__ = [7, 7, 7, 7]; + +delete fast_double[2]; +assertTrue(%HasFastDoubleElements(fast_double)); +assertEquals("[1.1,2,7,4]", JSON.stringify(fast_double)); + +var fast_obj = [1, 2, {}, {}]; +fast_obj.__proto__ = [7, 7, 7, 7]; + +delete fast_obj[2]; +assertTrue(%HasFastObjectElements(fast_obj)); +assertEquals("[1,2,7,{}]", JSON.stringify(fast_obj)); + +var getter_side_effect = { a: 1, + get b() { + delete this.a; + delete this.c; + this.e = 5; + return 2; + }, + c: 3, + d: 4 }; +assertEquals('{"a":1,"b":2,"d":4}', JSON.stringify(getter_side_effect)); +assertEquals('{"b":2,"d":4,"e":5}', JSON.stringify(getter_side_effect)); + +var non_enum = {}; +non_enum.a = 1; +Object.defineProperty(non_enum, "b", { value: 2, enumerable: false }); +non_enum.c = 3; +assertEquals('{"a":1,"c":3}', JSON.stringify(non_enum)); diff --git a/src/3rdparty/v8/test/mjsunit/limit-locals.js b/src/3rdparty/v8/test/mjsunit/limit-locals.js index ad9ec43..a166f30 100644 --- a/src/3rdparty/v8/test/mjsunit/limit-locals.js +++ b/src/3rdparty/v8/test/mjsunit/limit-locals.js @@ -25,7 +25,9 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Test that there is a limit of 32767 locals. +// Test that there is a limit of 131071 locals. + +// Flags: --stack-size=1200 function function_with_n_locals(n) { test_prefix = "prefix "; @@ -40,7 +42,6 @@ function function_with_n_locals(n) { assertEquals("prefix 0 suffix", function_with_n_locals(0)); assertEquals("prefix 16000 suffix", function_with_n_locals(16000)); -assertEquals("prefix 32767 suffix", function_with_n_locals(32767)); +assertEquals("prefix 131071 suffix", function_with_n_locals(131071)); -assertThrows("function_with_n_locals(32768)"); -assertThrows("function_with_n_locals(100000)"); +assertThrows("function_with_n_locals(131072)"); diff --git a/src/3rdparty/v8/test/mjsunit/math-floor-negative.js b/src/3rdparty/v8/test/mjsunit/math-floor-negative.js new file mode 100644 index 0000000..4cabff5 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/math-floor-negative.js @@ -0,0 +1,59 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --noenable_sse4_1 --allow-natives-syntax + +function test1() { + // Trigger overflow when converting/truncating double to integer. + // Divide by 10 to avoid overflow when smi-tagging at the end. + return Math.floor(-100000000000.5) / 10; +} + +function test2() { + // Trigger no overflow. + return Math.floor(-100.2); +} + +function test3() { + // Trigger overflow when compensating by subtracting after compare. + // Divide by 10 to avoid overflow when smi-tagging at the end. + return Math.floor(-2147483648.1) / 10; +} + +test1(); +test1(); +%OptimizeFunctionOnNextCall(test1); +test2(); +test2(); +%OptimizeFunctionOnNextCall(test2); +test3(); +test3(); +%OptimizeFunctionOnNextCall(test3); + +assertEquals(-10000000000.1, test1()); +assertEquals(-101, test2()); +assertEquals(-214748364.9, test3()); diff --git a/src/3rdparty/v8/test/mjsunit/math-floor-of-div-minus-zero.js b/src/3rdparty/v8/test/mjsunit/math-floor-of-div-minus-zero.js new file mode 100644 index 0000000..2743490 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/math-floor-of-div-minus-zero.js @@ -0,0 +1,40 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax --nouse_inlining --noparallel-recompilation + +// Test for negative zero that doesn't need bail out + +function test_div_no_deopt_minus_zero() { + var zero_in_array = [0]; + assertTrue(0 === (Math.floor((zero_in_array[0] | 0) / -1) | 0)); +} + +test_div_no_deopt_minus_zero(); +%OptimizeFunctionOnNextCall(test_div_no_deopt_minus_zero); +test_div_no_deopt_minus_zero(); +assertTrue(2 != %GetOptimizationStatus(test_div_no_deopt_minus_zero)); diff --git a/src/3rdparty/v8/test/mjsunit/math-floor.js b/src/3rdparty/v8/test/mjsunit/math-floor-part1.js index f211ce2..313f272 100644 --- a/src/3rdparty/v8/test/mjsunit/math-floor.js +++ b/src/3rdparty/v8/test/mjsunit/math-floor-part1.js @@ -45,13 +45,6 @@ function zero() { } function test() { - testFloor(0, 0); - testFloor(0, zero()); - testFloor(-0, -0); - testFloor(Infinity, Infinity); - testFloor(-Infinity, -Infinity); - testFloor(NaN, NaN); - // Ensure that a negative zero coming from Math.floor is properly handled // by other operations. function ifloor(x) { @@ -86,74 +79,10 @@ function test() { testFloor(-Number.MAX_VALUE, -Number.MAX_VALUE); testFloor(Infinity, Infinity); testFloor(-Infinity, -Infinity); - - // 2^30 is a smi boundary. - var two_30 = 1 << 30; - - testFloor(two_30, two_30); - testFloor(two_30, two_30 + 0.1); - testFloor(two_30, two_30 + 0.5); - testFloor(two_30, two_30 + 0.7); - - testFloor(two_30 - 1, two_30 - 1); - testFloor(two_30 - 1, two_30 - 1 + 0.1); - testFloor(two_30 - 1, two_30 - 1 + 0.5); - testFloor(two_30 - 1, two_30 - 1 + 0.7); - - testFloor(-two_30, -two_30); - testFloor(-two_30, -two_30 + 0.1); - testFloor(-two_30, -two_30 + 0.5); - testFloor(-two_30, -two_30 + 0.7); - - testFloor(-two_30 + 1, -two_30 + 1); - testFloor(-two_30 + 1, -two_30 + 1 + 0.1); - testFloor(-two_30 + 1, -two_30 + 1 + 0.5); - testFloor(-two_30 + 1, -two_30 + 1 + 0.7); - - // 2^52 is a precision boundary. - var two_52 = (1 << 30) * (1 << 22); - - testFloor(two_52, two_52); - testFloor(two_52, two_52 + 0.1); - assertEquals(two_52, two_52 + 0.5); - testFloor(two_52, two_52 + 0.5); - assertEquals(two_52 + 1, two_52 + 0.7); - testFloor(two_52 + 1, two_52 + 0.7); - - testFloor(two_52 - 1, two_52 - 1); - testFloor(two_52 - 1, two_52 - 1 + 0.1); - testFloor(two_52 - 1, two_52 - 1 + 0.5); - testFloor(two_52 - 1, two_52 - 1 + 0.7); - - testFloor(-two_52, -two_52); - testFloor(-two_52, -two_52 + 0.1); - testFloor(-two_52, -two_52 + 0.5); - testFloor(-two_52, -two_52 + 0.7); - - testFloor(-two_52 + 1, -two_52 + 1); - testFloor(-two_52 + 1, -two_52 + 1 + 0.1); - testFloor(-two_52 + 1, -two_52 + 1 + 0.5); - testFloor(-two_52 + 1, -two_52 + 1 + 0.7); } // Test in a loop to cover the custom IC and GC-related issues. -for (var i = 0; i < 500; i++) { +for (var i = 0; i < 100; i++) { test(); } - - -// Regression test for a bug where a negative zero coming from Math.floor -// was not properly handled by other operations. -function floorsum(i, n) { - var ret = Math.floor(n); - while (--i > 0) { - ret += Math.floor(n); - } - return ret; -} -assertEquals(-0, floorsum(1, -0)); -%OptimizeFunctionOnNextCall(floorsum); -// The optimized function will deopt. Run it with enough iterations to try -// to optimize via OSR (triggering the bug). -assertEquals(-0, floorsum(100000, -0)); diff --git a/src/3rdparty/v8/test/mjsunit/math-floor-part2.js b/src/3rdparty/v8/test/mjsunit/math-floor-part2.js new file mode 100644 index 0000000..b6d51b2 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/math-floor-part2.js @@ -0,0 +1,76 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --max-new-space-size=256 --allow-natives-syntax + +var test_id = 0; + +function testFloor(expect, input) { + var test = new Function('n', + '"' + (test_id++) + '";return Math.floor(n)'); + assertEquals(expect, test(input)); + assertEquals(expect, test(input)); + assertEquals(expect, test(input)); + %OptimizeFunctionOnNextCall(test); + assertEquals(expect, test(input)); +} + +function zero() { + var x = 0.5; + return (function() { return x - 0.5; })(); +} + +function test() { + // 2^30 is a smi boundary. + var two_30 = 1 << 30; + + testFloor(two_30, two_30); + testFloor(two_30, two_30 + 0.1); + testFloor(two_30, two_30 + 0.5); + testFloor(two_30, two_30 + 0.7); + + testFloor(two_30 - 1, two_30 - 1); + testFloor(two_30 - 1, two_30 - 1 + 0.1); + testFloor(two_30 - 1, two_30 - 1 + 0.5); + testFloor(two_30 - 1, two_30 - 1 + 0.7); + + testFloor(-two_30, -two_30); + testFloor(-two_30, -two_30 + 0.1); + testFloor(-two_30, -two_30 + 0.5); + testFloor(-two_30, -two_30 + 0.7); + + testFloor(-two_30 + 1, -two_30 + 1); + testFloor(-two_30 + 1, -two_30 + 1 + 0.1); + testFloor(-two_30 + 1, -two_30 + 1 + 0.5); + testFloor(-two_30 + 1, -two_30 + 1 + 0.7); +} + + +// Test in a loop to cover the custom IC and GC-related issues. +for (var i = 0; i < 100; i++) { + test(); +} diff --git a/src/3rdparty/v8/test/mjsunit/math-floor-part3.js b/src/3rdparty/v8/test/mjsunit/math-floor-part3.js new file mode 100644 index 0000000..db25923 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/math-floor-part3.js @@ -0,0 +1,78 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --max-new-space-size=256 --allow-natives-syntax + +var test_id = 0; + +function testFloor(expect, input) { + var test = new Function('n', + '"' + (test_id++) + '";return Math.floor(n)'); + assertEquals(expect, test(input)); + assertEquals(expect, test(input)); + assertEquals(expect, test(input)); + %OptimizeFunctionOnNextCall(test); + assertEquals(expect, test(input)); +} + +function zero() { + var x = 0.5; + return (function() { return x - 0.5; })(); +} + +function test() { + // 2^52 is a precision boundary. + var two_52 = (1 << 30) * (1 << 22); + + testFloor(two_52, two_52); + testFloor(two_52, two_52 + 0.1); + assertEquals(two_52, two_52 + 0.5); + testFloor(two_52, two_52 + 0.5); + assertEquals(two_52 + 1, two_52 + 0.7); + testFloor(two_52 + 1, two_52 + 0.7); + + testFloor(two_52 - 1, two_52 - 1); + testFloor(two_52 - 1, two_52 - 1 + 0.1); + testFloor(two_52 - 1, two_52 - 1 + 0.5); + testFloor(two_52 - 1, two_52 - 1 + 0.7); + + testFloor(-two_52, -two_52); + testFloor(-two_52, -two_52 + 0.1); + testFloor(-two_52, -two_52 + 0.5); + testFloor(-two_52, -two_52 + 0.7); + + testFloor(-two_52 + 1, -two_52 + 1); + testFloor(-two_52 + 1, -two_52 + 1 + 0.1); + testFloor(-two_52 + 1, -two_52 + 1 + 0.5); + testFloor(-two_52 + 1, -two_52 + 1 + 0.7); +} + + +// Test in a loop to cover the custom IC and GC-related issues. +for (var i = 0; i < 100; i++) { + test(); +} diff --git a/src/3rdparty/v8/test/mjsunit/math-floor-part4.js b/src/3rdparty/v8/test/mjsunit/math-floor-part4.js new file mode 100644 index 0000000..c633623 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/math-floor-part4.js @@ -0,0 +1,76 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --max-new-space-size=256 --allow-natives-syntax + +var test_id = 0; + +function testFloor(expect, input) { + var test = new Function('n', + '"' + (test_id++) + '";return Math.floor(n)'); + assertEquals(expect, test(input)); + assertEquals(expect, test(input)); + assertEquals(expect, test(input)); + %OptimizeFunctionOnNextCall(test); + assertEquals(expect, test(input)); +} + +function zero() { + var x = 0.5; + return (function() { return x - 0.5; })(); +} + +function test() { + testFloor(0, 0); + testFloor(0, zero()); + testFloor(-0, -0); + testFloor(Infinity, Infinity); + testFloor(-Infinity, -Infinity); + testFloor(NaN, NaN); +} + + +// Test in a loop to cover the custom IC and GC-related issues. +for (var i = 0; i < 100; i++) { + test(); +} + + +// Regression test for a bug where a negative zero coming from Math.floor +// was not properly handled by other operations. +function floorsum(i, n) { + var ret = Math.floor(n); + while (--i > 0) { + ret += Math.floor(n); + } + return ret; +} +assertEquals(-0, floorsum(1, -0)); +%OptimizeFunctionOnNextCall(floorsum); +// The optimized function will deopt. Run it with enough iterations to try +// to optimize via OSR (triggering the bug). +assertEquals(-0, floorsum(100000, -0)); diff --git a/src/3rdparty/v8/test/mjsunit/mirror-object.js b/src/3rdparty/v8/test/mjsunit/mirror-object.js index d4d228c..8bf8a2d 100644 --- a/src/3rdparty/v8/test/mjsunit/mirror-object.js +++ b/src/3rdparty/v8/test/mjsunit/mirror-object.js @@ -1,4 +1,4 @@ -// Copyright 2008 the V8 project authors. All rights reserved. +// Copyright 2012 the V8 project authors. All rights reserved. // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: @@ -49,19 +49,19 @@ function testObjectMirror(obj, cls_name, ctor_name, hasSpecialProperties) { JSON.stringify(serializer.serializeReferencedObjects())); // Check the mirror hierachy. - assertTrue(mirror instanceof debug.Mirror, 'Unexpected mirror hierachy'); - assertTrue(mirror instanceof debug.ValueMirror, 'Unexpected mirror hierachy'); - assertTrue(mirror instanceof debug.ObjectMirror, 'Unexpected mirror hierachy'); + assertTrue(mirror instanceof debug.Mirror, 'Unexpected mirror hierarchy'); + assertTrue(mirror instanceof debug.ValueMirror, 'Unexpected mirror hierarchy'); + assertTrue(mirror instanceof debug.ObjectMirror, 'Unexpected mirror hierarchy'); // Check the mirror properties. assertTrue(mirror.isObject(), 'Unexpected mirror'); assertEquals('object', mirror.type(), 'Unexpected mirror type'); assertFalse(mirror.isPrimitive(), 'Unexpected primitive mirror'); assertEquals(cls_name, mirror.className(), 'Unexpected mirror class name'); - assertTrue(mirror.constructorFunction() instanceof debug.ObjectMirror, 'Unexpected mirror hierachy'); + assertTrue(mirror.constructorFunction() instanceof debug.ObjectMirror, 'Unexpected mirror hierarchy'); assertEquals(ctor_name, mirror.constructorFunction().name(), 'Unexpected constructor function name'); - assertTrue(mirror.protoObject() instanceof debug.Mirror, 'Unexpected mirror hierachy'); - assertTrue(mirror.prototypeObject() instanceof debug.Mirror, 'Unexpected mirror hierachy'); + assertTrue(mirror.protoObject() instanceof debug.Mirror, 'Unexpected mirror hierarchy'); + assertTrue(mirror.prototypeObject() instanceof debug.Mirror, 'Unexpected mirror hierarchy'); assertFalse(mirror.hasNamedInterceptor(), 'No named interceptor expected'); assertFalse(mirror.hasIndexedInterceptor(), 'No indexed interceptor expected'); @@ -69,12 +69,19 @@ function testObjectMirror(obj, cls_name, ctor_name, hasSpecialProperties) { var properties = mirror.properties(); assertEquals(names.length, properties.length); for (var i = 0; i < properties.length; i++) { - assertTrue(properties[i] instanceof debug.Mirror, 'Unexpected mirror hierachy'); - assertTrue(properties[i] instanceof debug.PropertyMirror, 'Unexpected mirror hierachy'); + assertTrue(properties[i] instanceof debug.Mirror, 'Unexpected mirror hierarchy'); + assertTrue(properties[i] instanceof debug.PropertyMirror, 'Unexpected mirror hierarchy'); assertEquals('property', properties[i].type(), 'Unexpected mirror type'); assertEquals(names[i], properties[i].name(), 'Unexpected property name'); } + var internalProperties = mirror.internalProperties(); + for (var i = 0; i < internalProperties.length; i++) { + assertTrue(internalProperties[i] instanceof debug.Mirror, 'Unexpected mirror hierarchy'); + assertTrue(internalProperties[i] instanceof debug.InternalPropertyMirror, 'Unexpected mirror hierarchy'); + assertEquals('internalProperty', internalProperties[i].type(), 'Unexpected mirror type'); + } + for (var p in obj) { var property_mirror = mirror.property(p); assertTrue(property_mirror instanceof debug.PropertyMirror); @@ -172,6 +179,7 @@ testObjectMirror(this, 'global', '', true); // Global object has special proper testObjectMirror(this.__proto__, 'Object', ''); testObjectMirror([], 'Array', 'Array'); testObjectMirror([1,2], 'Array', 'Array'); +testObjectMirror(Object(17), 'Number', 'Number'); // Test circular references. o = {}; @@ -230,3 +238,29 @@ assertTrue(mirror.property('length').isNative()); assertEquals('a', mirror.property(0).value().value()); assertEquals('b', mirror.property(1).value().value()); assertEquals('c', mirror.property(2).value().value()); + +// Test value wrapper internal properties. +mirror = debug.MakeMirror(Object("Capybara")); +var ip = mirror.internalProperties(); +assertEquals(1, ip.length); +assertEquals("[[PrimitiveValue]]", ip[0].name()); +assertEquals("string", ip[0].value().type()); +assertEquals("Capybara", ip[0].value().value()); + +// Test bound function internal properties. +mirror = debug.MakeMirror(Number.bind(Array, 2)); +ip = mirror.internalProperties(); +assertEquals(3, ip.length); +var property_map = {}; +for (var i = 0; i < ip.length; i++) { + property_map[ip[i].name()] = ip[i]; +} +assertTrue("[[BoundThis]]" in property_map); +assertEquals("function", property_map["[[BoundThis]]"].value().type()); +assertEquals(Array, property_map["[[BoundThis]]"].value().value()); +assertTrue("[[TargetFunction]]" in property_map); +assertEquals("function", property_map["[[TargetFunction]]"].value().type()); +assertEquals(Number, property_map["[[TargetFunction]]"].value().value()); +assertTrue("[[BoundArgs]]" in property_map); +assertEquals("object", property_map["[[BoundArgs]]"].value().type()); +assertEquals(1, property_map["[[BoundArgs]]"].value().value().length); diff --git a/src/3rdparty/v8/test/mjsunit/mjsunit.js b/src/3rdparty/v8/test/mjsunit/mjsunit.js index 65fb301..25d7c00 100644 --- a/src/3rdparty/v8/test/mjsunit/mjsunit.js +++ b/src/3rdparty/v8/test/mjsunit/mjsunit.js @@ -321,7 +321,7 @@ var assertUnreachable; assertInstanceof = function assertInstanceof(obj, type) { if (!(obj instanceof type)) { var actualTypeName = null; - var actualConstructor = Object.prototypeOf(obj).constructor; + var actualConstructor = Object.getPrototypeOf(obj).constructor; if (typeof actualConstructor == "function") { actualTypeName = actualConstructor.name || String(actualConstructor); } diff --git a/src/3rdparty/v8/test/mjsunit/mjsunit.status b/src/3rdparty/v8/test/mjsunit/mjsunit.status index ab5f2e3..0bf378b 100644 --- a/src/3rdparty/v8/test/mjsunit/mjsunit.status +++ b/src/3rdparty/v8/test/mjsunit/mjsunit.status @@ -28,61 +28,62 @@ prefix mjsunit # All tests in the bug directory are expected to fail. -bugs: FAIL +bugs/*: FAIL ############################################################################## # Fails. regress/regress-1119: FAIL -############################################################################## - -# NewGC: BUG(1719) slow to collect arrays over several contexts. +# Issue 1719: Slow to collect arrays over several contexts. regress/regress-524: SKIP +# When that bug is fixed, revert the expectation to: +# Skip long running test in debug and allow it to timeout in release mode. +# regress/regress-524: (PASS || TIMEOUT), SKIP if $mode == debug ############################################################################## # Too slow in debug mode with --stress-opt compiler/regress-stacktrace-methods: PASS, SKIP if $mode == debug compiler/regress-funcaller: PASS, SKIP if $mode == debug +regress/regress-2318: PASS, SKIP if $mode == debug regress/regress-create-exception: PASS, SKIP if $mode == debug ############################################################################## -# This one uses a built-in that's only present in debug mode. It takes +# These use a built-in that's only present in debug mode. They take # too long to run in debug mode on ARM and MIPS. -fuzz-natives: PASS, SKIP if ($mode == release || $arch == arm || $arch == mips) +fuzz-natives-part*: PASS, SKIP if ($mode == release || $arch == arm || $arch == android_arm || $arch == mipsel) -big-object-literal: PASS, SKIP if ($arch == arm) +big-object-literal: PASS, SKIP if ($arch == arm || $arch == android_arm) # Issue 488: this test sometimes times out. array-constructor: PASS || TIMEOUT # Very slow on ARM and MIPS, contains no architecture dependent code. -unicode-case-overoptimization: PASS, TIMEOUT if ($arch == arm || $arch == mips) - -# Skip long running test in debug and allow it to timeout in release mode. -regress/regress-524: (PASS || TIMEOUT), SKIP if $mode == debug +unicode-case-overoptimization: PASS, TIMEOUT if ($arch == arm || $arch == android_arm || $arch == mipsel) -# Stack manipulations in LiveEdit are buggy - see bug 915 -debug-liveedit-check-stack: SKIP -debug-liveedit-patch-positions-replace: SKIP -debug-liveedit-stack-padding: SKIP - -# Test Crankshaft compilation time. Expected to take too long in debug mode. -regress/regress-1969: PASS, SKIP if $mode == debug +############################################################################## +# This test expects to reach a certain recursion depth, which may not work +# for debug mode. +json-recursive: PASS, (PASS || FAIL) if $mode == debug ############################################################################## -[ $isolates ] +# Skip long running test that times out in debug mode. +regress/regress-crbug-160010: PASS, SKIP if $mode == debug +############################################################################## # This test sets the umask on a per-process basis and hence cannot be # used in multi-threaded runs. -d8-os: SKIP +# On android there is no /tmp directory. +d8-os: PASS, SKIP if ($isolates || $arch == android_arm || $arch == android_ia32) +tools/tickprocessor: PASS, SKIP if ($arch == android_arm || $arch == android_ia32) ############################################################################## -[ $arch == arm ] +[ $arch == arm || $arch == android_arm ] # Slow tests which times out in debug mode. try: PASS, SKIP if $mode == debug debug-scripts-request: PASS, SKIP if $mode == debug array-constructor: PASS, SKIP if $mode == debug +regress/regress-1122: PASS, SKIP if ($mode == debug && $arch == android_arm) # Flaky test that can hit compilation-time stack overflow in debug mode. unicode-test: PASS, (PASS || FAIL) if $mode == debug @@ -92,8 +93,8 @@ compiler/regress-stacktrace-methods: PASS, PASS || TIMEOUT if $mode == release array-splice: PASS || TIMEOUT # Long running test. -mirror-object: PASS || TIMEOUT string-indexof-2: PASS || TIMEOUT +mirror-object: PASS || TIMEOUT # BUG(3251035): Timeouts in long looping crankshaft optimization # tests. Skipping because having them timeout takes too long on the @@ -110,11 +111,9 @@ compiler/property-calls: SKIP compiler/recursive-deopt: SKIP compiler/regress-4: SKIP compiler/regress-funcaller: SKIP -compiler/regress-gvn: SKIP compiler/regress-rep-change: SKIP compiler/regress-arguments: SKIP compiler/regress-funarguments: SKIP -compiler/regress-or: SKIP compiler/regress-3249650: SKIP compiler/simple-deopt: SKIP regress/regress-490: SKIP @@ -128,8 +127,17 @@ regress/regress-3247124: SKIP # should be platform-independent. regress/regress-1132: SKIP +# Stack manipulations in LiveEdit is not implemented for this arch. +debug-liveedit-check-stack: SKIP +debug-liveedit-stack-padding: SKIP +debug-liveedit-restart-frame: SKIP +debug-liveedit-double-call: SKIP + +# Currently always deopt on minus zero +math-floor-of-div-minus-zero: SKIP + ############################################################################## -[ $arch == mips ] +[ $arch == mipsel ] # Slow tests which times out in debug mode. try: PASS, SKIP if $mode == debug @@ -159,11 +167,9 @@ compiler/property-calls: SKIP compiler/recursive-deopt: SKIP compiler/regress-4: SKIP compiler/regress-funcaller: SKIP -compiler/regress-gvn: SKIP compiler/regress-rep-change: SKIP compiler/regress-arguments: SKIP compiler/regress-funarguments: SKIP -compiler/regress-or: SKIP compiler/regress-3249650: SKIP compiler/simple-deopt: SKIP regress/regress-490: SKIP @@ -176,3 +182,10 @@ regress/regress-3247124: SKIP # the test requires too much time to run. However, the problem test covers # should be platform-independent. regress/regress-1132: SKIP + +# Stack manipulations in LiveEdit is not implemented for this arch. +debug-liveedit-check-stack: SKIP +debug-liveedit-stack-padding: SKIP +debug-liveedit-restart-frame: SKIP +debug-liveedit-double-call: SKIP + diff --git a/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part1.js b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part1.js new file mode 100644 index 0000000..7902cc2 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part1.js @@ -0,0 +1,491 @@ +// Copyright 2008 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var x; + +// Converts a number to string respecting -0. +function stringify(n) { + if ((1 / n) === -Infinity) return "-0"; + return String(n); +} + +function f(expected, y) { + function testEval(string, x, y) { + var mulFunction = Function("x, y", "return " + string); + return mulFunction(x, y); + } + function mulTest(expected, x, y) { + assertEquals(expected, x * y); + assertEquals(expected, testEval(stringify(x) + " * y", x, y)); + assertEquals(expected, testEval("x * " + stringify(y), x, y)); + assertEquals(expected, testEval(stringify(x) + " * " + stringify(y), x, y)); + } + mulTest(expected, x, y); + mulTest(-expected, -x, y); + mulTest(-expected, x, -y); + mulTest(expected, -x, -y); + if (x === y) return; // Symmetric cases not necessary. + mulTest(expected, y, x); + mulTest(-expected, -y, x); + mulTest(-expected, y, -x); + mulTest(expected, -y, -x); +} + +x = 0; +f(0, 0); +x = 1; +f(0, 0); +f(1, 1); +x = 2; +f(0, 0); +f(2, 1); +f(4, 2); +x = 3; +f(0, 0); +f(3, 1); +f(6, 2); +f(9, 3); +x = 4; +f(0, 0); +f(4, 1); +f(8, 2); +f(12, 3); +f(16, 4); +x = 5; +f(0, 0); +f(5, 1); +f(10, 2); +f(15, 3); +f(20, 4); +f(25, 5); +x = 7; +f(0, 0); +f(7, 1); +f(14, 2); +f(21, 3); +f(28, 4); +f(35, 5); +f(49, 7); +x = 8; +f(0, 0); +f(8, 1); +f(16, 2); +f(24, 3); +f(32, 4); +f(40, 5); +f(56, 7); +f(64, 8); +x = 9; +f(0, 0); +f(9, 1); +f(18, 2); +f(27, 3); +f(36, 4); +f(45, 5); +f(63, 7); +f(72, 8); +f(81, 9); +x = 15; +f(0, 0); +f(15, 1); +f(30, 2); +f(45, 3); +f(60, 4); +f(75, 5); +f(105, 7); +f(120, 8); +f(135, 9); +f(225, 15); +x = 16; +f(0, 0); +f(16, 1); +f(32, 2); +f(48, 3); +f(64, 4); +f(80, 5); +f(112, 7); +f(128, 8); +f(144, 9); +f(240, 15); +f(256, 16); +x = 17; +f(0, 0); +f(17, 1); +f(34, 2); +f(51, 3); +f(68, 4); +f(85, 5); +f(119, 7); +f(136, 8); +f(153, 9); +f(255, 15); +f(272, 16); +f(289, 17); +x = 31; +f(0, 0); +f(31, 1); +f(62, 2); +f(93, 3); +f(124, 4); +f(155, 5); +f(217, 7); +f(248, 8); +f(279, 9); +f(465, 15); +f(496, 16); +f(527, 17); +f(961, 31); +x = 32; +f(0, 0); +f(32, 1); +f(64, 2); +f(96, 3); +f(128, 4); +f(160, 5); +f(224, 7); +f(256, 8); +f(288, 9); +f(480, 15); +f(512, 16); +f(544, 17); +f(992, 31); +f(1024, 32); +x = 33; +f(0, 0); +f(33, 1); +f(66, 2); +f(99, 3); +f(132, 4); +f(165, 5); +f(231, 7); +f(264, 8); +f(297, 9); +f(495, 15); +f(528, 16); +f(561, 17); +f(1023, 31); +f(1056, 32); +f(1089, 33); +x = 63; +f(0, 0); +f(63, 1); +f(126, 2); +f(189, 3); +f(252, 4); +f(315, 5); +f(441, 7); +f(504, 8); +f(567, 9); +f(945, 15); +f(1008, 16); +f(1071, 17); +f(1953, 31); +f(2016, 32); +f(2079, 33); +f(3969, 63); +x = 64; +f(0, 0); +f(64, 1); +f(128, 2); +f(192, 3); +f(256, 4); +f(320, 5); +f(448, 7); +f(512, 8); +f(576, 9); +f(960, 15); +f(1024, 16); +f(1088, 17); +f(1984, 31); +f(2048, 32); +f(2112, 33); +f(4032, 63); +f(4096, 64); +x = 65; +f(0, 0); +f(65, 1); +f(130, 2); +f(195, 3); +f(260, 4); +f(325, 5); +f(455, 7); +f(520, 8); +f(585, 9); +f(975, 15); +f(1040, 16); +f(1105, 17); +f(2015, 31); +f(2080, 32); +f(2145, 33); +f(4095, 63); +f(4160, 64); +f(4225, 65); +x = 127; +f(0, 0); +f(127, 1); +f(254, 2); +f(381, 3); +f(508, 4); +f(635, 5); +f(889, 7); +f(1016, 8); +f(1143, 9); +f(1905, 15); +f(2032, 16); +f(2159, 17); +f(3937, 31); +f(4064, 32); +f(4191, 33); +f(8001, 63); +f(8128, 64); +f(8255, 65); +f(16129, 127); +x = 128; +f(0, 0); +f(128, 1); +f(256, 2); +f(384, 3); +f(512, 4); +f(640, 5); +f(896, 7); +f(1024, 8); +f(1152, 9); +f(1920, 15); +f(2048, 16); +f(2176, 17); +f(3968, 31); +f(4096, 32); +f(4224, 33); +f(8064, 63); +f(8192, 64); +f(8320, 65); +f(16256, 127); +f(16384, 128); +x = 129; +f(0, 0); +f(129, 1); +f(258, 2); +f(387, 3); +f(516, 4); +f(645, 5); +f(903, 7); +f(1032, 8); +f(1161, 9); +f(1935, 15); +f(2064, 16); +f(2193, 17); +f(3999, 31); +f(4128, 32); +f(4257, 33); +f(8127, 63); +f(8256, 64); +f(8385, 65); +f(16383, 127); +f(16512, 128); +f(16641, 129); +x = 255; +f(0, 0); +f(255, 1); +f(510, 2); +f(765, 3); +f(1020, 4); +f(1275, 5); +f(1785, 7); +f(2040, 8); +f(2295, 9); +f(3825, 15); +f(4080, 16); +f(4335, 17); +f(7905, 31); +f(8160, 32); +f(8415, 33); +f(16065, 63); +f(16320, 64); +f(16575, 65); +f(32385, 127); +f(32640, 128); +f(32895, 129); +f(65025, 255); +x = 256; +f(0, 0); +f(256, 1); +f(512, 2); +f(768, 3); +f(1024, 4); +f(1280, 5); +f(1792, 7); +f(2048, 8); +f(2304, 9); +f(3840, 15); +f(4096, 16); +f(4352, 17); +f(7936, 31); +f(8192, 32); +f(8448, 33); +f(16128, 63); +f(16384, 64); +f(16640, 65); +f(32512, 127); +f(32768, 128); +f(33024, 129); +f(65280, 255); +f(65536, 256); +x = 257; +f(0, 0); +f(257, 1); +f(514, 2); +f(771, 3); +f(1028, 4); +f(1285, 5); +f(1799, 7); +f(2056, 8); +f(2313, 9); +f(3855, 15); +f(4112, 16); +f(4369, 17); +f(7967, 31); +f(8224, 32); +f(8481, 33); +f(16191, 63); +f(16448, 64); +f(16705, 65); +f(32639, 127); +f(32896, 128); +f(33153, 129); +f(65535, 255); +f(65792, 256); +f(66049, 257); +x = 511; +f(0, 0); +f(511, 1); +f(1022, 2); +f(1533, 3); +f(2044, 4); +f(2555, 5); +f(3577, 7); +f(4088, 8); +f(4599, 9); +f(7665, 15); +f(8176, 16); +f(8687, 17); +f(15841, 31); +f(16352, 32); +f(16863, 33); +f(32193, 63); +f(32704, 64); +f(33215, 65); +f(64897, 127); +f(65408, 128); +f(65919, 129); +f(130305, 255); +f(130816, 256); +f(131327, 257); +f(261121, 511); +x = 512; +f(0, 0); +f(512, 1); +f(1024, 2); +f(1536, 3); +f(2048, 4); +f(2560, 5); +f(3584, 7); +f(4096, 8); +f(4608, 9); +f(7680, 15); +f(8192, 16); +f(8704, 17); +f(15872, 31); +f(16384, 32); +f(16896, 33); +f(32256, 63); +f(32768, 64); +f(33280, 65); +f(65024, 127); +f(65536, 128); +f(66048, 129); +f(130560, 255); +f(131072, 256); +f(131584, 257); +f(261632, 511); +f(262144, 512); +x = 513; +f(0, 0); +f(513, 1); +f(1026, 2); +f(1539, 3); +f(2052, 4); +f(2565, 5); +f(3591, 7); +f(4104, 8); +f(4617, 9); +f(7695, 15); +f(8208, 16); +f(8721, 17); +f(15903, 31); +f(16416, 32); +f(16929, 33); +f(32319, 63); +f(32832, 64); +f(33345, 65); +f(65151, 127); +f(65664, 128); +f(66177, 129); +f(130815, 255); +f(131328, 256); +f(131841, 257); +f(262143, 511); +f(262656, 512); +f(263169, 513); +x = 1023; +f(0, 0); +f(1023, 1); +f(2046, 2); +f(3069, 3); +f(4092, 4); +f(5115, 5); +f(7161, 7); +f(8184, 8); +f(9207, 9); +f(15345, 15); +f(16368, 16); +f(17391, 17); +f(31713, 31); +f(32736, 32); +f(33759, 33); +f(64449, 63); +f(65472, 64); +f(66495, 65); +f(129921, 127); +f(130944, 128); +f(131967, 129); +f(260865, 255); +f(261888, 256); +f(262911, 257); +f(522753, 511); +f(523776, 512); +f(524799, 513); +f(1046529, 1023); diff --git a/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part10.js b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part10.js new file mode 100644 index 0000000..166ec52 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part10.js @@ -0,0 +1,470 @@ +// Copyright 2008 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var x; + +// Converts a number to string respecting -0. +function stringify(n) { + if ((1 / n) === -Infinity) return "-0"; + return String(n); +} + +function f(expected, y) { + function testEval(string, x, y) { + var mulFunction = Function("x, y", "return " + string); + return mulFunction(x, y); + } + function mulTest(expected, x, y) { + assertEquals(expected, x * y); + assertEquals(expected, testEval(stringify(x) + " * y", x, y)); + assertEquals(expected, testEval("x * " + stringify(y), x, y)); + assertEquals(expected, testEval(stringify(x) + " * " + stringify(y), x, y)); + } + mulTest(expected, x, y); + mulTest(-expected, -x, y); + mulTest(-expected, x, -y); + mulTest(expected, -x, -y); + if (x === y) return; // Symmetric cases not necessary. + mulTest(expected, y, x); + mulTest(-expected, -y, x); + mulTest(-expected, y, -x); + mulTest(expected, -y, -x); +} + +x = 4294967296; +f(0, 0); +f(4294967296, 1); +f(8589934592, 2); +f(12884901888, 3); +f(17179869184, 4); +f(21474836480, 5); +f(30064771072, 7); +f(34359738368, 8); +f(38654705664, 9); +f(64424509440, 15); +f(68719476736, 16); +f(73014444032, 17); +f(133143986176, 31); +f(137438953472, 32); +f(141733920768, 33); +f(270582939648, 63); +f(274877906944, 64); +f(279172874240, 65); +f(545460846592, 127); +f(549755813888, 128); +f(554050781184, 129); +f(1095216660480, 255); +f(1099511627776, 256); +f(1103806595072, 257); +f(2194728288256, 511); +f(2199023255552, 512); +f(2203318222848, 513); +f(4393751543808, 1023); +f(4398046511104, 1024); +f(4402341478400, 1025); +f(8791798054912, 2047); +f(8796093022208, 2048); +f(8800387989504, 2049); +f(17587891077120, 4095); +f(17592186044416, 4096); +f(17596481011712, 4097); +f(35180077121536, 8191); +f(35184372088832, 8192); +f(35188667056128, 8193); +f(70364449210368, 16383); +f(70368744177664, 16384); +f(70373039144960, 16385); +f(140733193388032, 32767); +f(140737488355328, 32768); +f(140741783322624, 32769); +f(281470681743360, 65535); +f(281474976710656, 65536); +f(281479271677952, 65537); +f(562945658454016, 131071); +f(562949953421312, 131072); +f(562954248388608, 131073); +f(1125895611875328, 262143); +f(1125899906842624, 262144); +f(1125904201809920, 262145); +x = 4294967297; +f(0, 0); +f(4294967297, 1); +f(8589934594, 2); +f(12884901891, 3); +f(17179869188, 4); +f(21474836485, 5); +f(30064771079, 7); +f(34359738376, 8); +f(38654705673, 9); +f(64424509455, 15); +f(68719476752, 16); +f(73014444049, 17); +f(133143986207, 31); +f(137438953504, 32); +f(141733920801, 33); +f(270582939711, 63); +f(274877907008, 64); +f(279172874305, 65); +f(545460846719, 127); +f(549755814016, 128); +f(554050781313, 129); +f(1095216660735, 255); +f(1099511628032, 256); +f(1103806595329, 257); +f(2194728288767, 511); +f(2199023256064, 512); +f(2203318223361, 513); +f(4393751544831, 1023); +f(4398046512128, 1024); +f(4402341479425, 1025); +f(8791798056959, 2047); +f(8796093024256, 2048); +f(8800387991553, 2049); +f(17587891081215, 4095); +f(17592186048512, 4096); +f(17596481015809, 4097); +f(35180077129727, 8191); +f(35184372097024, 8192); +f(35188667064321, 8193); +f(70364449226751, 16383); +f(70368744194048, 16384); +f(70373039161345, 16385); +f(140733193420799, 32767); +f(140737488388096, 32768); +f(140741783355393, 32769); +f(281470681808895, 65535); +f(281474976776192, 65536); +f(281479271743489, 65537); +f(562945658585087, 131071); +f(562949953552384, 131072); +f(562954248519681, 131073); +f(1125895612137471, 262143); +f(1125899907104768, 262144); +f(1125904202072065, 262145); +x = 8589934591; +f(0, 0); +f(8589934591, 1); +f(17179869182, 2); +f(25769803773, 3); +f(34359738364, 4); +f(42949672955, 5); +f(60129542137, 7); +f(68719476728, 8); +f(77309411319, 9); +f(128849018865, 15); +f(137438953456, 16); +f(146028888047, 17); +f(266287972321, 31); +f(274877906912, 32); +f(283467841503, 33); +f(541165879233, 63); +f(549755813824, 64); +f(558345748415, 65); +f(1090921693057, 127); +f(1099511627648, 128); +f(1108101562239, 129); +f(2190433320705, 255); +f(2199023255296, 256); +f(2207613189887, 257); +f(4389456576001, 511); +f(4398046510592, 512); +f(4406636445183, 513); +f(8787503086593, 1023); +f(8796093021184, 1024); +f(8804682955775, 1025); +f(17583596107777, 2047); +f(17592186042368, 2048); +f(17600775976959, 2049); +f(35175782150145, 4095); +f(35184372084736, 4096); +f(35192962019327, 4097); +f(70360154234881, 8191); +f(70368744169472, 8192); +f(70377334104063, 8193); +f(140728898404353, 16383); +f(140737488338944, 16384); +f(140746078273535, 16385); +f(281466386743297, 32767); +f(281474976677888, 32768); +f(281483566612479, 32769); +f(562941363421185, 65535); +f(562949953355776, 65536); +f(562958543290367, 65537); +f(1125891316776961, 131071); +f(1125899906711552, 131072); +f(1125908496646143, 131073); +x = 8589934592; +f(0, 0); +f(8589934592, 1); +f(17179869184, 2); +f(25769803776, 3); +f(34359738368, 4); +f(42949672960, 5); +f(60129542144, 7); +f(68719476736, 8); +f(77309411328, 9); +f(128849018880, 15); +f(137438953472, 16); +f(146028888064, 17); +f(266287972352, 31); +f(274877906944, 32); +f(283467841536, 33); +f(541165879296, 63); +f(549755813888, 64); +f(558345748480, 65); +f(1090921693184, 127); +f(1099511627776, 128); +f(1108101562368, 129); +f(2190433320960, 255); +f(2199023255552, 256); +f(2207613190144, 257); +f(4389456576512, 511); +f(4398046511104, 512); +f(4406636445696, 513); +f(8787503087616, 1023); +f(8796093022208, 1024); +f(8804682956800, 1025); +f(17583596109824, 2047); +f(17592186044416, 2048); +f(17600775979008, 2049); +f(35175782154240, 4095); +f(35184372088832, 4096); +f(35192962023424, 4097); +f(70360154243072, 8191); +f(70368744177664, 8192); +f(70377334112256, 8193); +f(140728898420736, 16383); +f(140737488355328, 16384); +f(140746078289920, 16385); +f(281466386776064, 32767); +f(281474976710656, 32768); +f(281483566645248, 32769); +f(562941363486720, 65535); +f(562949953421312, 65536); +f(562958543355904, 65537); +f(1125891316908032, 131071); +f(1125899906842624, 131072); +f(1125908496777216, 131073); +x = 8589934593; +f(0, 0); +f(8589934593, 1); +f(17179869186, 2); +f(25769803779, 3); +f(34359738372, 4); +f(42949672965, 5); +f(60129542151, 7); +f(68719476744, 8); +f(77309411337, 9); +f(128849018895, 15); +f(137438953488, 16); +f(146028888081, 17); +f(266287972383, 31); +f(274877906976, 32); +f(283467841569, 33); +f(541165879359, 63); +f(549755813952, 64); +f(558345748545, 65); +f(1090921693311, 127); +f(1099511627904, 128); +f(1108101562497, 129); +f(2190433321215, 255); +f(2199023255808, 256); +f(2207613190401, 257); +f(4389456577023, 511); +f(4398046511616, 512); +f(4406636446209, 513); +f(8787503088639, 1023); +f(8796093023232, 1024); +f(8804682957825, 1025); +f(17583596111871, 2047); +f(17592186046464, 2048); +f(17600775981057, 2049); +f(35175782158335, 4095); +f(35184372092928, 4096); +f(35192962027521, 4097); +f(70360154251263, 8191); +f(70368744185856, 8192); +f(70377334120449, 8193); +f(140728898437119, 16383); +f(140737488371712, 16384); +f(140746078306305, 16385); +f(281466386808831, 32767); +f(281474976743424, 32768); +f(281483566678017, 32769); +f(562941363552255, 65535); +f(562949953486848, 65536); +f(562958543421441, 65537); +f(1125891317039103, 131071); +f(1125899906973696, 131072); +f(1125908496908289, 131073); +x = 17179869183; +f(0, 0); +f(17179869183, 1); +f(34359738366, 2); +f(51539607549, 3); +f(68719476732, 4); +f(85899345915, 5); +f(120259084281, 7); +f(137438953464, 8); +f(154618822647, 9); +f(257698037745, 15); +f(274877906928, 16); +f(292057776111, 17); +f(532575944673, 31); +f(549755813856, 32); +f(566935683039, 33); +f(1082331758529, 63); +f(1099511627712, 64); +f(1116691496895, 65); +f(2181843386241, 127); +f(2199023255424, 128); +f(2216203124607, 129); +f(4380866641665, 255); +f(4398046510848, 256); +f(4415226380031, 257); +f(8778913152513, 511); +f(8796093021696, 512); +f(8813272890879, 513); +f(17575006174209, 1023); +f(17592186043392, 1024); +f(17609365912575, 1025); +f(35167192217601, 2047); +f(35184372086784, 2048); +f(35201551955967, 2049); +f(70351564304385, 4095); +f(70368744173568, 4096); +f(70385924042751, 4097); +f(140720308477953, 8191); +f(140737488347136, 8192); +f(140754668216319, 8193); +f(281457796825089, 16383); +f(281474976694272, 16384); +f(281492156563455, 16385); +f(562932773519361, 32767); +f(562949953388544, 32768); +f(562967133257727, 32769); +f(1125882726907905, 65535); +f(1125899906777088, 65536); +f(1125917086646271, 65537); +x = 17179869184; +f(0, 0); +f(17179869184, 1); +f(34359738368, 2); +f(51539607552, 3); +f(68719476736, 4); +f(85899345920, 5); +f(120259084288, 7); +f(137438953472, 8); +f(154618822656, 9); +f(257698037760, 15); +f(274877906944, 16); +f(292057776128, 17); +f(532575944704, 31); +f(549755813888, 32); +f(566935683072, 33); +f(1082331758592, 63); +f(1099511627776, 64); +f(1116691496960, 65); +f(2181843386368, 127); +f(2199023255552, 128); +f(2216203124736, 129); +f(4380866641920, 255); +f(4398046511104, 256); +f(4415226380288, 257); +f(8778913153024, 511); +f(8796093022208, 512); +f(8813272891392, 513); +f(17575006175232, 1023); +f(17592186044416, 1024); +f(17609365913600, 1025); +f(35167192219648, 2047); +f(35184372088832, 2048); +f(35201551958016, 2049); +f(70351564308480, 4095); +f(70368744177664, 4096); +f(70385924046848, 4097); +f(140720308486144, 8191); +f(140737488355328, 8192); +f(140754668224512, 8193); +f(281457796841472, 16383); +f(281474976710656, 16384); +f(281492156579840, 16385); +f(562932773552128, 32767); +f(562949953421312, 32768); +f(562967133290496, 32769); +f(1125882726973440, 65535); +f(1125899906842624, 65536); +f(1125917086711808, 65537); +x = 17179869185; +f(0, 0); +f(17179869185, 1); +f(34359738370, 2); +f(51539607555, 3); +f(68719476740, 4); +f(85899345925, 5); +f(120259084295, 7); +f(137438953480, 8); +f(154618822665, 9); +f(257698037775, 15); +f(274877906960, 16); +f(292057776145, 17); +f(532575944735, 31); +f(549755813920, 32); +f(566935683105, 33); +f(1082331758655, 63); +f(1099511627840, 64); +f(1116691497025, 65); +f(2181843386495, 127); +f(2199023255680, 128); +f(2216203124865, 129); +f(4380866642175, 255); +f(4398046511360, 256); +f(4415226380545, 257); +f(8778913153535, 511); +f(8796093022720, 512); +f(8813272891905, 513); +f(17575006176255, 1023); +f(17592186045440, 1024); +f(17609365914625, 1025); +f(35167192221695, 2047); +f(35184372090880, 2048); +f(35201551960065, 2049); +f(70351564312575, 4095); +f(70368744181760, 4096); +f(70385924050945, 4097); +f(140720308494335, 8191); +f(140737488363520, 8192); +f(140754668232705, 8193); +f(281457796857855, 16383); +f(281474976727040, 16384); +f(281492156596225, 16385); +f(562932773584895, 32767); +f(562949953454080, 32768); +f(562967133323265, 32769); +f(1125882727038975, 65535); +f(1125899906908160, 65536); +f(1125917086777345, 65537); diff --git a/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part2.js b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part2.js new file mode 100644 index 0000000..4c4a123 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part2.js @@ -0,0 +1,525 @@ +// Copyright 2008 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var x; + +// Converts a number to string respecting -0. +function stringify(n) { + if ((1 / n) === -Infinity) return "-0"; + return String(n); +} + +function f(expected, y) { + function testEval(string, x, y) { + var mulFunction = Function("x, y", "return " + string); + return mulFunction(x, y); + } + function mulTest(expected, x, y) { + assertEquals(expected, x * y); + assertEquals(expected, testEval(stringify(x) + " * y", x, y)); + assertEquals(expected, testEval("x * " + stringify(y), x, y)); + assertEquals(expected, testEval(stringify(x) + " * " + stringify(y), x, y)); + } + mulTest(expected, x, y); + mulTest(-expected, -x, y); + mulTest(-expected, x, -y); + mulTest(expected, -x, -y); + if (x === y) return; // Symmetric cases not necessary. + mulTest(expected, y, x); + mulTest(-expected, -y, x); + mulTest(-expected, y, -x); + mulTest(expected, -y, -x); +} + +x = 1024; +f(0, 0); +f(1024, 1); +f(2048, 2); +f(3072, 3); +f(4096, 4); +f(5120, 5); +f(7168, 7); +f(8192, 8); +f(9216, 9); +f(15360, 15); +f(16384, 16); +f(17408, 17); +f(31744, 31); +f(32768, 32); +f(33792, 33); +f(64512, 63); +f(65536, 64); +f(66560, 65); +f(130048, 127); +f(131072, 128); +f(132096, 129); +f(261120, 255); +f(262144, 256); +f(263168, 257); +f(523264, 511); +f(524288, 512); +f(525312, 513); +f(1047552, 1023); +f(1048576, 1024); +x = 1025; +f(0, 0); +f(1025, 1); +f(2050, 2); +f(3075, 3); +f(4100, 4); +f(5125, 5); +f(7175, 7); +f(8200, 8); +f(9225, 9); +f(15375, 15); +f(16400, 16); +f(17425, 17); +f(31775, 31); +f(32800, 32); +f(33825, 33); +f(64575, 63); +f(65600, 64); +f(66625, 65); +f(130175, 127); +f(131200, 128); +f(132225, 129); +f(261375, 255); +f(262400, 256); +f(263425, 257); +f(523775, 511); +f(524800, 512); +f(525825, 513); +f(1048575, 1023); +f(1049600, 1024); +f(1050625, 1025); +x = 2047; +f(0, 0); +f(2047, 1); +f(4094, 2); +f(6141, 3); +f(8188, 4); +f(10235, 5); +f(14329, 7); +f(16376, 8); +f(18423, 9); +f(30705, 15); +f(32752, 16); +f(34799, 17); +f(63457, 31); +f(65504, 32); +f(67551, 33); +f(128961, 63); +f(131008, 64); +f(133055, 65); +f(259969, 127); +f(262016, 128); +f(264063, 129); +f(521985, 255); +f(524032, 256); +f(526079, 257); +f(1046017, 511); +f(1048064, 512); +f(1050111, 513); +f(2094081, 1023); +f(2096128, 1024); +f(2098175, 1025); +f(4190209, 2047); +x = 2048; +f(0, 0); +f(2048, 1); +f(4096, 2); +f(6144, 3); +f(8192, 4); +f(10240, 5); +f(14336, 7); +f(16384, 8); +f(18432, 9); +f(30720, 15); +f(32768, 16); +f(34816, 17); +f(63488, 31); +f(65536, 32); +f(67584, 33); +f(129024, 63); +f(131072, 64); +f(133120, 65); +f(260096, 127); +f(262144, 128); +f(264192, 129); +f(522240, 255); +f(524288, 256); +f(526336, 257); +f(1046528, 511); +f(1048576, 512); +f(1050624, 513); +f(2095104, 1023); +f(2097152, 1024); +f(2099200, 1025); +f(4192256, 2047); +f(4194304, 2048); +x = 2049; +f(0, 0); +f(2049, 1); +f(4098, 2); +f(6147, 3); +f(8196, 4); +f(10245, 5); +f(14343, 7); +f(16392, 8); +f(18441, 9); +f(30735, 15); +f(32784, 16); +f(34833, 17); +f(63519, 31); +f(65568, 32); +f(67617, 33); +f(129087, 63); +f(131136, 64); +f(133185, 65); +f(260223, 127); +f(262272, 128); +f(264321, 129); +f(522495, 255); +f(524544, 256); +f(526593, 257); +f(1047039, 511); +f(1049088, 512); +f(1051137, 513); +f(2096127, 1023); +f(2098176, 1024); +f(2100225, 1025); +f(4194303, 2047); +f(4196352, 2048); +f(4198401, 2049); +x = 4095; +f(0, 0); +f(4095, 1); +f(8190, 2); +f(12285, 3); +f(16380, 4); +f(20475, 5); +f(28665, 7); +f(32760, 8); +f(36855, 9); +f(61425, 15); +f(65520, 16); +f(69615, 17); +f(126945, 31); +f(131040, 32); +f(135135, 33); +f(257985, 63); +f(262080, 64); +f(266175, 65); +f(520065, 127); +f(524160, 128); +f(528255, 129); +f(1044225, 255); +f(1048320, 256); +f(1052415, 257); +f(2092545, 511); +f(2096640, 512); +f(2100735, 513); +f(4189185, 1023); +f(4193280, 1024); +f(4197375, 1025); +f(8382465, 2047); +f(8386560, 2048); +f(8390655, 2049); +f(16769025, 4095); +x = 4096; +f(0, 0); +f(4096, 1); +f(8192, 2); +f(12288, 3); +f(16384, 4); +f(20480, 5); +f(28672, 7); +f(32768, 8); +f(36864, 9); +f(61440, 15); +f(65536, 16); +f(69632, 17); +f(126976, 31); +f(131072, 32); +f(135168, 33); +f(258048, 63); +f(262144, 64); +f(266240, 65); +f(520192, 127); +f(524288, 128); +f(528384, 129); +f(1044480, 255); +f(1048576, 256); +f(1052672, 257); +f(2093056, 511); +f(2097152, 512); +f(2101248, 513); +f(4190208, 1023); +f(4194304, 1024); +f(4198400, 1025); +f(8384512, 2047); +f(8388608, 2048); +f(8392704, 2049); +f(16773120, 4095); +f(16777216, 4096); +x = 4097; +f(0, 0); +f(4097, 1); +f(8194, 2); +f(12291, 3); +f(16388, 4); +f(20485, 5); +f(28679, 7); +f(32776, 8); +f(36873, 9); +f(61455, 15); +f(65552, 16); +f(69649, 17); +f(127007, 31); +f(131104, 32); +f(135201, 33); +f(258111, 63); +f(262208, 64); +f(266305, 65); +f(520319, 127); +f(524416, 128); +f(528513, 129); +f(1044735, 255); +f(1048832, 256); +f(1052929, 257); +f(2093567, 511); +f(2097664, 512); +f(2101761, 513); +f(4191231, 1023); +f(4195328, 1024); +f(4199425, 1025); +f(8386559, 2047); +f(8390656, 2048); +f(8394753, 2049); +f(16777215, 4095); +f(16781312, 4096); +f(16785409, 4097); +x = 8191; +f(0, 0); +f(8191, 1); +f(16382, 2); +f(24573, 3); +f(32764, 4); +f(40955, 5); +f(57337, 7); +f(65528, 8); +f(73719, 9); +f(122865, 15); +f(131056, 16); +f(139247, 17); +f(253921, 31); +f(262112, 32); +f(270303, 33); +f(516033, 63); +f(524224, 64); +f(532415, 65); +f(1040257, 127); +f(1048448, 128); +f(1056639, 129); +f(2088705, 255); +f(2096896, 256); +f(2105087, 257); +f(4185601, 511); +f(4193792, 512); +f(4201983, 513); +f(8379393, 1023); +f(8387584, 1024); +f(8395775, 1025); +f(16766977, 2047); +f(16775168, 2048); +f(16783359, 2049); +f(33542145, 4095); +f(33550336, 4096); +f(33558527, 4097); +f(67092481, 8191); +x = 8192; +f(0, 0); +f(8192, 1); +f(16384, 2); +f(24576, 3); +f(32768, 4); +f(40960, 5); +f(57344, 7); +f(65536, 8); +f(73728, 9); +f(122880, 15); +f(131072, 16); +f(139264, 17); +f(253952, 31); +f(262144, 32); +f(270336, 33); +f(516096, 63); +f(524288, 64); +f(532480, 65); +f(1040384, 127); +f(1048576, 128); +f(1056768, 129); +f(2088960, 255); +f(2097152, 256); +f(2105344, 257); +f(4186112, 511); +f(4194304, 512); +f(4202496, 513); +f(8380416, 1023); +f(8388608, 1024); +f(8396800, 1025); +f(16769024, 2047); +f(16777216, 2048); +f(16785408, 2049); +f(33546240, 4095); +f(33554432, 4096); +f(33562624, 4097); +f(67100672, 8191); +f(67108864, 8192); +x = 8193; +f(0, 0); +f(8193, 1); +f(16386, 2); +f(24579, 3); +f(32772, 4); +f(40965, 5); +f(57351, 7); +f(65544, 8); +f(73737, 9); +f(122895, 15); +f(131088, 16); +f(139281, 17); +f(253983, 31); +f(262176, 32); +f(270369, 33); +f(516159, 63); +f(524352, 64); +f(532545, 65); +f(1040511, 127); +f(1048704, 128); +f(1056897, 129); +f(2089215, 255); +f(2097408, 256); +f(2105601, 257); +f(4186623, 511); +f(4194816, 512); +f(4203009, 513); +f(8381439, 1023); +f(8389632, 1024); +f(8397825, 1025); +f(16771071, 2047); +f(16779264, 2048); +f(16787457, 2049); +f(33550335, 4095); +f(33558528, 4096); +f(33566721, 4097); +f(67108863, 8191); +f(67117056, 8192); +f(67125249, 8193); +x = 16383; +f(0, 0); +f(16383, 1); +f(32766, 2); +f(49149, 3); +f(65532, 4); +f(81915, 5); +f(114681, 7); +f(131064, 8); +f(147447, 9); +f(245745, 15); +f(262128, 16); +f(278511, 17); +f(507873, 31); +f(524256, 32); +f(540639, 33); +f(1032129, 63); +f(1048512, 64); +f(1064895, 65); +f(2080641, 127); +f(2097024, 128); +f(2113407, 129); +f(4177665, 255); +f(4194048, 256); +f(4210431, 257); +f(8371713, 511); +f(8388096, 512); +f(8404479, 513); +f(16759809, 1023); +f(16776192, 1024); +f(16792575, 1025); +f(33536001, 2047); +f(33552384, 2048); +f(33568767, 2049); +f(67088385, 4095); +f(67104768, 4096); +f(67121151, 4097); +f(134193153, 8191); +f(134209536, 8192); +f(134225919, 8193); +f(268402689, 16383); +x = 16384; +f(0, 0); +f(16384, 1); +f(32768, 2); +f(49152, 3); +f(65536, 4); +f(81920, 5); +f(114688, 7); +f(131072, 8); +f(147456, 9); +f(245760, 15); +f(262144, 16); +f(278528, 17); +f(507904, 31); +f(524288, 32); +f(540672, 33); +f(1032192, 63); +f(1048576, 64); +f(1064960, 65); +f(2080768, 127); +f(2097152, 128); +f(2113536, 129); +f(4177920, 255); +f(4194304, 256); +f(4210688, 257); +f(8372224, 511); +f(8388608, 512); +f(8404992, 513); +f(16760832, 1023); +f(16777216, 1024); +f(16793600, 1025); +f(33538048, 2047); +f(33554432, 2048); +f(33570816, 2049); +f(67092480, 4095); +f(67108864, 4096); +f(67125248, 4097); +f(134201344, 8191); +f(134217728, 8192); +f(134234112, 8193); +f(268419072, 16383); +f(268435456, 16384); diff --git a/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part3.js b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part3.js new file mode 100644 index 0000000..06e41a1 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part3.js @@ -0,0 +1,532 @@ +// Copyright 2008 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var x; + +// Converts a number to string respecting -0. +function stringify(n) { + if ((1 / n) === -Infinity) return "-0"; + return String(n); +} + +function f(expected, y) { + function testEval(string, x, y) { + var mulFunction = Function("x, y", "return " + string); + return mulFunction(x, y); + } + function mulTest(expected, x, y) { + assertEquals(expected, x * y); + assertEquals(expected, testEval(stringify(x) + " * y", x, y)); + assertEquals(expected, testEval("x * " + stringify(y), x, y)); + assertEquals(expected, testEval(stringify(x) + " * " + stringify(y), x, y)); + } + mulTest(expected, x, y); + mulTest(-expected, -x, y); + mulTest(-expected, x, -y); + mulTest(expected, -x, -y); + if (x === y) return; // Symmetric cases not necessary. + mulTest(expected, y, x); + mulTest(-expected, -y, x); + mulTest(-expected, y, -x); + mulTest(expected, -y, -x); +} + +x = 16385; +f(0, 0); +f(16385, 1); +f(32770, 2); +f(49155, 3); +f(65540, 4); +f(81925, 5); +f(114695, 7); +f(131080, 8); +f(147465, 9); +f(245775, 15); +f(262160, 16); +f(278545, 17); +f(507935, 31); +f(524320, 32); +f(540705, 33); +f(1032255, 63); +f(1048640, 64); +f(1065025, 65); +f(2080895, 127); +f(2097280, 128); +f(2113665, 129); +f(4178175, 255); +f(4194560, 256); +f(4210945, 257); +f(8372735, 511); +f(8389120, 512); +f(8405505, 513); +f(16761855, 1023); +f(16778240, 1024); +f(16794625, 1025); +f(33540095, 2047); +f(33556480, 2048); +f(33572865, 2049); +f(67096575, 4095); +f(67112960, 4096); +f(67129345, 4097); +f(134209535, 8191); +f(134225920, 8192); +f(134242305, 8193); +f(268435455, 16383); +f(268451840, 16384); +f(268468225, 16385); +x = 32767; +f(0, 0); +f(32767, 1); +f(65534, 2); +f(98301, 3); +f(131068, 4); +f(163835, 5); +f(229369, 7); +f(262136, 8); +f(294903, 9); +f(491505, 15); +f(524272, 16); +f(557039, 17); +f(1015777, 31); +f(1048544, 32); +f(1081311, 33); +f(2064321, 63); +f(2097088, 64); +f(2129855, 65); +f(4161409, 127); +f(4194176, 128); +f(4226943, 129); +f(8355585, 255); +f(8388352, 256); +f(8421119, 257); +f(16743937, 511); +f(16776704, 512); +f(16809471, 513); +f(33520641, 1023); +f(33553408, 1024); +f(33586175, 1025); +f(67074049, 2047); +f(67106816, 2048); +f(67139583, 2049); +f(134180865, 4095); +f(134213632, 4096); +f(134246399, 4097); +f(268394497, 8191); +f(268427264, 8192); +f(268460031, 8193); +f(536821761, 16383); +f(536854528, 16384); +f(536887295, 16385); +f(1073676289, 32767); +x = 32768; +f(0, 0); +f(32768, 1); +f(65536, 2); +f(98304, 3); +f(131072, 4); +f(163840, 5); +f(229376, 7); +f(262144, 8); +f(294912, 9); +f(491520, 15); +f(524288, 16); +f(557056, 17); +f(1015808, 31); +f(1048576, 32); +f(1081344, 33); +f(2064384, 63); +f(2097152, 64); +f(2129920, 65); +f(4161536, 127); +f(4194304, 128); +f(4227072, 129); +f(8355840, 255); +f(8388608, 256); +f(8421376, 257); +f(16744448, 511); +f(16777216, 512); +f(16809984, 513); +f(33521664, 1023); +f(33554432, 1024); +f(33587200, 1025); +f(67076096, 2047); +f(67108864, 2048); +f(67141632, 2049); +f(134184960, 4095); +f(134217728, 4096); +f(134250496, 4097); +f(268402688, 8191); +f(268435456, 8192); +f(268468224, 8193); +f(536838144, 16383); +f(536870912, 16384); +f(536903680, 16385); +f(1073709056, 32767); +f(1073741824, 32768); +x = 32769; +f(0, 0); +f(32769, 1); +f(65538, 2); +f(98307, 3); +f(131076, 4); +f(163845, 5); +f(229383, 7); +f(262152, 8); +f(294921, 9); +f(491535, 15); +f(524304, 16); +f(557073, 17); +f(1015839, 31); +f(1048608, 32); +f(1081377, 33); +f(2064447, 63); +f(2097216, 64); +f(2129985, 65); +f(4161663, 127); +f(4194432, 128); +f(4227201, 129); +f(8356095, 255); +f(8388864, 256); +f(8421633, 257); +f(16744959, 511); +f(16777728, 512); +f(16810497, 513); +f(33522687, 1023); +f(33555456, 1024); +f(33588225, 1025); +f(67078143, 2047); +f(67110912, 2048); +f(67143681, 2049); +f(134189055, 4095); +f(134221824, 4096); +f(134254593, 4097); +f(268410879, 8191); +f(268443648, 8192); +f(268476417, 8193); +f(536854527, 16383); +f(536887296, 16384); +f(536920065, 16385); +f(1073741823, 32767); +f(1073774592, 32768); +f(1073807361, 32769); +x = 65535; +f(0, 0); +f(65535, 1); +f(131070, 2); +f(196605, 3); +f(262140, 4); +f(327675, 5); +f(458745, 7); +f(524280, 8); +f(589815, 9); +f(983025, 15); +f(1048560, 16); +f(1114095, 17); +f(2031585, 31); +f(2097120, 32); +f(2162655, 33); +f(4128705, 63); +f(4194240, 64); +f(4259775, 65); +f(8322945, 127); +f(8388480, 128); +f(8454015, 129); +f(16711425, 255); +f(16776960, 256); +f(16842495, 257); +f(33488385, 511); +f(33553920, 512); +f(33619455, 513); +f(67042305, 1023); +f(67107840, 1024); +f(67173375, 1025); +f(134150145, 2047); +f(134215680, 2048); +f(134281215, 2049); +f(268365825, 4095); +f(268431360, 4096); +f(268496895, 4097); +f(536797185, 8191); +f(536862720, 8192); +f(536928255, 8193); +f(1073659905, 16383); +f(1073725440, 16384); +f(1073790975, 16385); +f(2147385345, 32767); +f(2147450880, 32768); +f(2147516415, 32769); +f(4294836225, 65535); +x = 65536; +f(0, 0); +f(65536, 1); +f(131072, 2); +f(196608, 3); +f(262144, 4); +f(327680, 5); +f(458752, 7); +f(524288, 8); +f(589824, 9); +f(983040, 15); +f(1048576, 16); +f(1114112, 17); +f(2031616, 31); +f(2097152, 32); +f(2162688, 33); +f(4128768, 63); +f(4194304, 64); +f(4259840, 65); +f(8323072, 127); +f(8388608, 128); +f(8454144, 129); +f(16711680, 255); +f(16777216, 256); +f(16842752, 257); +f(33488896, 511); +f(33554432, 512); +f(33619968, 513); +f(67043328, 1023); +f(67108864, 1024); +f(67174400, 1025); +f(134152192, 2047); +f(134217728, 2048); +f(134283264, 2049); +f(268369920, 4095); +f(268435456, 4096); +f(268500992, 4097); +f(536805376, 8191); +f(536870912, 8192); +f(536936448, 8193); +f(1073676288, 16383); +f(1073741824, 16384); +f(1073807360, 16385); +f(2147418112, 32767); +f(2147483648, 32768); +f(2147549184, 32769); +f(4294901760, 65535); +f(4294967296, 65536); +x = 65537; +f(0, 0); +f(65537, 1); +f(131074, 2); +f(196611, 3); +f(262148, 4); +f(327685, 5); +f(458759, 7); +f(524296, 8); +f(589833, 9); +f(983055, 15); +f(1048592, 16); +f(1114129, 17); +f(2031647, 31); +f(2097184, 32); +f(2162721, 33); +f(4128831, 63); +f(4194368, 64); +f(4259905, 65); +f(8323199, 127); +f(8388736, 128); +f(8454273, 129); +f(16711935, 255); +f(16777472, 256); +f(16843009, 257); +f(33489407, 511); +f(33554944, 512); +f(33620481, 513); +f(67044351, 1023); +f(67109888, 1024); +f(67175425, 1025); +f(134154239, 2047); +f(134219776, 2048); +f(134285313, 2049); +f(268374015, 4095); +f(268439552, 4096); +f(268505089, 4097); +f(536813567, 8191); +f(536879104, 8192); +f(536944641, 8193); +f(1073692671, 16383); +f(1073758208, 16384); +f(1073823745, 16385); +f(2147450879, 32767); +f(2147516416, 32768); +f(2147581953, 32769); +f(4294967295, 65535); +f(4295032832, 65536); +f(4295098369, 65537); +x = 131071; +f(0, 0); +f(131071, 1); +f(262142, 2); +f(393213, 3); +f(524284, 4); +f(655355, 5); +f(917497, 7); +f(1048568, 8); +f(1179639, 9); +f(1966065, 15); +f(2097136, 16); +f(2228207, 17); +f(4063201, 31); +f(4194272, 32); +f(4325343, 33); +f(8257473, 63); +f(8388544, 64); +f(8519615, 65); +f(16646017, 127); +f(16777088, 128); +f(16908159, 129); +f(33423105, 255); +f(33554176, 256); +f(33685247, 257); +f(66977281, 511); +f(67108352, 512); +f(67239423, 513); +f(134085633, 1023); +f(134216704, 1024); +f(134347775, 1025); +f(268302337, 2047); +f(268433408, 2048); +f(268564479, 2049); +f(536735745, 4095); +f(536866816, 4096); +f(536997887, 4097); +f(1073602561, 8191); +f(1073733632, 8192); +f(1073864703, 8193); +f(2147336193, 16383); +f(2147467264, 16384); +f(2147598335, 16385); +f(4294803457, 32767); +f(4294934528, 32768); +f(4295065599, 32769); +f(8589737985, 65535); +f(8589869056, 65536); +f(8590000127, 65537); +f(17179607041, 131071); +x = 131072; +f(0, 0); +f(131072, 1); +f(262144, 2); +f(393216, 3); +f(524288, 4); +f(655360, 5); +f(917504, 7); +f(1048576, 8); +f(1179648, 9); +f(1966080, 15); +f(2097152, 16); +f(2228224, 17); +f(4063232, 31); +f(4194304, 32); +f(4325376, 33); +f(8257536, 63); +f(8388608, 64); +f(8519680, 65); +f(16646144, 127); +f(16777216, 128); +f(16908288, 129); +f(33423360, 255); +f(33554432, 256); +f(33685504, 257); +f(66977792, 511); +f(67108864, 512); +f(67239936, 513); +f(134086656, 1023); +f(134217728, 1024); +f(134348800, 1025); +f(268304384, 2047); +f(268435456, 2048); +f(268566528, 2049); +f(536739840, 4095); +f(536870912, 4096); +f(537001984, 4097); +f(1073610752, 8191); +f(1073741824, 8192); +f(1073872896, 8193); +f(2147352576, 16383); +f(2147483648, 16384); +f(2147614720, 16385); +f(4294836224, 32767); +f(4294967296, 32768); +f(4295098368, 32769); +f(8589803520, 65535); +f(8589934592, 65536); +f(8590065664, 65537); +f(17179738112, 131071); +f(17179869184, 131072); +x = 131073; +f(0, 0); +f(131073, 1); +f(262146, 2); +f(393219, 3); +f(524292, 4); +f(655365, 5); +f(917511, 7); +f(1048584, 8); +f(1179657, 9); +f(1966095, 15); +f(2097168, 16); +f(2228241, 17); +f(4063263, 31); +f(4194336, 32); +f(4325409, 33); +f(8257599, 63); +f(8388672, 64); +f(8519745, 65); +f(16646271, 127); +f(16777344, 128); +f(16908417, 129); +f(33423615, 255); +f(33554688, 256); +f(33685761, 257); +f(66978303, 511); +f(67109376, 512); +f(67240449, 513); +f(134087679, 1023); +f(134218752, 1024); +f(134349825, 1025); +f(268306431, 2047); +f(268437504, 2048); +f(268568577, 2049); +f(536743935, 4095); +f(536875008, 4096); +f(537006081, 4097); +f(1073618943, 8191); +f(1073750016, 8192); +f(1073881089, 8193); +f(2147368959, 16383); +f(2147500032, 16384); +f(2147631105, 16385); +f(4294868991, 32767); +f(4295000064, 32768); +f(4295131137, 32769); +f(8589869055, 65535); +f(8590000128, 65536); +f(8590131201, 65537); +f(17179869183, 131071); +f(17180000256, 131072); +f(17180131329, 131073); diff --git a/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part4.js b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part4.js new file mode 100644 index 0000000..de9f983 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part4.js @@ -0,0 +1,509 @@ +// Copyright 2008 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var x; + +// Converts a number to string respecting -0. +function stringify(n) { + if ((1 / n) === -Infinity) return "-0"; + return String(n); +} + +function f(expected, y) { + function testEval(string, x, y) { + var mulFunction = Function("x, y", "return " + string); + return mulFunction(x, y); + } + function mulTest(expected, x, y) { + assertEquals(expected, x * y); + assertEquals(expected, testEval(stringify(x) + " * y", x, y)); + assertEquals(expected, testEval("x * " + stringify(y), x, y)); + assertEquals(expected, testEval(stringify(x) + " * " + stringify(y), x, y)); + } + mulTest(expected, x, y); + mulTest(-expected, -x, y); + mulTest(-expected, x, -y); + mulTest(expected, -x, -y); + if (x === y) return; // Symmetric cases not necessary. + mulTest(expected, y, x); + mulTest(-expected, -y, x); + mulTest(-expected, y, -x); + mulTest(expected, -y, -x); +} + +x = 262143; +f(0, 0); +f(262143, 1); +f(524286, 2); +f(786429, 3); +f(1048572, 4); +f(1310715, 5); +f(1835001, 7); +f(2097144, 8); +f(2359287, 9); +f(3932145, 15); +f(4194288, 16); +f(4456431, 17); +f(8126433, 31); +f(8388576, 32); +f(8650719, 33); +f(16515009, 63); +f(16777152, 64); +f(17039295, 65); +f(33292161, 127); +f(33554304, 128); +f(33816447, 129); +f(66846465, 255); +f(67108608, 256); +f(67370751, 257); +f(133955073, 511); +f(134217216, 512); +f(134479359, 513); +f(268172289, 1023); +f(268434432, 1024); +f(268696575, 1025); +f(536606721, 2047); +f(536868864, 2048); +f(537131007, 2049); +f(1073475585, 4095); +f(1073737728, 4096); +f(1073999871, 4097); +f(2147213313, 8191); +f(2147475456, 8192); +f(2147737599, 8193); +f(4294688769, 16383); +f(4294950912, 16384); +f(4295213055, 16385); +f(8589639681, 32767); +f(8589901824, 32768); +f(8590163967, 32769); +f(17179541505, 65535); +f(17179803648, 65536); +f(17180065791, 65537); +f(34359345153, 131071); +f(34359607296, 131072); +f(34359869439, 131073); +f(68718952449, 262143); +x = 262144; +f(0, 0); +f(262144, 1); +f(524288, 2); +f(786432, 3); +f(1048576, 4); +f(1310720, 5); +f(1835008, 7); +f(2097152, 8); +f(2359296, 9); +f(3932160, 15); +f(4194304, 16); +f(4456448, 17); +f(8126464, 31); +f(8388608, 32); +f(8650752, 33); +f(16515072, 63); +f(16777216, 64); +f(17039360, 65); +f(33292288, 127); +f(33554432, 128); +f(33816576, 129); +f(66846720, 255); +f(67108864, 256); +f(67371008, 257); +f(133955584, 511); +f(134217728, 512); +f(134479872, 513); +f(268173312, 1023); +f(268435456, 1024); +f(268697600, 1025); +f(536608768, 2047); +f(536870912, 2048); +f(537133056, 2049); +f(1073479680, 4095); +f(1073741824, 4096); +f(1074003968, 4097); +f(2147221504, 8191); +f(2147483648, 8192); +f(2147745792, 8193); +f(4294705152, 16383); +f(4294967296, 16384); +f(4295229440, 16385); +f(8589672448, 32767); +f(8589934592, 32768); +f(8590196736, 32769); +f(17179607040, 65535); +f(17179869184, 65536); +f(17180131328, 65537); +f(34359476224, 131071); +f(34359738368, 131072); +f(34360000512, 131073); +f(68719214592, 262143); +f(68719476736, 262144); +x = 262145; +f(0, 0); +f(262145, 1); +f(524290, 2); +f(786435, 3); +f(1048580, 4); +f(1310725, 5); +f(1835015, 7); +f(2097160, 8); +f(2359305, 9); +f(3932175, 15); +f(4194320, 16); +f(4456465, 17); +f(8126495, 31); +f(8388640, 32); +f(8650785, 33); +f(16515135, 63); +f(16777280, 64); +f(17039425, 65); +f(33292415, 127); +f(33554560, 128); +f(33816705, 129); +f(66846975, 255); +f(67109120, 256); +f(67371265, 257); +f(133956095, 511); +f(134218240, 512); +f(134480385, 513); +f(268174335, 1023); +f(268436480, 1024); +f(268698625, 1025); +f(536610815, 2047); +f(536872960, 2048); +f(537135105, 2049); +f(1073483775, 4095); +f(1073745920, 4096); +f(1074008065, 4097); +f(2147229695, 8191); +f(2147491840, 8192); +f(2147753985, 8193); +f(4294721535, 16383); +f(4294983680, 16384); +f(4295245825, 16385); +f(8589705215, 32767); +f(8589967360, 32768); +f(8590229505, 32769); +f(17179672575, 65535); +f(17179934720, 65536); +f(17180196865, 65537); +f(34359607295, 131071); +f(34359869440, 131072); +f(34360131585, 131073); +f(68719476735, 262143); +f(68719738880, 262144); +f(68720001025, 262145); +x = 524287; +f(0, 0); +f(524287, 1); +f(1048574, 2); +f(1572861, 3); +f(2097148, 4); +f(2621435, 5); +f(3670009, 7); +f(4194296, 8); +f(4718583, 9); +f(7864305, 15); +f(8388592, 16); +f(8912879, 17); +f(16252897, 31); +f(16777184, 32); +f(17301471, 33); +f(33030081, 63); +f(33554368, 64); +f(34078655, 65); +f(66584449, 127); +f(67108736, 128); +f(67633023, 129); +f(133693185, 255); +f(134217472, 256); +f(134741759, 257); +f(267910657, 511); +f(268434944, 512); +f(268959231, 513); +f(536345601, 1023); +f(536869888, 1024); +f(537394175, 1025); +f(1073215489, 2047); +f(1073739776, 2048); +f(1074264063, 2049); +f(2146955265, 4095); +f(2147479552, 4096); +f(2148003839, 4097); +f(4294434817, 8191); +f(4294959104, 8192); +f(4295483391, 8193); +f(8589393921, 16383); +f(8589918208, 16384); +f(8590442495, 16385); +f(17179312129, 32767); +f(17179836416, 32768); +f(17180360703, 32769); +f(34359148545, 65535); +f(34359672832, 65536); +f(34360197119, 65537); +f(68718821377, 131071); +f(68719345664, 131072); +f(68719869951, 131073); +f(137438167041, 262143); +f(137438691328, 262144); +f(137439215615, 262145); +f(274876858369, 524287); +x = 524288; +f(0, 0); +f(524288, 1); +f(1048576, 2); +f(1572864, 3); +f(2097152, 4); +f(2621440, 5); +f(3670016, 7); +f(4194304, 8); +f(4718592, 9); +f(7864320, 15); +f(8388608, 16); +f(8912896, 17); +f(16252928, 31); +f(16777216, 32); +f(17301504, 33); +f(33030144, 63); +f(33554432, 64); +f(34078720, 65); +f(66584576, 127); +f(67108864, 128); +f(67633152, 129); +f(133693440, 255); +f(134217728, 256); +f(134742016, 257); +f(267911168, 511); +f(268435456, 512); +f(268959744, 513); +f(536346624, 1023); +f(536870912, 1024); +f(537395200, 1025); +f(1073217536, 2047); +f(1073741824, 2048); +f(1074266112, 2049); +f(2146959360, 4095); +f(2147483648, 4096); +f(2148007936, 4097); +f(4294443008, 8191); +f(4294967296, 8192); +f(4295491584, 8193); +f(8589410304, 16383); +f(8589934592, 16384); +f(8590458880, 16385); +f(17179344896, 32767); +f(17179869184, 32768); +f(17180393472, 32769); +f(34359214080, 65535); +f(34359738368, 65536); +f(34360262656, 65537); +f(68718952448, 131071); +f(68719476736, 131072); +f(68720001024, 131073); +f(137438429184, 262143); +f(137438953472, 262144); +f(137439477760, 262145); +f(274877382656, 524287); +f(274877906944, 524288); +x = 524289; +f(0, 0); +f(524289, 1); +f(1048578, 2); +f(1572867, 3); +f(2097156, 4); +f(2621445, 5); +f(3670023, 7); +f(4194312, 8); +f(4718601, 9); +f(7864335, 15); +f(8388624, 16); +f(8912913, 17); +f(16252959, 31); +f(16777248, 32); +f(17301537, 33); +f(33030207, 63); +f(33554496, 64); +f(34078785, 65); +f(66584703, 127); +f(67108992, 128); +f(67633281, 129); +f(133693695, 255); +f(134217984, 256); +f(134742273, 257); +f(267911679, 511); +f(268435968, 512); +f(268960257, 513); +f(536347647, 1023); +f(536871936, 1024); +f(537396225, 1025); +f(1073219583, 2047); +f(1073743872, 2048); +f(1074268161, 2049); +f(2146963455, 4095); +f(2147487744, 4096); +f(2148012033, 4097); +f(4294451199, 8191); +f(4294975488, 8192); +f(4295499777, 8193); +f(8589426687, 16383); +f(8589950976, 16384); +f(8590475265, 16385); +f(17179377663, 32767); +f(17179901952, 32768); +f(17180426241, 32769); +f(34359279615, 65535); +f(34359803904, 65536); +f(34360328193, 65537); +f(68719083519, 131071); +f(68719607808, 131072); +f(68720132097, 131073); +f(137438691327, 262143); +f(137439215616, 262144); +f(137439739905, 262145); +f(274877906943, 524287); +f(274878431232, 524288); +f(274878955521, 524289); +x = 1048575; +f(0, 0); +f(1048575, 1); +f(2097150, 2); +f(3145725, 3); +f(4194300, 4); +f(5242875, 5); +f(7340025, 7); +f(8388600, 8); +f(9437175, 9); +f(15728625, 15); +f(16777200, 16); +f(17825775, 17); +f(32505825, 31); +f(33554400, 32); +f(34602975, 33); +f(66060225, 63); +f(67108800, 64); +f(68157375, 65); +f(133169025, 127); +f(134217600, 128); +f(135266175, 129); +f(267386625, 255); +f(268435200, 256); +f(269483775, 257); +f(535821825, 511); +f(536870400, 512); +f(537918975, 513); +f(1072692225, 1023); +f(1073740800, 1024); +f(1074789375, 1025); +f(2146433025, 2047); +f(2147481600, 2048); +f(2148530175, 2049); +f(4293914625, 4095); +f(4294963200, 4096); +f(4296011775, 4097); +f(8588877825, 8191); +f(8589926400, 8192); +f(8590974975, 8193); +f(17178804225, 16383); +f(17179852800, 16384); +f(17180901375, 16385); +f(34358657025, 32767); +f(34359705600, 32768); +f(34360754175, 32769); +f(68718362625, 65535); +f(68719411200, 65536); +f(68720459775, 65537); +f(137437773825, 131071); +f(137438822400, 131072); +f(137439870975, 131073); +f(274876596225, 262143); +f(274877644800, 262144); +f(274878693375, 262145); +f(549754241025, 524287); +f(549755289600, 524288); +f(549756338175, 524289); +f(1099509530625, 1048575); +x = 1048576; +f(0, 0); +f(1048576, 1); +f(2097152, 2); +f(3145728, 3); +f(4194304, 4); +f(5242880, 5); +f(7340032, 7); +f(8388608, 8); +f(9437184, 9); +f(15728640, 15); +f(16777216, 16); +f(17825792, 17); +f(32505856, 31); +f(33554432, 32); +f(34603008, 33); +f(66060288, 63); +f(67108864, 64); +f(68157440, 65); +f(133169152, 127); +f(134217728, 128); +f(135266304, 129); +f(267386880, 255); +f(268435456, 256); +f(269484032, 257); +f(535822336, 511); +f(536870912, 512); +f(537919488, 513); +f(1072693248, 1023); +f(1073741824, 1024); +f(1074790400, 1025); +f(2146435072, 2047); +f(2147483648, 2048); +f(2148532224, 2049); +f(4293918720, 4095); +f(4294967296, 4096); +f(4296015872, 4097); +f(8588886016, 8191); +f(8589934592, 8192); +f(8590983168, 8193); +f(17178820608, 16383); +f(17179869184, 16384); +f(17180917760, 16385); +f(34358689792, 32767); +f(34359738368, 32768); +f(34360786944, 32769); +f(68718428160, 65535); +f(68719476736, 65536); +f(68720525312, 65537); +f(137437904896, 131071); +f(137438953472, 131072); +f(137440002048, 131073); +f(274876858368, 262143); +f(274877906944, 262144); +f(274878955520, 262145); +f(549754765312, 524287); +f(549755813888, 524288); +f(549756862464, 524289); +f(1099510579200, 1048575); +f(1099511627776, 1048576); diff --git a/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part5.js b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part5.js new file mode 100644 index 0000000..e929985 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part5.js @@ -0,0 +1,505 @@ +// Copyright 2008 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var x; + +// Converts a number to string respecting -0. +function stringify(n) { + if ((1 / n) === -Infinity) return "-0"; + return String(n); +} + +function f(expected, y) { + function testEval(string, x, y) { + var mulFunction = Function("x, y", "return " + string); + return mulFunction(x, y); + } + function mulTest(expected, x, y) { + assertEquals(expected, x * y); + assertEquals(expected, testEval(stringify(x) + " * y", x, y)); + assertEquals(expected, testEval("x * " + stringify(y), x, y)); + assertEquals(expected, testEval(stringify(x) + " * " + stringify(y), x, y)); + } + mulTest(expected, x, y); + mulTest(-expected, -x, y); + mulTest(-expected, x, -y); + mulTest(expected, -x, -y); + if (x === y) return; // Symmetric cases not necessary. + mulTest(expected, y, x); + mulTest(-expected, -y, x); + mulTest(-expected, y, -x); + mulTest(expected, -y, -x); +} + +x = 1048577; +f(0, 0); +f(1048577, 1); +f(2097154, 2); +f(3145731, 3); +f(4194308, 4); +f(5242885, 5); +f(7340039, 7); +f(8388616, 8); +f(9437193, 9); +f(15728655, 15); +f(16777232, 16); +f(17825809, 17); +f(32505887, 31); +f(33554464, 32); +f(34603041, 33); +f(66060351, 63); +f(67108928, 64); +f(68157505, 65); +f(133169279, 127); +f(134217856, 128); +f(135266433, 129); +f(267387135, 255); +f(268435712, 256); +f(269484289, 257); +f(535822847, 511); +f(536871424, 512); +f(537920001, 513); +f(1072694271, 1023); +f(1073742848, 1024); +f(1074791425, 1025); +f(2146437119, 2047); +f(2147485696, 2048); +f(2148534273, 2049); +f(4293922815, 4095); +f(4294971392, 4096); +f(4296019969, 4097); +f(8588894207, 8191); +f(8589942784, 8192); +f(8590991361, 8193); +f(17178836991, 16383); +f(17179885568, 16384); +f(17180934145, 16385); +f(34358722559, 32767); +f(34359771136, 32768); +f(34360819713, 32769); +f(68718493695, 65535); +f(68719542272, 65536); +f(68720590849, 65537); +f(137438035967, 131071); +f(137439084544, 131072); +f(137440133121, 131073); +f(274877120511, 262143); +f(274878169088, 262144); +f(274879217665, 262145); +f(549755289599, 524287); +f(549756338176, 524288); +f(549757386753, 524289); +f(1099511627775, 1048575); +f(1099512676352, 1048576); +f(1099513724929, 1048577); +x = 2097151; +f(0, 0); +f(2097151, 1); +f(4194302, 2); +f(6291453, 3); +f(8388604, 4); +f(10485755, 5); +f(14680057, 7); +f(16777208, 8); +f(18874359, 9); +f(31457265, 15); +f(33554416, 16); +f(35651567, 17); +f(65011681, 31); +f(67108832, 32); +f(69205983, 33); +f(132120513, 63); +f(134217664, 64); +f(136314815, 65); +f(266338177, 127); +f(268435328, 128); +f(270532479, 129); +f(534773505, 255); +f(536870656, 256); +f(538967807, 257); +f(1071644161, 511); +f(1073741312, 512); +f(1075838463, 513); +f(2145385473, 1023); +f(2147482624, 1024); +f(2149579775, 1025); +f(4292868097, 2047); +f(4294965248, 2048); +f(4297062399, 2049); +f(8587833345, 4095); +f(8589930496, 4096); +f(8592027647, 4097); +f(17177763841, 8191); +f(17179860992, 8192); +f(17181958143, 8193); +f(34357624833, 16383); +f(34359721984, 16384); +f(34361819135, 16385); +f(68717346817, 32767); +f(68719443968, 32768); +f(68721541119, 32769); +f(137436790785, 65535); +f(137438887936, 65536); +f(137440985087, 65537); +f(274875678721, 131071); +f(274877775872, 131072); +f(274879873023, 131073); +f(549753454593, 262143); +f(549755551744, 262144); +f(549757648895, 262145); +f(1099509006337, 524287); +f(1099511103488, 524288); +f(1099513200639, 524289); +f(2199020109825, 1048575); +f(2199022206976, 1048576); +f(2199024304127, 1048577); +f(4398042316801, 2097151); +x = 2097152; +f(0, 0); +f(2097152, 1); +f(4194304, 2); +f(6291456, 3); +f(8388608, 4); +f(10485760, 5); +f(14680064, 7); +f(16777216, 8); +f(18874368, 9); +f(31457280, 15); +f(33554432, 16); +f(35651584, 17); +f(65011712, 31); +f(67108864, 32); +f(69206016, 33); +f(132120576, 63); +f(134217728, 64); +f(136314880, 65); +f(266338304, 127); +f(268435456, 128); +f(270532608, 129); +f(534773760, 255); +f(536870912, 256); +f(538968064, 257); +f(1071644672, 511); +f(1073741824, 512); +f(1075838976, 513); +f(2145386496, 1023); +f(2147483648, 1024); +f(2149580800, 1025); +f(4292870144, 2047); +f(4294967296, 2048); +f(4297064448, 2049); +f(8587837440, 4095); +f(8589934592, 4096); +f(8592031744, 4097); +f(17177772032, 8191); +f(17179869184, 8192); +f(17181966336, 8193); +f(34357641216, 16383); +f(34359738368, 16384); +f(34361835520, 16385); +f(68717379584, 32767); +f(68719476736, 32768); +f(68721573888, 32769); +f(137436856320, 65535); +f(137438953472, 65536); +f(137441050624, 65537); +f(274875809792, 131071); +f(274877906944, 131072); +f(274880004096, 131073); +f(549753716736, 262143); +f(549755813888, 262144); +f(549757911040, 262145); +f(1099509530624, 524287); +f(1099511627776, 524288); +f(1099513724928, 524289); +f(2199021158400, 1048575); +f(2199023255552, 1048576); +f(2199025352704, 1048577); +f(4398044413952, 2097151); +f(4398046511104, 2097152); +x = 2097153; +f(0, 0); +f(2097153, 1); +f(4194306, 2); +f(6291459, 3); +f(8388612, 4); +f(10485765, 5); +f(14680071, 7); +f(16777224, 8); +f(18874377, 9); +f(31457295, 15); +f(33554448, 16); +f(35651601, 17); +f(65011743, 31); +f(67108896, 32); +f(69206049, 33); +f(132120639, 63); +f(134217792, 64); +f(136314945, 65); +f(266338431, 127); +f(268435584, 128); +f(270532737, 129); +f(534774015, 255); +f(536871168, 256); +f(538968321, 257); +f(1071645183, 511); +f(1073742336, 512); +f(1075839489, 513); +f(2145387519, 1023); +f(2147484672, 1024); +f(2149581825, 1025); +f(4292872191, 2047); +f(4294969344, 2048); +f(4297066497, 2049); +f(8587841535, 4095); +f(8589938688, 4096); +f(8592035841, 4097); +f(17177780223, 8191); +f(17179877376, 8192); +f(17181974529, 8193); +f(34357657599, 16383); +f(34359754752, 16384); +f(34361851905, 16385); +f(68717412351, 32767); +f(68719509504, 32768); +f(68721606657, 32769); +f(137436921855, 65535); +f(137439019008, 65536); +f(137441116161, 65537); +f(274875940863, 131071); +f(274878038016, 131072); +f(274880135169, 131073); +f(549753978879, 262143); +f(549756076032, 262144); +f(549758173185, 262145); +f(1099510054911, 524287); +f(1099512152064, 524288); +f(1099514249217, 524289); +f(2199022206975, 1048575); +f(2199024304128, 1048576); +f(2199026401281, 1048577); +f(4398046511103, 2097151); +f(4398048608256, 2097152); +f(4398050705409, 2097153); +x = 4194303; +f(0, 0); +f(4194303, 1); +f(8388606, 2); +f(12582909, 3); +f(16777212, 4); +f(20971515, 5); +f(29360121, 7); +f(33554424, 8); +f(37748727, 9); +f(62914545, 15); +f(67108848, 16); +f(71303151, 17); +f(130023393, 31); +f(134217696, 32); +f(138411999, 33); +f(264241089, 63); +f(268435392, 64); +f(272629695, 65); +f(532676481, 127); +f(536870784, 128); +f(541065087, 129); +f(1069547265, 255); +f(1073741568, 256); +f(1077935871, 257); +f(2143288833, 511); +f(2147483136, 512); +f(2151677439, 513); +f(4290771969, 1023); +f(4294966272, 1024); +f(4299160575, 1025); +f(8585738241, 2047); +f(8589932544, 2048); +f(8594126847, 2049); +f(17175670785, 4095); +f(17179865088, 4096); +f(17184059391, 4097); +f(34355535873, 8191); +f(34359730176, 8192); +f(34363924479, 8193); +f(68715266049, 16383); +f(68719460352, 16384); +f(68723654655, 16385); +f(137434726401, 32767); +f(137438920704, 32768); +f(137443115007, 32769); +f(274873647105, 65535); +f(274877841408, 65536); +f(274882035711, 65537); +f(549751488513, 131071); +f(549755682816, 131072); +f(549759877119, 131073); +f(1099507171329, 262143); +f(1099511365632, 262144); +f(1099515559935, 262145); +f(2199018536961, 524287); +f(2199022731264, 524288); +f(2199026925567, 524289); +f(4398041268225, 1048575); +f(4398045462528, 1048576); +f(4398049656831, 1048577); +f(8796086730753, 2097151); +f(8796090925056, 2097152); +f(8796095119359, 2097153); +f(17592177655809, 4194303); +x = 4194304; +f(0, 0); +f(4194304, 1); +f(8388608, 2); +f(12582912, 3); +f(16777216, 4); +f(20971520, 5); +f(29360128, 7); +f(33554432, 8); +f(37748736, 9); +f(62914560, 15); +f(67108864, 16); +f(71303168, 17); +f(130023424, 31); +f(134217728, 32); +f(138412032, 33); +f(264241152, 63); +f(268435456, 64); +f(272629760, 65); +f(532676608, 127); +f(536870912, 128); +f(541065216, 129); +f(1069547520, 255); +f(1073741824, 256); +f(1077936128, 257); +f(2143289344, 511); +f(2147483648, 512); +f(2151677952, 513); +f(4290772992, 1023); +f(4294967296, 1024); +f(4299161600, 1025); +f(8585740288, 2047); +f(8589934592, 2048); +f(8594128896, 2049); +f(17175674880, 4095); +f(17179869184, 4096); +f(17184063488, 4097); +f(34355544064, 8191); +f(34359738368, 8192); +f(34363932672, 8193); +f(68715282432, 16383); +f(68719476736, 16384); +f(68723671040, 16385); +f(137434759168, 32767); +f(137438953472, 32768); +f(137443147776, 32769); +f(274873712640, 65535); +f(274877906944, 65536); +f(274882101248, 65537); +f(549751619584, 131071); +f(549755813888, 131072); +f(549760008192, 131073); +f(1099507433472, 262143); +f(1099511627776, 262144); +f(1099515822080, 262145); +f(2199019061248, 524287); +f(2199023255552, 524288); +f(2199027449856, 524289); +f(4398042316800, 1048575); +f(4398046511104, 1048576); +f(4398050705408, 1048577); +f(8796088827904, 2097151); +f(8796093022208, 2097152); +f(8796097216512, 2097153); +f(17592181850112, 4194303); +f(17592186044416, 4194304); +x = 4194305; +f(0, 0); +f(4194305, 1); +f(8388610, 2); +f(12582915, 3); +f(16777220, 4); +f(20971525, 5); +f(29360135, 7); +f(33554440, 8); +f(37748745, 9); +f(62914575, 15); +f(67108880, 16); +f(71303185, 17); +f(130023455, 31); +f(134217760, 32); +f(138412065, 33); +f(264241215, 63); +f(268435520, 64); +f(272629825, 65); +f(532676735, 127); +f(536871040, 128); +f(541065345, 129); +f(1069547775, 255); +f(1073742080, 256); +f(1077936385, 257); +f(2143289855, 511); +f(2147484160, 512); +f(2151678465, 513); +f(4290774015, 1023); +f(4294968320, 1024); +f(4299162625, 1025); +f(8585742335, 2047); +f(8589936640, 2048); +f(8594130945, 2049); +f(17175678975, 4095); +f(17179873280, 4096); +f(17184067585, 4097); +f(34355552255, 8191); +f(34359746560, 8192); +f(34363940865, 8193); +f(68715298815, 16383); +f(68719493120, 16384); +f(68723687425, 16385); +f(137434791935, 32767); +f(137438986240, 32768); +f(137443180545, 32769); +f(274873778175, 65535); +f(274877972480, 65536); +f(274882166785, 65537); +f(549751750655, 131071); +f(549755944960, 131072); +f(549760139265, 131073); +f(1099507695615, 262143); +f(1099511889920, 262144); +f(1099516084225, 262145); +f(2199019585535, 524287); +f(2199023779840, 524288); +f(2199027974145, 524289); +f(4398043365375, 1048575); +f(4398047559680, 1048576); +f(4398051753985, 1048577); +f(8796090925055, 2097151); +f(8796095119360, 2097152); +f(8796099313665, 2097153); +f(17592186044415, 4194303); +f(17592190238720, 4194304); +f(17592194433025, 4194305); diff --git a/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part6.js b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part6.js new file mode 100644 index 0000000..91cb798 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part6.js @@ -0,0 +1,554 @@ +// Copyright 2008 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var x; + +// Converts a number to string respecting -0. +function stringify(n) { + if ((1 / n) === -Infinity) return "-0"; + return String(n); +} + +function f(expected, y) { + function testEval(string, x, y) { + var mulFunction = Function("x, y", "return " + string); + return mulFunction(x, y); + } + function mulTest(expected, x, y) { + assertEquals(expected, x * y); + assertEquals(expected, testEval(stringify(x) + " * y", x, y)); + assertEquals(expected, testEval("x * " + stringify(y), x, y)); + assertEquals(expected, testEval(stringify(x) + " * " + stringify(y), x, y)); + } + mulTest(expected, x, y); + mulTest(-expected, -x, y); + mulTest(-expected, x, -y); + mulTest(expected, -x, -y); + if (x === y) return; // Symmetric cases not necessary. + mulTest(expected, y, x); + mulTest(-expected, -y, x); + mulTest(-expected, y, -x); + mulTest(expected, -y, -x); +} + +x = 8388607; +f(0, 0); +f(8388607, 1); +f(16777214, 2); +f(25165821, 3); +f(33554428, 4); +f(41943035, 5); +f(58720249, 7); +f(67108856, 8); +f(75497463, 9); +f(125829105, 15); +f(134217712, 16); +f(142606319, 17); +f(260046817, 31); +f(268435424, 32); +f(276824031, 33); +f(528482241, 63); +f(536870848, 64); +f(545259455, 65); +f(1065353089, 127); +f(1073741696, 128); +f(1082130303, 129); +f(2139094785, 255); +f(2147483392, 256); +f(2155871999, 257); +f(4286578177, 511); +f(4294966784, 512); +f(4303355391, 513); +f(8581544961, 1023); +f(8589933568, 1024); +f(8598322175, 1025); +f(17171478529, 2047); +f(17179867136, 2048); +f(17188255743, 2049); +f(34351345665, 4095); +f(34359734272, 4096); +f(34368122879, 4097); +f(68711079937, 8191); +f(68719468544, 8192); +f(68727857151, 8193); +f(137430548481, 16383); +f(137438937088, 16384); +f(137447325695, 16385); +f(274869485569, 32767); +f(274877874176, 32768); +f(274886262783, 32769); +f(549747359745, 65535); +f(549755748352, 65536); +f(549764136959, 65537); +f(1099503108097, 131071); +f(1099511496704, 131072); +f(1099519885311, 131073); +f(2199014604801, 262143); +f(2199022993408, 262144); +f(2199031382015, 262145); +f(4398037598209, 524287); +f(4398045986816, 524288); +f(4398054375423, 524289); +f(8796083585025, 1048575); +f(8796091973632, 1048576); +f(8796100362239, 1048577); +f(17592175558657, 2097151); +f(17592183947264, 2097152); +f(17592192335871, 2097153); +f(35184359505921, 4194303); +f(35184367894528, 4194304); +f(35184376283135, 4194305); +f(70368727400449, 8388607); +x = 8388608; +f(0, 0); +f(8388608, 1); +f(16777216, 2); +f(25165824, 3); +f(33554432, 4); +f(41943040, 5); +f(58720256, 7); +f(67108864, 8); +f(75497472, 9); +f(125829120, 15); +f(134217728, 16); +f(142606336, 17); +f(260046848, 31); +f(268435456, 32); +f(276824064, 33); +f(528482304, 63); +f(536870912, 64); +f(545259520, 65); +f(1065353216, 127); +f(1073741824, 128); +f(1082130432, 129); +f(2139095040, 255); +f(2147483648, 256); +f(2155872256, 257); +f(4286578688, 511); +f(4294967296, 512); +f(4303355904, 513); +f(8581545984, 1023); +f(8589934592, 1024); +f(8598323200, 1025); +f(17171480576, 2047); +f(17179869184, 2048); +f(17188257792, 2049); +f(34351349760, 4095); +f(34359738368, 4096); +f(34368126976, 4097); +f(68711088128, 8191); +f(68719476736, 8192); +f(68727865344, 8193); +f(137430564864, 16383); +f(137438953472, 16384); +f(137447342080, 16385); +f(274869518336, 32767); +f(274877906944, 32768); +f(274886295552, 32769); +f(549747425280, 65535); +f(549755813888, 65536); +f(549764202496, 65537); +f(1099503239168, 131071); +f(1099511627776, 131072); +f(1099520016384, 131073); +f(2199014866944, 262143); +f(2199023255552, 262144); +f(2199031644160, 262145); +f(4398038122496, 524287); +f(4398046511104, 524288); +f(4398054899712, 524289); +f(8796084633600, 1048575); +f(8796093022208, 1048576); +f(8796101410816, 1048577); +f(17592177655808, 2097151); +f(17592186044416, 2097152); +f(17592194433024, 2097153); +f(35184363700224, 4194303); +f(35184372088832, 4194304); +f(35184380477440, 4194305); +f(70368735789056, 8388607); +f(70368744177664, 8388608); +x = 8388609; +f(0, 0); +f(8388609, 1); +f(16777218, 2); +f(25165827, 3); +f(33554436, 4); +f(41943045, 5); +f(58720263, 7); +f(67108872, 8); +f(75497481, 9); +f(125829135, 15); +f(134217744, 16); +f(142606353, 17); +f(260046879, 31); +f(268435488, 32); +f(276824097, 33); +f(528482367, 63); +f(536870976, 64); +f(545259585, 65); +f(1065353343, 127); +f(1073741952, 128); +f(1082130561, 129); +f(2139095295, 255); +f(2147483904, 256); +f(2155872513, 257); +f(4286579199, 511); +f(4294967808, 512); +f(4303356417, 513); +f(8581547007, 1023); +f(8589935616, 1024); +f(8598324225, 1025); +f(17171482623, 2047); +f(17179871232, 2048); +f(17188259841, 2049); +f(34351353855, 4095); +f(34359742464, 4096); +f(34368131073, 4097); +f(68711096319, 8191); +f(68719484928, 8192); +f(68727873537, 8193); +f(137430581247, 16383); +f(137438969856, 16384); +f(137447358465, 16385); +f(274869551103, 32767); +f(274877939712, 32768); +f(274886328321, 32769); +f(549747490815, 65535); +f(549755879424, 65536); +f(549764268033, 65537); +f(1099503370239, 131071); +f(1099511758848, 131072); +f(1099520147457, 131073); +f(2199015129087, 262143); +f(2199023517696, 262144); +f(2199031906305, 262145); +f(4398038646783, 524287); +f(4398047035392, 524288); +f(4398055424001, 524289); +f(8796085682175, 1048575); +f(8796094070784, 1048576); +f(8796102459393, 1048577); +f(17592179752959, 2097151); +f(17592188141568, 2097152); +f(17592196530177, 2097153); +f(35184367894527, 4194303); +f(35184376283136, 4194304); +f(35184384671745, 4194305); +f(70368744177663, 8388607); +f(70368752566272, 8388608); +f(70368760954881, 8388609); +x = 16777215; +f(0, 0); +f(16777215, 1); +f(33554430, 2); +f(50331645, 3); +f(67108860, 4); +f(83886075, 5); +f(117440505, 7); +f(134217720, 8); +f(150994935, 9); +f(251658225, 15); +f(268435440, 16); +f(285212655, 17); +f(520093665, 31); +f(536870880, 32); +f(553648095, 33); +f(1056964545, 63); +f(1073741760, 64); +f(1090518975, 65); +f(2130706305, 127); +f(2147483520, 128); +f(2164260735, 129); +f(4278189825, 255); +f(4294967040, 256); +f(4311744255, 257); +f(8573156865, 511); +f(8589934080, 512); +f(8606711295, 513); +f(17163090945, 1023); +f(17179868160, 1024); +f(17196645375, 1025); +f(34342959105, 2047); +f(34359736320, 2048); +f(34376513535, 2049); +f(68702695425, 4095); +f(68719472640, 4096); +f(68736249855, 4097); +f(137422168065, 8191); +f(137438945280, 8192); +f(137455722495, 8193); +f(274861113345, 16383); +f(274877890560, 16384); +f(274894667775, 16385); +f(549739003905, 32767); +f(549755781120, 32768); +f(549772558335, 32769); +f(1099494785025, 65535); +f(1099511562240, 65536); +f(1099528339455, 65537); +f(2199006347265, 131071); +f(2199023124480, 131072); +f(2199039901695, 131073); +f(4398029471745, 262143); +f(4398046248960, 262144); +f(4398063026175, 262145); +f(8796075720705, 524287); +f(8796092497920, 524288); +f(8796109275135, 524289); +f(17592168218625, 1048575); +f(17592184995840, 1048576); +f(17592201773055, 1048577); +f(35184353214465, 2097151); +f(35184369991680, 2097152); +f(35184386768895, 2097153); +f(70368723206145, 4194303); +f(70368739983360, 4194304); +f(70368756760575, 4194305); +f(140737463189505, 8388607); +f(140737479966720, 8388608); +f(140737496743935, 8388609); +f(281474943156225, 16777215); +x = 16777216; +f(0, 0); +f(16777216, 1); +f(33554432, 2); +f(50331648, 3); +f(67108864, 4); +f(83886080, 5); +f(117440512, 7); +f(134217728, 8); +f(150994944, 9); +f(251658240, 15); +f(268435456, 16); +f(285212672, 17); +f(520093696, 31); +f(536870912, 32); +f(553648128, 33); +f(1056964608, 63); +f(1073741824, 64); +f(1090519040, 65); +f(2130706432, 127); +f(2147483648, 128); +f(2164260864, 129); +f(4278190080, 255); +f(4294967296, 256); +f(4311744512, 257); +f(8573157376, 511); +f(8589934592, 512); +f(8606711808, 513); +f(17163091968, 1023); +f(17179869184, 1024); +f(17196646400, 1025); +f(34342961152, 2047); +f(34359738368, 2048); +f(34376515584, 2049); +f(68702699520, 4095); +f(68719476736, 4096); +f(68736253952, 4097); +f(137422176256, 8191); +f(137438953472, 8192); +f(137455730688, 8193); +f(274861129728, 16383); +f(274877906944, 16384); +f(274894684160, 16385); +f(549739036672, 32767); +f(549755813888, 32768); +f(549772591104, 32769); +f(1099494850560, 65535); +f(1099511627776, 65536); +f(1099528404992, 65537); +f(2199006478336, 131071); +f(2199023255552, 131072); +f(2199040032768, 131073); +f(4398029733888, 262143); +f(4398046511104, 262144); +f(4398063288320, 262145); +f(8796076244992, 524287); +f(8796093022208, 524288); +f(8796109799424, 524289); +f(17592169267200, 1048575); +f(17592186044416, 1048576); +f(17592202821632, 1048577); +f(35184355311616, 2097151); +f(35184372088832, 2097152); +f(35184388866048, 2097153); +f(70368727400448, 4194303); +f(70368744177664, 4194304); +f(70368760954880, 4194305); +f(140737471578112, 8388607); +f(140737488355328, 8388608); +f(140737505132544, 8388609); +f(281474959933440, 16777215); +f(281474976710656, 16777216); +x = 16777217; +f(0, 0); +f(16777217, 1); +f(33554434, 2); +f(50331651, 3); +f(67108868, 4); +f(83886085, 5); +f(117440519, 7); +f(134217736, 8); +f(150994953, 9); +f(251658255, 15); +f(268435472, 16); +f(285212689, 17); +f(520093727, 31); +f(536870944, 32); +f(553648161, 33); +f(1056964671, 63); +f(1073741888, 64); +f(1090519105, 65); +f(2130706559, 127); +f(2147483776, 128); +f(2164260993, 129); +f(4278190335, 255); +f(4294967552, 256); +f(4311744769, 257); +f(8573157887, 511); +f(8589935104, 512); +f(8606712321, 513); +f(17163092991, 1023); +f(17179870208, 1024); +f(17196647425, 1025); +f(34342963199, 2047); +f(34359740416, 2048); +f(34376517633, 2049); +f(68702703615, 4095); +f(68719480832, 4096); +f(68736258049, 4097); +f(137422184447, 8191); +f(137438961664, 8192); +f(137455738881, 8193); +f(274861146111, 16383); +f(274877923328, 16384); +f(274894700545, 16385); +f(549739069439, 32767); +f(549755846656, 32768); +f(549772623873, 32769); +f(1099494916095, 65535); +f(1099511693312, 65536); +f(1099528470529, 65537); +f(2199006609407, 131071); +f(2199023386624, 131072); +f(2199040163841, 131073); +f(4398029996031, 262143); +f(4398046773248, 262144); +f(4398063550465, 262145); +f(8796076769279, 524287); +f(8796093546496, 524288); +f(8796110323713, 524289); +f(17592170315775, 1048575); +f(17592187092992, 1048576); +f(17592203870209, 1048577); +f(35184357408767, 2097151); +f(35184374185984, 2097152); +f(35184390963201, 2097153); +f(70368731594751, 4194303); +f(70368748371968, 4194304); +f(70368765149185, 4194305); +f(140737479966719, 8388607); +f(140737496743936, 8388608); +f(140737513521153, 8388609); +f(281474976710655, 16777215); +f(281474993487872, 16777216); +f(281475010265089, 16777217); +x = 33554431; +f(0, 0); +f(33554431, 1); +f(67108862, 2); +f(100663293, 3); +f(134217724, 4); +f(167772155, 5); +f(234881017, 7); +f(268435448, 8); +f(301989879, 9); +f(503316465, 15); +f(536870896, 16); +f(570425327, 17); +f(1040187361, 31); +f(1073741792, 32); +f(1107296223, 33); +f(2113929153, 63); +f(2147483584, 64); +f(2181038015, 65); +f(4261412737, 127); +f(4294967168, 128); +f(4328521599, 129); +f(8556379905, 255); +f(8589934336, 256); +f(8623488767, 257); +f(17146314241, 511); +f(17179868672, 512); +f(17213423103, 513); +f(34326182913, 1023); +f(34359737344, 1024); +f(34393291775, 1025); +f(68685920257, 2047); +f(68719474688, 2048); +f(68753029119, 2049); +f(137405394945, 4095); +f(137438949376, 4096); +f(137472503807, 4097); +f(274844344321, 8191); +f(274877898752, 8192); +f(274911453183, 8193); +f(549722243073, 16383); +f(549755797504, 16384); +f(549789351935, 16385); +f(1099478040577, 32767); +f(1099511595008, 32768); +f(1099545149439, 32769); +f(2198989635585, 65535); +f(2199023190016, 65536); +f(2199056744447, 65537); +f(4398012825601, 131071); +f(4398046380032, 131072); +f(4398079934463, 131073); +f(8796059205633, 262143); +f(8796092760064, 262144); +f(8796126314495, 262145); +f(17592151965697, 524287); +f(17592185520128, 524288); +f(17592219074559, 524289); +f(35184337485825, 1048575); +f(35184371040256, 1048576); +f(35184404594687, 1048577); +f(70368708526081, 2097151); +f(70368742080512, 2097152); +f(70368775634943, 2097153); +f(140737450606593, 4194303); +f(140737484161024, 4194304); +f(140737517715455, 4194305); +f(281474934767617, 8388607); +f(281474968322048, 8388608); +f(281475001876479, 8388609); +f(562949903089665, 16777215); +f(562949936644096, 16777216); +f(562949970198527, 16777217); +f(1125899839733761, 33554431);
\ No newline at end of file diff --git a/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part7.js b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part7.js new file mode 100644 index 0000000..d517225 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part7.js @@ -0,0 +1,497 @@ +// Copyright 2008 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var x; + +// Converts a number to string respecting -0. +function stringify(n) { + if ((1 / n) === -Infinity) return "-0"; + return String(n); +} + +function f(expected, y) { + function testEval(string, x, y) { + var mulFunction = Function("x, y", "return " + string); + return mulFunction(x, y); + } + function mulTest(expected, x, y) { + assertEquals(expected, x * y); + assertEquals(expected, testEval(stringify(x) + " * y", x, y)); + assertEquals(expected, testEval("x * " + stringify(y), x, y)); + assertEquals(expected, testEval(stringify(x) + " * " + stringify(y), x, y)); + } + mulTest(expected, x, y); + mulTest(-expected, -x, y); + mulTest(-expected, x, -y); + mulTest(expected, -x, -y); + if (x === y) return; // Symmetric cases not necessary. + mulTest(expected, y, x); + mulTest(-expected, -y, x); + mulTest(-expected, y, -x); + mulTest(expected, -y, -x); +} + +x = 33554432; +f(0, 0); +f(33554432, 1); +f(67108864, 2); +f(100663296, 3); +f(134217728, 4); +f(167772160, 5); +f(234881024, 7); +f(268435456, 8); +f(301989888, 9); +f(503316480, 15); +f(536870912, 16); +f(570425344, 17); +f(1040187392, 31); +f(1073741824, 32); +f(1107296256, 33); +f(2113929216, 63); +f(2147483648, 64); +f(2181038080, 65); +f(4261412864, 127); +f(4294967296, 128); +f(4328521728, 129); +f(8556380160, 255); +f(8589934592, 256); +f(8623489024, 257); +f(17146314752, 511); +f(17179869184, 512); +f(17213423616, 513); +f(34326183936, 1023); +f(34359738368, 1024); +f(34393292800, 1025); +f(68685922304, 2047); +f(68719476736, 2048); +f(68753031168, 2049); +f(137405399040, 4095); +f(137438953472, 4096); +f(137472507904, 4097); +f(274844352512, 8191); +f(274877906944, 8192); +f(274911461376, 8193); +f(549722259456, 16383); +f(549755813888, 16384); +f(549789368320, 16385); +f(1099478073344, 32767); +f(1099511627776, 32768); +f(1099545182208, 32769); +f(2198989701120, 65535); +f(2199023255552, 65536); +f(2199056809984, 65537); +f(4398012956672, 131071); +f(4398046511104, 131072); +f(4398080065536, 131073); +f(8796059467776, 262143); +f(8796093022208, 262144); +f(8796126576640, 262145); +f(17592152489984, 524287); +f(17592186044416, 524288); +f(17592219598848, 524289); +f(35184338534400, 1048575); +f(35184372088832, 1048576); +f(35184405643264, 1048577); +f(70368710623232, 2097151); +f(70368744177664, 2097152); +f(70368777732096, 2097153); +f(140737454800896, 4194303); +f(140737488355328, 4194304); +f(140737521909760, 4194305); +f(281474943156224, 8388607); +f(281474976710656, 8388608); +f(281475010265088, 8388609); +f(562949919866880, 16777215); +f(562949953421312, 16777216); +f(562949986975744, 16777217); +f(1125899873288192, 33554431); +f(1125899906842624, 33554432); +x = 33554433; +f(0, 0); +f(33554433, 1); +f(67108866, 2); +f(100663299, 3); +f(134217732, 4); +f(167772165, 5); +f(234881031, 7); +f(268435464, 8); +f(301989897, 9); +f(503316495, 15); +f(536870928, 16); +f(570425361, 17); +f(1040187423, 31); +f(1073741856, 32); +f(1107296289, 33); +f(2113929279, 63); +f(2147483712, 64); +f(2181038145, 65); +f(4261412991, 127); +f(4294967424, 128); +f(4328521857, 129); +f(8556380415, 255); +f(8589934848, 256); +f(8623489281, 257); +f(17146315263, 511); +f(17179869696, 512); +f(17213424129, 513); +f(34326184959, 1023); +f(34359739392, 1024); +f(34393293825, 1025); +f(68685924351, 2047); +f(68719478784, 2048); +f(68753033217, 2049); +f(137405403135, 4095); +f(137438957568, 4096); +f(137472512001, 4097); +f(274844360703, 8191); +f(274877915136, 8192); +f(274911469569, 8193); +f(549722275839, 16383); +f(549755830272, 16384); +f(549789384705, 16385); +f(1099478106111, 32767); +f(1099511660544, 32768); +f(1099545214977, 32769); +f(2198989766655, 65535); +f(2199023321088, 65536); +f(2199056875521, 65537); +f(4398013087743, 131071); +f(4398046642176, 131072); +f(4398080196609, 131073); +f(8796059729919, 262143); +f(8796093284352, 262144); +f(8796126838785, 262145); +f(17592153014271, 524287); +f(17592186568704, 524288); +f(17592220123137, 524289); +f(35184339582975, 1048575); +f(35184373137408, 1048576); +f(35184406691841, 1048577); +f(70368712720383, 2097151); +f(70368746274816, 2097152); +f(70368779829249, 2097153); +f(140737458995199, 4194303); +f(140737492549632, 4194304); +f(140737526104065, 4194305); +f(281474951544831, 8388607); +f(281474985099264, 8388608); +f(281475018653697, 8388609); +f(562949936644095, 16777215); +f(562949970198528, 16777216); +f(562950003752961, 16777217); +f(1125899906842623, 33554431); +f(1125899940397056, 33554432); +f(1125899973951489, 33554433); +x = 67108863; +f(0, 0); +f(67108863, 1); +f(134217726, 2); +f(201326589, 3); +f(268435452, 4); +f(335544315, 5); +f(469762041, 7); +f(536870904, 8); +f(603979767, 9); +f(1006632945, 15); +f(1073741808, 16); +f(1140850671, 17); +f(2080374753, 31); +f(2147483616, 32); +f(2214592479, 33); +f(4227858369, 63); +f(4294967232, 64); +f(4362076095, 65); +f(8522825601, 127); +f(8589934464, 128); +f(8657043327, 129); +f(17112760065, 255); +f(17179868928, 256); +f(17246977791, 257); +f(34292628993, 511); +f(34359737856, 512); +f(34426846719, 513); +f(68652366849, 1023); +f(68719475712, 1024); +f(68786584575, 1025); +f(137371842561, 2047); +f(137438951424, 2048); +f(137506060287, 2049); +f(274810793985, 4095); +f(274877902848, 4096); +f(274945011711, 4097); +f(549688696833, 8191); +f(549755805696, 8192); +f(549822914559, 8193); +f(1099444502529, 16383); +f(1099511611392, 16384); +f(1099578720255, 16385); +f(2198956113921, 32767); +f(2199023222784, 32768); +f(2199090331647, 32769); +f(4397979336705, 65535); +f(4398046445568, 65536); +f(4398113554431, 65537); +f(8796025782273, 131071); +f(8796092891136, 131072); +f(8796159999999, 131073); +f(17592118673409, 262143); +f(17592185782272, 262144); +f(17592252891135, 262145); +f(35184304455681, 524287); +f(35184371564544, 524288); +f(35184438673407, 524289); +f(70368676020225, 1048575); +f(70368743129088, 1048576); +f(70368810237951, 1048577); +f(140737419149313, 2097151); +f(140737486258176, 2097152); +f(140737553367039, 2097153); +f(281474905407489, 4194303); +f(281474972516352, 4194304); +f(281475039625215, 4194305); +f(562949877923841, 8388607); +f(562949945032704, 8388608); +f(562950012141567, 8388609); +f(1125899822956545, 16777215); +f(1125899890065408, 16777216); +f(1125899957174271, 16777217); +x = 67108864; +f(0, 0); +f(67108864, 1); +f(134217728, 2); +f(201326592, 3); +f(268435456, 4); +f(335544320, 5); +f(469762048, 7); +f(536870912, 8); +f(603979776, 9); +f(1006632960, 15); +f(1073741824, 16); +f(1140850688, 17); +f(2080374784, 31); +f(2147483648, 32); +f(2214592512, 33); +f(4227858432, 63); +f(4294967296, 64); +f(4362076160, 65); +f(8522825728, 127); +f(8589934592, 128); +f(8657043456, 129); +f(17112760320, 255); +f(17179869184, 256); +f(17246978048, 257); +f(34292629504, 511); +f(34359738368, 512); +f(34426847232, 513); +f(68652367872, 1023); +f(68719476736, 1024); +f(68786585600, 1025); +f(137371844608, 2047); +f(137438953472, 2048); +f(137506062336, 2049); +f(274810798080, 4095); +f(274877906944, 4096); +f(274945015808, 4097); +f(549688705024, 8191); +f(549755813888, 8192); +f(549822922752, 8193); +f(1099444518912, 16383); +f(1099511627776, 16384); +f(1099578736640, 16385); +f(2198956146688, 32767); +f(2199023255552, 32768); +f(2199090364416, 32769); +f(4397979402240, 65535); +f(4398046511104, 65536); +f(4398113619968, 65537); +f(8796025913344, 131071); +f(8796093022208, 131072); +f(8796160131072, 131073); +f(17592118935552, 262143); +f(17592186044416, 262144); +f(17592253153280, 262145); +f(35184304979968, 524287); +f(35184372088832, 524288); +f(35184439197696, 524289); +f(70368677068800, 1048575); +f(70368744177664, 1048576); +f(70368811286528, 1048577); +f(140737421246464, 2097151); +f(140737488355328, 2097152); +f(140737555464192, 2097153); +f(281474909601792, 4194303); +f(281474976710656, 4194304); +f(281475043819520, 4194305); +f(562949886312448, 8388607); +f(562949953421312, 8388608); +f(562950020530176, 8388609); +f(1125899839733760, 16777215); +f(1125899906842624, 16777216); +f(1125899973951488, 16777217); +x = 67108865; +f(0, 0); +f(67108865, 1); +f(134217730, 2); +f(201326595, 3); +f(268435460, 4); +f(335544325, 5); +f(469762055, 7); +f(536870920, 8); +f(603979785, 9); +f(1006632975, 15); +f(1073741840, 16); +f(1140850705, 17); +f(2080374815, 31); +f(2147483680, 32); +f(2214592545, 33); +f(4227858495, 63); +f(4294967360, 64); +f(4362076225, 65); +f(8522825855, 127); +f(8589934720, 128); +f(8657043585, 129); +f(17112760575, 255); +f(17179869440, 256); +f(17246978305, 257); +f(34292630015, 511); +f(34359738880, 512); +f(34426847745, 513); +f(68652368895, 1023); +f(68719477760, 1024); +f(68786586625, 1025); +f(137371846655, 2047); +f(137438955520, 2048); +f(137506064385, 2049); +f(274810802175, 4095); +f(274877911040, 4096); +f(274945019905, 4097); +f(549688713215, 8191); +f(549755822080, 8192); +f(549822930945, 8193); +f(1099444535295, 16383); +f(1099511644160, 16384); +f(1099578753025, 16385); +f(2198956179455, 32767); +f(2199023288320, 32768); +f(2199090397185, 32769); +f(4397979467775, 65535); +f(4398046576640, 65536); +f(4398113685505, 65537); +f(8796026044415, 131071); +f(8796093153280, 131072); +f(8796160262145, 131073); +f(17592119197695, 262143); +f(17592186306560, 262144); +f(17592253415425, 262145); +f(35184305504255, 524287); +f(35184372613120, 524288); +f(35184439721985, 524289); +f(70368678117375, 1048575); +f(70368745226240, 1048576); +f(70368812335105, 1048577); +f(140737423343615, 2097151); +f(140737490452480, 2097152); +f(140737557561345, 2097153); +f(281474913796095, 4194303); +f(281474980904960, 4194304); +f(281475048013825, 4194305); +f(562949894701055, 8388607); +f(562949961809920, 8388608); +f(562950028918785, 8388609); +f(1125899856510975, 16777215); +f(1125899923619840, 16777216); +f(1125899990728705, 16777217); +x = 134217727; +f(0, 0); +f(134217727, 1); +f(268435454, 2); +f(402653181, 3); +f(536870908, 4); +f(671088635, 5); +f(939524089, 7); +f(1073741816, 8); +f(1207959543, 9); +f(2013265905, 15); +f(2147483632, 16); +f(2281701359, 17); +f(4160749537, 31); +f(4294967264, 32); +f(4429184991, 33); +f(8455716801, 63); +f(8589934528, 64); +f(8724152255, 65); +f(17045651329, 127); +f(17179869056, 128); +f(17314086783, 129); +f(34225520385, 255); +f(34359738112, 256); +f(34493955839, 257); +f(68585258497, 511); +f(68719476224, 512); +f(68853693951, 513); +f(137304734721, 1023); +f(137438952448, 1024); +f(137573170175, 1025); +f(274743687169, 2047); +f(274877904896, 2048); +f(275012122623, 2049); +f(549621592065, 4095); +f(549755809792, 4096); +f(549890027519, 4097); +f(1099377401857, 8191); +f(1099511619584, 8192); +f(1099645837311, 8193); +f(2198889021441, 16383); +f(2199023239168, 16384); +f(2199157456895, 16385); +f(4397912260609, 32767); +f(4398046478336, 32768); +f(4398180696063, 32769); +f(8795958738945, 65535); +f(8796092956672, 65536); +f(8796227174399, 65537); +f(17592051695617, 131071); +f(17592185913344, 131072); +f(17592320131071, 131073); +f(35184237608961, 262143); +f(35184371826688, 262144); +f(35184506044415, 262145); +f(70368609435649, 524287); +f(70368743653376, 524288); +f(70368877871103, 524289); +f(140737353089025, 1048575); +f(140737487306752, 1048576); +f(140737621524479, 1048577); +f(281474840395777, 2097151); +f(281474974613504, 2097152); +f(281475108831231, 2097153); +f(562949815009281, 4194303); +f(562949949227008, 4194304); +f(562950083444735, 4194305); +f(1125899764236289, 8388607); +f(1125899898454016, 8388608); +f(1125900032671743, 8388609); diff --git a/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part8.js b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part8.js new file mode 100644 index 0000000..7e5f285 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part8.js @@ -0,0 +1,526 @@ +// Copyright 2008 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var x; + +// Converts a number to string respecting -0. +function stringify(n) { + if ((1 / n) === -Infinity) return "-0"; + return String(n); +} + +function f(expected, y) { + function testEval(string, x, y) { + var mulFunction = Function("x, y", "return " + string); + return mulFunction(x, y); + } + function mulTest(expected, x, y) { + assertEquals(expected, x * y); + assertEquals(expected, testEval(stringify(x) + " * y", x, y)); + assertEquals(expected, testEval("x * " + stringify(y), x, y)); + assertEquals(expected, testEval(stringify(x) + " * " + stringify(y), x, y)); + } + mulTest(expected, x, y); + mulTest(-expected, -x, y); + mulTest(-expected, x, -y); + mulTest(expected, -x, -y); + if (x === y) return; // Symmetric cases not necessary. + mulTest(expected, y, x); + mulTest(-expected, -y, x); + mulTest(-expected, y, -x); + mulTest(expected, -y, -x); +} + +x = 134217728; +f(0, 0); +f(134217728, 1); +f(268435456, 2); +f(402653184, 3); +f(536870912, 4); +f(671088640, 5); +f(939524096, 7); +f(1073741824, 8); +f(1207959552, 9); +f(2013265920, 15); +f(2147483648, 16); +f(2281701376, 17); +f(4160749568, 31); +f(4294967296, 32); +f(4429185024, 33); +f(8455716864, 63); +f(8589934592, 64); +f(8724152320, 65); +f(17045651456, 127); +f(17179869184, 128); +f(17314086912, 129); +f(34225520640, 255); +f(34359738368, 256); +f(34493956096, 257); +f(68585259008, 511); +f(68719476736, 512); +f(68853694464, 513); +f(137304735744, 1023); +f(137438953472, 1024); +f(137573171200, 1025); +f(274743689216, 2047); +f(274877906944, 2048); +f(275012124672, 2049); +f(549621596160, 4095); +f(549755813888, 4096); +f(549890031616, 4097); +f(1099377410048, 8191); +f(1099511627776, 8192); +f(1099645845504, 8193); +f(2198889037824, 16383); +f(2199023255552, 16384); +f(2199157473280, 16385); +f(4397912293376, 32767); +f(4398046511104, 32768); +f(4398180728832, 32769); +f(8795958804480, 65535); +f(8796093022208, 65536); +f(8796227239936, 65537); +f(17592051826688, 131071); +f(17592186044416, 131072); +f(17592320262144, 131073); +f(35184237871104, 262143); +f(35184372088832, 262144); +f(35184506306560, 262145); +f(70368609959936, 524287); +f(70368744177664, 524288); +f(70368878395392, 524289); +f(140737354137600, 1048575); +f(140737488355328, 1048576); +f(140737622573056, 1048577); +f(281474842492928, 2097151); +f(281474976710656, 2097152); +f(281475110928384, 2097153); +f(562949819203584, 4194303); +f(562949953421312, 4194304); +f(562950087639040, 4194305); +f(1125899772624896, 8388607); +f(1125899906842624, 8388608); +f(1125900041060352, 8388609); +x = 134217729; +f(0, 0); +f(134217729, 1); +f(268435458, 2); +f(402653187, 3); +f(536870916, 4); +f(671088645, 5); +f(939524103, 7); +f(1073741832, 8); +f(1207959561, 9); +f(2013265935, 15); +f(2147483664, 16); +f(2281701393, 17); +f(4160749599, 31); +f(4294967328, 32); +f(4429185057, 33); +f(8455716927, 63); +f(8589934656, 64); +f(8724152385, 65); +f(17045651583, 127); +f(17179869312, 128); +f(17314087041, 129); +f(34225520895, 255); +f(34359738624, 256); +f(34493956353, 257); +f(68585259519, 511); +f(68719477248, 512); +f(68853694977, 513); +f(137304736767, 1023); +f(137438954496, 1024); +f(137573172225, 1025); +f(274743691263, 2047); +f(274877908992, 2048); +f(275012126721, 2049); +f(549621600255, 4095); +f(549755817984, 4096); +f(549890035713, 4097); +f(1099377418239, 8191); +f(1099511635968, 8192); +f(1099645853697, 8193); +f(2198889054207, 16383); +f(2199023271936, 16384); +f(2199157489665, 16385); +f(4397912326143, 32767); +f(4398046543872, 32768); +f(4398180761601, 32769); +f(8795958870015, 65535); +f(8796093087744, 65536); +f(8796227305473, 65537); +f(17592051957759, 131071); +f(17592186175488, 131072); +f(17592320393217, 131073); +f(35184238133247, 262143); +f(35184372350976, 262144); +f(35184506568705, 262145); +f(70368610484223, 524287); +f(70368744701952, 524288); +f(70368878919681, 524289); +f(140737355186175, 1048575); +f(140737489403904, 1048576); +f(140737623621633, 1048577); +f(281474844590079, 2097151); +f(281474978807808, 2097152); +f(281475113025537, 2097153); +f(562949823397887, 4194303); +f(562949957615616, 4194304); +f(562950091833345, 4194305); +f(1125899781013503, 8388607); +f(1125899915231232, 8388608); +f(1125900049448961, 8388609); +x = 268435455; +f(0, 0); +f(268435455, 1); +f(536870910, 2); +f(805306365, 3); +f(1073741820, 4); +f(1342177275, 5); +f(1879048185, 7); +f(2147483640, 8); +f(2415919095, 9); +f(4026531825, 15); +f(4294967280, 16); +f(4563402735, 17); +f(8321499105, 31); +f(8589934560, 32); +f(8858370015, 33); +f(16911433665, 63); +f(17179869120, 64); +f(17448304575, 65); +f(34091302785, 127); +f(34359738240, 128); +f(34628173695, 129); +f(68451041025, 255); +f(68719476480, 256); +f(68987911935, 257); +f(137170517505, 511); +f(137438952960, 512); +f(137707388415, 513); +f(274609470465, 1023); +f(274877905920, 1024); +f(275146341375, 1025); +f(549487376385, 2047); +f(549755811840, 2048); +f(550024247295, 2049); +f(1099243188225, 4095); +f(1099511623680, 4096); +f(1099780059135, 4097); +f(2198754811905, 8191); +f(2199023247360, 8192); +f(2199291682815, 8193); +f(4397778059265, 16383); +f(4398046494720, 16384); +f(4398314930175, 16385); +f(8795824553985, 32767); +f(8796092989440, 32768); +f(8796361424895, 32769); +f(17591917543425, 65535); +f(17592185978880, 65536); +f(17592454414335, 65537); +f(35184103522305, 131071); +f(35184371957760, 131072); +f(35184640393215, 131073); +f(70368475480065, 262143); +f(70368743915520, 262144); +f(70369012350975, 262145); +f(140737219395585, 524287); +f(140737487831040, 524288); +f(140737756266495, 524289); +f(281474707226625, 1048575); +f(281474975662080, 1048576); +f(281475244097535, 1048577); +f(562949682888705, 2097151); +f(562949951324160, 2097152); +f(562950219759615, 2097153); +f(1125899634212865, 4194303); +f(1125899902648320, 4194304); +f(1125900171083775, 4194305); +x = 268435456; +f(0, 0); +f(268435456, 1); +f(536870912, 2); +f(805306368, 3); +f(1073741824, 4); +f(1342177280, 5); +f(1879048192, 7); +f(2147483648, 8); +f(2415919104, 9); +f(4026531840, 15); +f(4294967296, 16); +f(4563402752, 17); +f(8321499136, 31); +f(8589934592, 32); +f(8858370048, 33); +f(16911433728, 63); +f(17179869184, 64); +f(17448304640, 65); +f(34091302912, 127); +f(34359738368, 128); +f(34628173824, 129); +f(68451041280, 255); +f(68719476736, 256); +f(68987912192, 257); +f(137170518016, 511); +f(137438953472, 512); +f(137707388928, 513); +f(274609471488, 1023); +f(274877906944, 1024); +f(275146342400, 1025); +f(549487378432, 2047); +f(549755813888, 2048); +f(550024249344, 2049); +f(1099243192320, 4095); +f(1099511627776, 4096); +f(1099780063232, 4097); +f(2198754820096, 8191); +f(2199023255552, 8192); +f(2199291691008, 8193); +f(4397778075648, 16383); +f(4398046511104, 16384); +f(4398314946560, 16385); +f(8795824586752, 32767); +f(8796093022208, 32768); +f(8796361457664, 32769); +f(17591917608960, 65535); +f(17592186044416, 65536); +f(17592454479872, 65537); +f(35184103653376, 131071); +f(35184372088832, 131072); +f(35184640524288, 131073); +f(70368475742208, 262143); +f(70368744177664, 262144); +f(70369012613120, 262145); +f(140737219919872, 524287); +f(140737488355328, 524288); +f(140737756790784, 524289); +f(281474708275200, 1048575); +f(281474976710656, 1048576); +f(281475245146112, 1048577); +f(562949684985856, 2097151); +f(562949953421312, 2097152); +f(562950221856768, 2097153); +f(1125899638407168, 4194303); +f(1125899906842624, 4194304); +f(1125900175278080, 4194305); +x = 268435457; +f(0, 0); +f(268435457, 1); +f(536870914, 2); +f(805306371, 3); +f(1073741828, 4); +f(1342177285, 5); +f(1879048199, 7); +f(2147483656, 8); +f(2415919113, 9); +f(4026531855, 15); +f(4294967312, 16); +f(4563402769, 17); +f(8321499167, 31); +f(8589934624, 32); +f(8858370081, 33); +f(16911433791, 63); +f(17179869248, 64); +f(17448304705, 65); +f(34091303039, 127); +f(34359738496, 128); +f(34628173953, 129); +f(68451041535, 255); +f(68719476992, 256); +f(68987912449, 257); +f(137170518527, 511); +f(137438953984, 512); +f(137707389441, 513); +f(274609472511, 1023); +f(274877907968, 1024); +f(275146343425, 1025); +f(549487380479, 2047); +f(549755815936, 2048); +f(550024251393, 2049); +f(1099243196415, 4095); +f(1099511631872, 4096); +f(1099780067329, 4097); +f(2198754828287, 8191); +f(2199023263744, 8192); +f(2199291699201, 8193); +f(4397778092031, 16383); +f(4398046527488, 16384); +f(4398314962945, 16385); +f(8795824619519, 32767); +f(8796093054976, 32768); +f(8796361490433, 32769); +f(17591917674495, 65535); +f(17592186109952, 65536); +f(17592454545409, 65537); +f(35184103784447, 131071); +f(35184372219904, 131072); +f(35184640655361, 131073); +f(70368476004351, 262143); +f(70368744439808, 262144); +f(70369012875265, 262145); +f(140737220444159, 524287); +f(140737488879616, 524288); +f(140737757315073, 524289); +f(281474709323775, 1048575); +f(281474977759232, 1048576); +f(281475246194689, 1048577); +f(562949687083007, 2097151); +f(562949955518464, 2097152); +f(562950223953921, 2097153); +f(1125899642601471, 4194303); +f(1125899911036928, 4194304); +f(1125900179472385, 4194305); +x = 536870911; +f(0, 0); +f(536870911, 1); +f(1073741822, 2); +f(1610612733, 3); +f(2147483644, 4); +f(2684354555, 5); +f(3758096377, 7); +f(4294967288, 8); +f(4831838199, 9); +f(8053063665, 15); +f(8589934576, 16); +f(9126805487, 17); +f(16642998241, 31); +f(17179869152, 32); +f(17716740063, 33); +f(33822867393, 63); +f(34359738304, 64); +f(34896609215, 65); +f(68182605697, 127); +f(68719476608, 128); +f(69256347519, 129); +f(136902082305, 255); +f(137438953216, 256); +f(137975824127, 257); +f(274341035521, 511); +f(274877906432, 512); +f(275414777343, 513); +f(549218941953, 1023); +f(549755812864, 1024); +f(550292683775, 1025); +f(1098974754817, 2047); +f(1099511625728, 2048); +f(1100048496639, 2049); +f(2198486380545, 4095); +f(2199023251456, 4096); +f(2199560122367, 4097); +f(4397509632001, 8191); +f(4398046502912, 8192); +f(4398583373823, 8193); +f(8795556134913, 16383); +f(8796093005824, 16384); +f(8796629876735, 16385); +f(17591649140737, 32767); +f(17592186011648, 32768); +f(17592722882559, 32769); +f(35183835152385, 65535); +f(35184372023296, 65536); +f(35184908894207, 65537); +f(70368207175681, 131071); +f(70368744046592, 131072); +f(70369280917503, 131073); +f(140736951222273, 262143); +f(140737488093184, 262144); +f(140738024964095, 262145); +f(281474439315457, 524287); +f(281474976186368, 524288); +f(281475513057279, 524289); +f(562949415501825, 1048575); +f(562949952372736, 1048576); +f(562950489243647, 1048577); +f(1125899367874561, 2097151); +f(1125899904745472, 2097152); +f(1125900441616383, 2097153); +x = 536870912; +f(0, 0); +f(536870912, 1); +f(1073741824, 2); +f(1610612736, 3); +f(2147483648, 4); +f(2684354560, 5); +f(3758096384, 7); +f(4294967296, 8); +f(4831838208, 9); +f(8053063680, 15); +f(8589934592, 16); +f(9126805504, 17); +f(16642998272, 31); +f(17179869184, 32); +f(17716740096, 33); +f(33822867456, 63); +f(34359738368, 64); +f(34896609280, 65); +f(68182605824, 127); +f(68719476736, 128); +f(69256347648, 129); +f(136902082560, 255); +f(137438953472, 256); +f(137975824384, 257); +f(274341036032, 511); +f(274877906944, 512); +f(275414777856, 513); +f(549218942976, 1023); +f(549755813888, 1024); +f(550292684800, 1025); +f(1098974756864, 2047); +f(1099511627776, 2048); +f(1100048498688, 2049); +f(2198486384640, 4095); +f(2199023255552, 4096); +f(2199560126464, 4097); +f(4397509640192, 8191); +f(4398046511104, 8192); +f(4398583382016, 8193); +f(8795556151296, 16383); +f(8796093022208, 16384); +f(8796629893120, 16385); +f(17591649173504, 32767); +f(17592186044416, 32768); +f(17592722915328, 32769); +f(35183835217920, 65535); +f(35184372088832, 65536); +f(35184908959744, 65537); +f(70368207306752, 131071); +f(70368744177664, 131072); +f(70369281048576, 131073); +f(140736951484416, 262143); +f(140737488355328, 262144); +f(140738025226240, 262145); +f(281474439839744, 524287); +f(281474976710656, 524288); +f(281475513581568, 524289); +f(562949416550400, 1048575); +f(562949953421312, 1048576); +f(562950490292224, 1048577); +f(1125899369971712, 2097151); +f(1125899906842624, 2097152); +f(1125900443713536, 2097153); diff --git a/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part9.js b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part9.js new file mode 100644 index 0000000..f329a5a --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/mul-exhaustive-part9.js @@ -0,0 +1,533 @@ +// Copyright 2008 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var x; + +// Converts a number to string respecting -0. +function stringify(n) { + if ((1 / n) === -Infinity) return "-0"; + return String(n); +} + +function f(expected, y) { + function testEval(string, x, y) { + var mulFunction = Function("x, y", "return " + string); + return mulFunction(x, y); + } + function mulTest(expected, x, y) { + assertEquals(expected, x * y); + assertEquals(expected, testEval(stringify(x) + " * y", x, y)); + assertEquals(expected, testEval("x * " + stringify(y), x, y)); + assertEquals(expected, testEval(stringify(x) + " * " + stringify(y), x, y)); + } + mulTest(expected, x, y); + mulTest(-expected, -x, y); + mulTest(-expected, x, -y); + mulTest(expected, -x, -y); + if (x === y) return; // Symmetric cases not necessary. + mulTest(expected, y, x); + mulTest(-expected, -y, x); + mulTest(-expected, y, -x); + mulTest(expected, -y, -x); +} + +x = 536870913; +f(0, 0); +f(536870913, 1); +f(1073741826, 2); +f(1610612739, 3); +f(2147483652, 4); +f(2684354565, 5); +f(3758096391, 7); +f(4294967304, 8); +f(4831838217, 9); +f(8053063695, 15); +f(8589934608, 16); +f(9126805521, 17); +f(16642998303, 31); +f(17179869216, 32); +f(17716740129, 33); +f(33822867519, 63); +f(34359738432, 64); +f(34896609345, 65); +f(68182605951, 127); +f(68719476864, 128); +f(69256347777, 129); +f(136902082815, 255); +f(137438953728, 256); +f(137975824641, 257); +f(274341036543, 511); +f(274877907456, 512); +f(275414778369, 513); +f(549218943999, 1023); +f(549755814912, 1024); +f(550292685825, 1025); +f(1098974758911, 2047); +f(1099511629824, 2048); +f(1100048500737, 2049); +f(2198486388735, 4095); +f(2199023259648, 4096); +f(2199560130561, 4097); +f(4397509648383, 8191); +f(4398046519296, 8192); +f(4398583390209, 8193); +f(8795556167679, 16383); +f(8796093038592, 16384); +f(8796629909505, 16385); +f(17591649206271, 32767); +f(17592186077184, 32768); +f(17592722948097, 32769); +f(35183835283455, 65535); +f(35184372154368, 65536); +f(35184909025281, 65537); +f(70368207437823, 131071); +f(70368744308736, 131072); +f(70369281179649, 131073); +f(140736951746559, 262143); +f(140737488617472, 262144); +f(140738025488385, 262145); +f(281474440364031, 524287); +f(281474977234944, 524288); +f(281475514105857, 524289); +f(562949417598975, 1048575); +f(562949954469888, 1048576); +f(562950491340801, 1048577); +f(1125899372068863, 2097151); +f(1125899908939776, 2097152); +f(1125900445810689, 2097153); +x = 1073741823; +f(0, 0); +f(1073741823, 1); +f(2147483646, 2); +f(3221225469, 3); +f(4294967292, 4); +f(5368709115, 5); +f(7516192761, 7); +f(8589934584, 8); +f(9663676407, 9); +f(16106127345, 15); +f(17179869168, 16); +f(18253610991, 17); +f(33285996513, 31); +f(34359738336, 32); +f(35433480159, 33); +f(67645734849, 63); +f(68719476672, 64); +f(69793218495, 65); +f(136365211521, 127); +f(137438953344, 128); +f(138512695167, 129); +f(273804164865, 255); +f(274877906688, 256); +f(275951648511, 257); +f(548682071553, 511); +f(549755813376, 512); +f(550829555199, 513); +f(1098437884929, 1023); +f(1099511626752, 1024); +f(1100585368575, 1025); +f(2197949511681, 2047); +f(2199023253504, 2048); +f(2200096995327, 2049); +f(4396972765185, 4095); +f(4398046507008, 4096); +f(4399120248831, 4097); +f(8795019272193, 8191); +f(8796093014016, 8192); +f(8797166755839, 8193); +f(17591112286209, 16383); +f(17592186028032, 16384); +f(17593259769855, 16385); +f(35183298314241, 32767); +f(35184372056064, 32768); +f(35185445797887, 32769); +f(70367670370305, 65535); +f(70368744112128, 65536); +f(70369817853951, 65537); +f(140736414482433, 131071); +f(140737488224256, 131072); +f(140738561966079, 131073); +f(281473902706689, 262143); +f(281474976448512, 262144); +f(281476050190335, 262145); +f(562948879155201, 524287); +f(562949952897024, 524288); +f(562951026638847, 524289); +f(1125898832052225, 1048575); +f(1125899905794048, 1048576); +f(1125900979535871, 1048577); +x = 1073741824; +f(0, 0); +f(1073741824, 1); +f(2147483648, 2); +f(3221225472, 3); +f(4294967296, 4); +f(5368709120, 5); +f(7516192768, 7); +f(8589934592, 8); +f(9663676416, 9); +f(16106127360, 15); +f(17179869184, 16); +f(18253611008, 17); +f(33285996544, 31); +f(34359738368, 32); +f(35433480192, 33); +f(67645734912, 63); +f(68719476736, 64); +f(69793218560, 65); +f(136365211648, 127); +f(137438953472, 128); +f(138512695296, 129); +f(273804165120, 255); +f(274877906944, 256); +f(275951648768, 257); +f(548682072064, 511); +f(549755813888, 512); +f(550829555712, 513); +f(1098437885952, 1023); +f(1099511627776, 1024); +f(1100585369600, 1025); +f(2197949513728, 2047); +f(2199023255552, 2048); +f(2200096997376, 2049); +f(4396972769280, 4095); +f(4398046511104, 4096); +f(4399120252928, 4097); +f(8795019280384, 8191); +f(8796093022208, 8192); +f(8797166764032, 8193); +f(17591112302592, 16383); +f(17592186044416, 16384); +f(17593259786240, 16385); +f(35183298347008, 32767); +f(35184372088832, 32768); +f(35185445830656, 32769); +f(70367670435840, 65535); +f(70368744177664, 65536); +f(70369817919488, 65537); +f(140736414613504, 131071); +f(140737488355328, 131072); +f(140738562097152, 131073); +f(281473902968832, 262143); +f(281474976710656, 262144); +f(281476050452480, 262145); +f(562948879679488, 524287); +f(562949953421312, 524288); +f(562951027163136, 524289); +f(1125898833100800, 1048575); +f(1125899906842624, 1048576); +f(1125900980584448, 1048577); +x = 1073741825; +f(0, 0); +f(1073741825, 1); +f(2147483650, 2); +f(3221225475, 3); +f(4294967300, 4); +f(5368709125, 5); +f(7516192775, 7); +f(8589934600, 8); +f(9663676425, 9); +f(16106127375, 15); +f(17179869200, 16); +f(18253611025, 17); +f(33285996575, 31); +f(34359738400, 32); +f(35433480225, 33); +f(67645734975, 63); +f(68719476800, 64); +f(69793218625, 65); +f(136365211775, 127); +f(137438953600, 128); +f(138512695425, 129); +f(273804165375, 255); +f(274877907200, 256); +f(275951649025, 257); +f(548682072575, 511); +f(549755814400, 512); +f(550829556225, 513); +f(1098437886975, 1023); +f(1099511628800, 1024); +f(1100585370625, 1025); +f(2197949515775, 2047); +f(2199023257600, 2048); +f(2200096999425, 2049); +f(4396972773375, 4095); +f(4398046515200, 4096); +f(4399120257025, 4097); +f(8795019288575, 8191); +f(8796093030400, 8192); +f(8797166772225, 8193); +f(17591112318975, 16383); +f(17592186060800, 16384); +f(17593259802625, 16385); +f(35183298379775, 32767); +f(35184372121600, 32768); +f(35185445863425, 32769); +f(70367670501375, 65535); +f(70368744243200, 65536); +f(70369817985025, 65537); +f(140736414744575, 131071); +f(140737488486400, 131072); +f(140738562228225, 131073); +f(281473903230975, 262143); +f(281474976972800, 262144); +f(281476050714625, 262145); +f(562948880203775, 524287); +f(562949953945600, 524288); +f(562951027687425, 524289); +f(1125898834149375, 1048575); +f(1125899907891200, 1048576); +f(1125900981633025, 1048577); +x = 2147483647; +f(0, 0); +f(2147483647, 1); +f(4294967294, 2); +f(6442450941, 3); +f(8589934588, 4); +f(10737418235, 5); +f(15032385529, 7); +f(17179869176, 8); +f(19327352823, 9); +f(32212254705, 15); +f(34359738352, 16); +f(36507221999, 17); +f(66571993057, 31); +f(68719476704, 32); +f(70866960351, 33); +f(135291469761, 63); +f(137438953408, 64); +f(139586437055, 65); +f(272730423169, 127); +f(274877906816, 128); +f(277025390463, 129); +f(547608329985, 255); +f(549755813632, 256); +f(551903297279, 257); +f(1097364143617, 511); +f(1099511627264, 512); +f(1101659110911, 513); +f(2196875770881, 1023); +f(2199023254528, 1024); +f(2201170738175, 1025); +f(4395899025409, 2047); +f(4398046509056, 2048); +f(4400193992703, 2049); +f(8793945534465, 4095); +f(8796093018112, 4096); +f(8798240501759, 4097); +f(17590038552577, 8191); +f(17592186036224, 8192); +f(17594333519871, 8193); +f(35182224588801, 16383); +f(35184372072448, 16384); +f(35186519556095, 16385); +f(70366596661249, 32767); +f(70368744144896, 32768); +f(70370891628543, 32769); +f(140735340806145, 65535); +f(140737488289792, 65536); +f(140739635773439, 65537); +f(281472829095937, 131071); +f(281474976579584, 131072); +f(281477124063231, 131073); +f(562947805675521, 262143); +f(562949953159168, 262144); +f(562952100642815, 262145); +f(1125897758834689, 524287); +f(1125899906318336, 524288); +f(1125902053801983, 524289); +x = 2147483648; +f(0, 0); +f(2147483648, 1); +f(4294967296, 2); +f(6442450944, 3); +f(8589934592, 4); +f(10737418240, 5); +f(15032385536, 7); +f(17179869184, 8); +f(19327352832, 9); +f(32212254720, 15); +f(34359738368, 16); +f(36507222016, 17); +f(66571993088, 31); +f(68719476736, 32); +f(70866960384, 33); +f(135291469824, 63); +f(137438953472, 64); +f(139586437120, 65); +f(272730423296, 127); +f(274877906944, 128); +f(277025390592, 129); +f(547608330240, 255); +f(549755813888, 256); +f(551903297536, 257); +f(1097364144128, 511); +f(1099511627776, 512); +f(1101659111424, 513); +f(2196875771904, 1023); +f(2199023255552, 1024); +f(2201170739200, 1025); +f(4395899027456, 2047); +f(4398046511104, 2048); +f(4400193994752, 2049); +f(8793945538560, 4095); +f(8796093022208, 4096); +f(8798240505856, 4097); +f(17590038560768, 8191); +f(17592186044416, 8192); +f(17594333528064, 8193); +f(35182224605184, 16383); +f(35184372088832, 16384); +f(35186519572480, 16385); +f(70366596694016, 32767); +f(70368744177664, 32768); +f(70370891661312, 32769); +f(140735340871680, 65535); +f(140737488355328, 65536); +f(140739635838976, 65537); +f(281472829227008, 131071); +f(281474976710656, 131072); +f(281477124194304, 131073); +f(562947805937664, 262143); +f(562949953421312, 262144); +f(562952100904960, 262145); +f(1125897759358976, 524287); +f(1125899906842624, 524288); +f(1125902054326272, 524289); +x = 2147483649; +f(0, 0); +f(2147483649, 1); +f(4294967298, 2); +f(6442450947, 3); +f(8589934596, 4); +f(10737418245, 5); +f(15032385543, 7); +f(17179869192, 8); +f(19327352841, 9); +f(32212254735, 15); +f(34359738384, 16); +f(36507222033, 17); +f(66571993119, 31); +f(68719476768, 32); +f(70866960417, 33); +f(135291469887, 63); +f(137438953536, 64); +f(139586437185, 65); +f(272730423423, 127); +f(274877907072, 128); +f(277025390721, 129); +f(547608330495, 255); +f(549755814144, 256); +f(551903297793, 257); +f(1097364144639, 511); +f(1099511628288, 512); +f(1101659111937, 513); +f(2196875772927, 1023); +f(2199023256576, 1024); +f(2201170740225, 1025); +f(4395899029503, 2047); +f(4398046513152, 2048); +f(4400193996801, 2049); +f(8793945542655, 4095); +f(8796093026304, 4096); +f(8798240509953, 4097); +f(17590038568959, 8191); +f(17592186052608, 8192); +f(17594333536257, 8193); +f(35182224621567, 16383); +f(35184372105216, 16384); +f(35186519588865, 16385); +f(70366596726783, 32767); +f(70368744210432, 32768); +f(70370891694081, 32769); +f(140735340937215, 65535); +f(140737488420864, 65536); +f(140739635904513, 65537); +f(281472829358079, 131071); +f(281474976841728, 131072); +f(281477124325377, 131073); +f(562947806199807, 262143); +f(562949953683456, 262144); +f(562952101167105, 262145); +f(1125897759883263, 524287); +f(1125899907366912, 524288); +f(1125902054850561, 524289); +x = 4294967295; +f(0, 0); +f(4294967295, 1); +f(8589934590, 2); +f(12884901885, 3); +f(17179869180, 4); +f(21474836475, 5); +f(30064771065, 7); +f(34359738360, 8); +f(38654705655, 9); +f(64424509425, 15); +f(68719476720, 16); +f(73014444015, 17); +f(133143986145, 31); +f(137438953440, 32); +f(141733920735, 33); +f(270582939585, 63); +f(274877906880, 64); +f(279172874175, 65); +f(545460846465, 127); +f(549755813760, 128); +f(554050781055, 129); +f(1095216660225, 255); +f(1099511627520, 256); +f(1103806594815, 257); +f(2194728287745, 511); +f(2199023255040, 512); +f(2203318222335, 513); +f(4393751542785, 1023); +f(4398046510080, 1024); +f(4402341477375, 1025); +f(8791798052865, 2047); +f(8796093020160, 2048); +f(8800387987455, 2049); +f(17587891073025, 4095); +f(17592186040320, 4096); +f(17596481007615, 4097); +f(35180077113345, 8191); +f(35184372080640, 8192); +f(35188667047935, 8193); +f(70364449193985, 16383); +f(70368744161280, 16384); +f(70373039128575, 16385); +f(140733193355265, 32767); +f(140737488322560, 32768); +f(140741783289855, 32769); +f(281470681677825, 65535); +f(281474976645120, 65536); +f(281479271612415, 65537); +f(562945658322945, 131071); +f(562949953290240, 131072); +f(562954248257535, 131073); +f(1125895611613185, 262143); +f(1125899906580480, 262144); +f(1125904201547775, 262145); diff --git a/src/3rdparty/v8/test/mjsunit/mul-exhaustive.js b/src/3rdparty/v8/test/mjsunit/mul-exhaustive.js deleted file mode 100644 index 12689db..0000000 --- a/src/3rdparty/v8/test/mjsunit/mul-exhaustive.js +++ /dev/null @@ -1,4629 +0,0 @@ -// Copyright 2008 the V8 project authors. All rights reserved. -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following -// disclaimer in the documentation and/or other materials provided -// with the distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived -// from this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -var x; - -// Converts a number to string respecting -0. -function stringify(n) { - if ((1 / n) === -Infinity) return "-0"; - return String(n); -} - -function f(expected, y) { - function testEval(string, x, y) { - var mulFunction = Function("x, y", "return " + string); - return mulFunction(x, y); - } - function mulTest(expected, x, y) { - assertEquals(expected, x * y); - assertEquals(expected, testEval(stringify(x) + " * y", x, y)); - assertEquals(expected, testEval("x * " + stringify(y), x, y)); - assertEquals(expected, testEval(stringify(x) + " * " + stringify(y), x, y)); - } - mulTest(expected, x, y); - mulTest(-expected, -x, y); - mulTest(-expected, x, -y); - mulTest(expected, -x, -y); - if (x === y) return; // Symmetric cases not necessary. - mulTest(expected, y, x); - mulTest(-expected, -y, x); - mulTest(-expected, y, -x); - mulTest(expected, -y, -x); -} - -x = 0; -f(0, 0); -x = 1; -f(0, 0); -f(1, 1); -x = 2; -f(0, 0); -f(2, 1); -f(4, 2); -x = 3; -f(0, 0); -f(3, 1); -f(6, 2); -f(9, 3); -x = 4; -f(0, 0); -f(4, 1); -f(8, 2); -f(12, 3); -f(16, 4); -x = 5; -f(0, 0); -f(5, 1); -f(10, 2); -f(15, 3); -f(20, 4); -f(25, 5); -x = 7; -f(0, 0); -f(7, 1); -f(14, 2); -f(21, 3); -f(28, 4); -f(35, 5); -f(49, 7); -x = 8; -f(0, 0); -f(8, 1); -f(16, 2); -f(24, 3); -f(32, 4); -f(40, 5); -f(56, 7); -f(64, 8); -x = 9; -f(0, 0); -f(9, 1); -f(18, 2); -f(27, 3); -f(36, 4); -f(45, 5); -f(63, 7); -f(72, 8); -f(81, 9); -x = 15; -f(0, 0); -f(15, 1); -f(30, 2); -f(45, 3); -f(60, 4); -f(75, 5); -f(105, 7); -f(120, 8); -f(135, 9); -f(225, 15); -x = 16; -f(0, 0); -f(16, 1); -f(32, 2); -f(48, 3); -f(64, 4); -f(80, 5); -f(112, 7); -f(128, 8); -f(144, 9); -f(240, 15); -f(256, 16); -x = 17; -f(0, 0); -f(17, 1); -f(34, 2); -f(51, 3); -f(68, 4); -f(85, 5); -f(119, 7); -f(136, 8); -f(153, 9); -f(255, 15); -f(272, 16); -f(289, 17); -x = 31; -f(0, 0); -f(31, 1); -f(62, 2); -f(93, 3); -f(124, 4); -f(155, 5); -f(217, 7); -f(248, 8); -f(279, 9); -f(465, 15); -f(496, 16); -f(527, 17); -f(961, 31); -x = 32; -f(0, 0); -f(32, 1); -f(64, 2); -f(96, 3); -f(128, 4); -f(160, 5); -f(224, 7); -f(256, 8); -f(288, 9); -f(480, 15); -f(512, 16); -f(544, 17); -f(992, 31); -f(1024, 32); -x = 33; -f(0, 0); -f(33, 1); -f(66, 2); -f(99, 3); -f(132, 4); -f(165, 5); -f(231, 7); -f(264, 8); -f(297, 9); -f(495, 15); -f(528, 16); -f(561, 17); -f(1023, 31); -f(1056, 32); -f(1089, 33); -x = 63; -f(0, 0); -f(63, 1); -f(126, 2); -f(189, 3); -f(252, 4); -f(315, 5); -f(441, 7); -f(504, 8); -f(567, 9); -f(945, 15); -f(1008, 16); -f(1071, 17); -f(1953, 31); -f(2016, 32); -f(2079, 33); -f(3969, 63); -x = 64; -f(0, 0); -f(64, 1); -f(128, 2); -f(192, 3); -f(256, 4); -f(320, 5); -f(448, 7); -f(512, 8); -f(576, 9); -f(960, 15); -f(1024, 16); -f(1088, 17); -f(1984, 31); -f(2048, 32); -f(2112, 33); -f(4032, 63); -f(4096, 64); -x = 65; -f(0, 0); -f(65, 1); -f(130, 2); -f(195, 3); -f(260, 4); -f(325, 5); -f(455, 7); -f(520, 8); -f(585, 9); -f(975, 15); -f(1040, 16); -f(1105, 17); -f(2015, 31); -f(2080, 32); -f(2145, 33); -f(4095, 63); -f(4160, 64); -f(4225, 65); -x = 127; -f(0, 0); -f(127, 1); -f(254, 2); -f(381, 3); -f(508, 4); -f(635, 5); -f(889, 7); -f(1016, 8); -f(1143, 9); -f(1905, 15); -f(2032, 16); -f(2159, 17); -f(3937, 31); -f(4064, 32); -f(4191, 33); -f(8001, 63); -f(8128, 64); -f(8255, 65); -f(16129, 127); -x = 128; -f(0, 0); -f(128, 1); -f(256, 2); -f(384, 3); -f(512, 4); -f(640, 5); -f(896, 7); -f(1024, 8); -f(1152, 9); -f(1920, 15); -f(2048, 16); -f(2176, 17); -f(3968, 31); -f(4096, 32); -f(4224, 33); -f(8064, 63); -f(8192, 64); -f(8320, 65); -f(16256, 127); -f(16384, 128); -x = 129; -f(0, 0); -f(129, 1); -f(258, 2); -f(387, 3); -f(516, 4); -f(645, 5); -f(903, 7); -f(1032, 8); -f(1161, 9); -f(1935, 15); -f(2064, 16); -f(2193, 17); -f(3999, 31); -f(4128, 32); -f(4257, 33); -f(8127, 63); -f(8256, 64); -f(8385, 65); -f(16383, 127); -f(16512, 128); -f(16641, 129); -x = 255; -f(0, 0); -f(255, 1); -f(510, 2); -f(765, 3); -f(1020, 4); -f(1275, 5); -f(1785, 7); -f(2040, 8); -f(2295, 9); -f(3825, 15); -f(4080, 16); -f(4335, 17); -f(7905, 31); -f(8160, 32); -f(8415, 33); -f(16065, 63); -f(16320, 64); -f(16575, 65); -f(32385, 127); -f(32640, 128); -f(32895, 129); -f(65025, 255); -x = 256; -f(0, 0); -f(256, 1); -f(512, 2); -f(768, 3); -f(1024, 4); -f(1280, 5); -f(1792, 7); -f(2048, 8); -f(2304, 9); -f(3840, 15); -f(4096, 16); -f(4352, 17); -f(7936, 31); -f(8192, 32); -f(8448, 33); -f(16128, 63); -f(16384, 64); -f(16640, 65); -f(32512, 127); -f(32768, 128); -f(33024, 129); -f(65280, 255); -f(65536, 256); -x = 257; -f(0, 0); -f(257, 1); -f(514, 2); -f(771, 3); -f(1028, 4); -f(1285, 5); -f(1799, 7); -f(2056, 8); -f(2313, 9); -f(3855, 15); -f(4112, 16); -f(4369, 17); -f(7967, 31); -f(8224, 32); -f(8481, 33); -f(16191, 63); -f(16448, 64); -f(16705, 65); -f(32639, 127); -f(32896, 128); -f(33153, 129); -f(65535, 255); -f(65792, 256); -f(66049, 257); -x = 511; -f(0, 0); -f(511, 1); -f(1022, 2); -f(1533, 3); -f(2044, 4); -f(2555, 5); -f(3577, 7); -f(4088, 8); -f(4599, 9); -f(7665, 15); -f(8176, 16); -f(8687, 17); -f(15841, 31); -f(16352, 32); -f(16863, 33); -f(32193, 63); -f(32704, 64); -f(33215, 65); -f(64897, 127); -f(65408, 128); -f(65919, 129); -f(130305, 255); -f(130816, 256); -f(131327, 257); -f(261121, 511); -x = 512; -f(0, 0); -f(512, 1); -f(1024, 2); -f(1536, 3); -f(2048, 4); -f(2560, 5); -f(3584, 7); -f(4096, 8); -f(4608, 9); -f(7680, 15); -f(8192, 16); -f(8704, 17); -f(15872, 31); -f(16384, 32); -f(16896, 33); -f(32256, 63); -f(32768, 64); -f(33280, 65); -f(65024, 127); -f(65536, 128); -f(66048, 129); -f(130560, 255); -f(131072, 256); -f(131584, 257); -f(261632, 511); -f(262144, 512); -x = 513; -f(0, 0); -f(513, 1); -f(1026, 2); -f(1539, 3); -f(2052, 4); -f(2565, 5); -f(3591, 7); -f(4104, 8); -f(4617, 9); -f(7695, 15); -f(8208, 16); -f(8721, 17); -f(15903, 31); -f(16416, 32); -f(16929, 33); -f(32319, 63); -f(32832, 64); -f(33345, 65); -f(65151, 127); -f(65664, 128); -f(66177, 129); -f(130815, 255); -f(131328, 256); -f(131841, 257); -f(262143, 511); -f(262656, 512); -f(263169, 513); -x = 1023; -f(0, 0); -f(1023, 1); -f(2046, 2); -f(3069, 3); -f(4092, 4); -f(5115, 5); -f(7161, 7); -f(8184, 8); -f(9207, 9); -f(15345, 15); -f(16368, 16); -f(17391, 17); -f(31713, 31); -f(32736, 32); -f(33759, 33); -f(64449, 63); -f(65472, 64); -f(66495, 65); -f(129921, 127); -f(130944, 128); -f(131967, 129); -f(260865, 255); -f(261888, 256); -f(262911, 257); -f(522753, 511); -f(523776, 512); -f(524799, 513); -f(1046529, 1023); -x = 1024; -f(0, 0); -f(1024, 1); -f(2048, 2); -f(3072, 3); -f(4096, 4); -f(5120, 5); -f(7168, 7); -f(8192, 8); -f(9216, 9); -f(15360, 15); -f(16384, 16); -f(17408, 17); -f(31744, 31); -f(32768, 32); -f(33792, 33); -f(64512, 63); -f(65536, 64); -f(66560, 65); -f(130048, 127); -f(131072, 128); -f(132096, 129); -f(261120, 255); -f(262144, 256); -f(263168, 257); -f(523264, 511); -f(524288, 512); -f(525312, 513); -f(1047552, 1023); -f(1048576, 1024); -x = 1025; -f(0, 0); -f(1025, 1); -f(2050, 2); -f(3075, 3); -f(4100, 4); -f(5125, 5); -f(7175, 7); -f(8200, 8); -f(9225, 9); -f(15375, 15); -f(16400, 16); -f(17425, 17); -f(31775, 31); -f(32800, 32); -f(33825, 33); -f(64575, 63); -f(65600, 64); -f(66625, 65); -f(130175, 127); -f(131200, 128); -f(132225, 129); -f(261375, 255); -f(262400, 256); -f(263425, 257); -f(523775, 511); -f(524800, 512); -f(525825, 513); -f(1048575, 1023); -f(1049600, 1024); -f(1050625, 1025); -x = 2047; -f(0, 0); -f(2047, 1); -f(4094, 2); -f(6141, 3); -f(8188, 4); -f(10235, 5); -f(14329, 7); -f(16376, 8); -f(18423, 9); -f(30705, 15); -f(32752, 16); -f(34799, 17); -f(63457, 31); -f(65504, 32); -f(67551, 33); -f(128961, 63); -f(131008, 64); -f(133055, 65); -f(259969, 127); -f(262016, 128); -f(264063, 129); -f(521985, 255); -f(524032, 256); -f(526079, 257); -f(1046017, 511); -f(1048064, 512); -f(1050111, 513); -f(2094081, 1023); -f(2096128, 1024); -f(2098175, 1025); -f(4190209, 2047); -x = 2048; -f(0, 0); -f(2048, 1); -f(4096, 2); -f(6144, 3); -f(8192, 4); -f(10240, 5); -f(14336, 7); -f(16384, 8); -f(18432, 9); -f(30720, 15); -f(32768, 16); -f(34816, 17); -f(63488, 31); -f(65536, 32); -f(67584, 33); -f(129024, 63); -f(131072, 64); -f(133120, 65); -f(260096, 127); -f(262144, 128); -f(264192, 129); -f(522240, 255); -f(524288, 256); -f(526336, 257); -f(1046528, 511); -f(1048576, 512); -f(1050624, 513); -f(2095104, 1023); -f(2097152, 1024); -f(2099200, 1025); -f(4192256, 2047); -f(4194304, 2048); -x = 2049; -f(0, 0); -f(2049, 1); -f(4098, 2); -f(6147, 3); -f(8196, 4); -f(10245, 5); -f(14343, 7); -f(16392, 8); -f(18441, 9); -f(30735, 15); -f(32784, 16); -f(34833, 17); -f(63519, 31); -f(65568, 32); -f(67617, 33); -f(129087, 63); -f(131136, 64); -f(133185, 65); -f(260223, 127); -f(262272, 128); -f(264321, 129); -f(522495, 255); -f(524544, 256); -f(526593, 257); -f(1047039, 511); -f(1049088, 512); -f(1051137, 513); -f(2096127, 1023); -f(2098176, 1024); -f(2100225, 1025); -f(4194303, 2047); -f(4196352, 2048); -f(4198401, 2049); -x = 4095; -f(0, 0); -f(4095, 1); -f(8190, 2); -f(12285, 3); -f(16380, 4); -f(20475, 5); -f(28665, 7); -f(32760, 8); -f(36855, 9); -f(61425, 15); -f(65520, 16); -f(69615, 17); -f(126945, 31); -f(131040, 32); -f(135135, 33); -f(257985, 63); -f(262080, 64); -f(266175, 65); -f(520065, 127); -f(524160, 128); -f(528255, 129); -f(1044225, 255); -f(1048320, 256); -f(1052415, 257); -f(2092545, 511); -f(2096640, 512); -f(2100735, 513); -f(4189185, 1023); -f(4193280, 1024); -f(4197375, 1025); -f(8382465, 2047); -f(8386560, 2048); -f(8390655, 2049); -f(16769025, 4095); -x = 4096; -f(0, 0); -f(4096, 1); -f(8192, 2); -f(12288, 3); -f(16384, 4); -f(20480, 5); -f(28672, 7); -f(32768, 8); -f(36864, 9); -f(61440, 15); -f(65536, 16); -f(69632, 17); -f(126976, 31); -f(131072, 32); -f(135168, 33); -f(258048, 63); -f(262144, 64); -f(266240, 65); -f(520192, 127); -f(524288, 128); -f(528384, 129); -f(1044480, 255); -f(1048576, 256); -f(1052672, 257); -f(2093056, 511); -f(2097152, 512); -f(2101248, 513); -f(4190208, 1023); -f(4194304, 1024); -f(4198400, 1025); -f(8384512, 2047); -f(8388608, 2048); -f(8392704, 2049); -f(16773120, 4095); -f(16777216, 4096); -x = 4097; -f(0, 0); -f(4097, 1); -f(8194, 2); -f(12291, 3); -f(16388, 4); -f(20485, 5); -f(28679, 7); -f(32776, 8); -f(36873, 9); -f(61455, 15); -f(65552, 16); -f(69649, 17); -f(127007, 31); -f(131104, 32); -f(135201, 33); -f(258111, 63); -f(262208, 64); -f(266305, 65); -f(520319, 127); -f(524416, 128); -f(528513, 129); -f(1044735, 255); -f(1048832, 256); -f(1052929, 257); -f(2093567, 511); -f(2097664, 512); -f(2101761, 513); -f(4191231, 1023); -f(4195328, 1024); -f(4199425, 1025); -f(8386559, 2047); -f(8390656, 2048); -f(8394753, 2049); -f(16777215, 4095); -f(16781312, 4096); -f(16785409, 4097); -x = 8191; -f(0, 0); -f(8191, 1); -f(16382, 2); -f(24573, 3); -f(32764, 4); -f(40955, 5); -f(57337, 7); -f(65528, 8); -f(73719, 9); -f(122865, 15); -f(131056, 16); -f(139247, 17); -f(253921, 31); -f(262112, 32); -f(270303, 33); -f(516033, 63); -f(524224, 64); -f(532415, 65); -f(1040257, 127); -f(1048448, 128); -f(1056639, 129); -f(2088705, 255); -f(2096896, 256); -f(2105087, 257); -f(4185601, 511); -f(4193792, 512); -f(4201983, 513); -f(8379393, 1023); -f(8387584, 1024); -f(8395775, 1025); -f(16766977, 2047); -f(16775168, 2048); -f(16783359, 2049); -f(33542145, 4095); -f(33550336, 4096); -f(33558527, 4097); -f(67092481, 8191); -x = 8192; -f(0, 0); -f(8192, 1); -f(16384, 2); -f(24576, 3); -f(32768, 4); -f(40960, 5); -f(57344, 7); -f(65536, 8); -f(73728, 9); -f(122880, 15); -f(131072, 16); -f(139264, 17); -f(253952, 31); -f(262144, 32); -f(270336, 33); -f(516096, 63); -f(524288, 64); -f(532480, 65); -f(1040384, 127); -f(1048576, 128); -f(1056768, 129); -f(2088960, 255); -f(2097152, 256); -f(2105344, 257); -f(4186112, 511); -f(4194304, 512); -f(4202496, 513); -f(8380416, 1023); -f(8388608, 1024); -f(8396800, 1025); -f(16769024, 2047); -f(16777216, 2048); -f(16785408, 2049); -f(33546240, 4095); -f(33554432, 4096); -f(33562624, 4097); -f(67100672, 8191); -f(67108864, 8192); -x = 8193; -f(0, 0); -f(8193, 1); -f(16386, 2); -f(24579, 3); -f(32772, 4); -f(40965, 5); -f(57351, 7); -f(65544, 8); -f(73737, 9); -f(122895, 15); -f(131088, 16); -f(139281, 17); -f(253983, 31); -f(262176, 32); -f(270369, 33); -f(516159, 63); -f(524352, 64); -f(532545, 65); -f(1040511, 127); -f(1048704, 128); -f(1056897, 129); -f(2089215, 255); -f(2097408, 256); -f(2105601, 257); -f(4186623, 511); -f(4194816, 512); -f(4203009, 513); -f(8381439, 1023); -f(8389632, 1024); -f(8397825, 1025); -f(16771071, 2047); -f(16779264, 2048); -f(16787457, 2049); -f(33550335, 4095); -f(33558528, 4096); -f(33566721, 4097); -f(67108863, 8191); -f(67117056, 8192); -f(67125249, 8193); -x = 16383; -f(0, 0); -f(16383, 1); -f(32766, 2); -f(49149, 3); -f(65532, 4); -f(81915, 5); -f(114681, 7); -f(131064, 8); -f(147447, 9); -f(245745, 15); -f(262128, 16); -f(278511, 17); -f(507873, 31); -f(524256, 32); -f(540639, 33); -f(1032129, 63); -f(1048512, 64); -f(1064895, 65); -f(2080641, 127); -f(2097024, 128); -f(2113407, 129); -f(4177665, 255); -f(4194048, 256); -f(4210431, 257); -f(8371713, 511); -f(8388096, 512); -f(8404479, 513); -f(16759809, 1023); -f(16776192, 1024); -f(16792575, 1025); -f(33536001, 2047); -f(33552384, 2048); -f(33568767, 2049); -f(67088385, 4095); -f(67104768, 4096); -f(67121151, 4097); -f(134193153, 8191); -f(134209536, 8192); -f(134225919, 8193); -f(268402689, 16383); -x = 16384; -f(0, 0); -f(16384, 1); -f(32768, 2); -f(49152, 3); -f(65536, 4); -f(81920, 5); -f(114688, 7); -f(131072, 8); -f(147456, 9); -f(245760, 15); -f(262144, 16); -f(278528, 17); -f(507904, 31); -f(524288, 32); -f(540672, 33); -f(1032192, 63); -f(1048576, 64); -f(1064960, 65); -f(2080768, 127); -f(2097152, 128); -f(2113536, 129); -f(4177920, 255); -f(4194304, 256); -f(4210688, 257); -f(8372224, 511); -f(8388608, 512); -f(8404992, 513); -f(16760832, 1023); -f(16777216, 1024); -f(16793600, 1025); -f(33538048, 2047); -f(33554432, 2048); -f(33570816, 2049); -f(67092480, 4095); -f(67108864, 4096); -f(67125248, 4097); -f(134201344, 8191); -f(134217728, 8192); -f(134234112, 8193); -f(268419072, 16383); -f(268435456, 16384); -x = 16385; -f(0, 0); -f(16385, 1); -f(32770, 2); -f(49155, 3); -f(65540, 4); -f(81925, 5); -f(114695, 7); -f(131080, 8); -f(147465, 9); -f(245775, 15); -f(262160, 16); -f(278545, 17); -f(507935, 31); -f(524320, 32); -f(540705, 33); -f(1032255, 63); -f(1048640, 64); -f(1065025, 65); -f(2080895, 127); -f(2097280, 128); -f(2113665, 129); -f(4178175, 255); -f(4194560, 256); -f(4210945, 257); -f(8372735, 511); -f(8389120, 512); -f(8405505, 513); -f(16761855, 1023); -f(16778240, 1024); -f(16794625, 1025); -f(33540095, 2047); -f(33556480, 2048); -f(33572865, 2049); -f(67096575, 4095); -f(67112960, 4096); -f(67129345, 4097); -f(134209535, 8191); -f(134225920, 8192); -f(134242305, 8193); -f(268435455, 16383); -f(268451840, 16384); -f(268468225, 16385); -x = 32767; -f(0, 0); -f(32767, 1); -f(65534, 2); -f(98301, 3); -f(131068, 4); -f(163835, 5); -f(229369, 7); -f(262136, 8); -f(294903, 9); -f(491505, 15); -f(524272, 16); -f(557039, 17); -f(1015777, 31); -f(1048544, 32); -f(1081311, 33); -f(2064321, 63); -f(2097088, 64); -f(2129855, 65); -f(4161409, 127); -f(4194176, 128); -f(4226943, 129); -f(8355585, 255); -f(8388352, 256); -f(8421119, 257); -f(16743937, 511); -f(16776704, 512); -f(16809471, 513); -f(33520641, 1023); -f(33553408, 1024); -f(33586175, 1025); -f(67074049, 2047); -f(67106816, 2048); -f(67139583, 2049); -f(134180865, 4095); -f(134213632, 4096); -f(134246399, 4097); -f(268394497, 8191); -f(268427264, 8192); -f(268460031, 8193); -f(536821761, 16383); -f(536854528, 16384); -f(536887295, 16385); -f(1073676289, 32767); -x = 32768; -f(0, 0); -f(32768, 1); -f(65536, 2); -f(98304, 3); -f(131072, 4); -f(163840, 5); -f(229376, 7); -f(262144, 8); -f(294912, 9); -f(491520, 15); -f(524288, 16); -f(557056, 17); -f(1015808, 31); -f(1048576, 32); -f(1081344, 33); -f(2064384, 63); -f(2097152, 64); -f(2129920, 65); -f(4161536, 127); -f(4194304, 128); -f(4227072, 129); -f(8355840, 255); -f(8388608, 256); -f(8421376, 257); -f(16744448, 511); -f(16777216, 512); -f(16809984, 513); -f(33521664, 1023); -f(33554432, 1024); -f(33587200, 1025); -f(67076096, 2047); -f(67108864, 2048); -f(67141632, 2049); -f(134184960, 4095); -f(134217728, 4096); -f(134250496, 4097); -f(268402688, 8191); -f(268435456, 8192); -f(268468224, 8193); -f(536838144, 16383); -f(536870912, 16384); -f(536903680, 16385); -f(1073709056, 32767); -f(1073741824, 32768); -x = 32769; -f(0, 0); -f(32769, 1); -f(65538, 2); -f(98307, 3); -f(131076, 4); -f(163845, 5); -f(229383, 7); -f(262152, 8); -f(294921, 9); -f(491535, 15); -f(524304, 16); -f(557073, 17); -f(1015839, 31); -f(1048608, 32); -f(1081377, 33); -f(2064447, 63); -f(2097216, 64); -f(2129985, 65); -f(4161663, 127); -f(4194432, 128); -f(4227201, 129); -f(8356095, 255); -f(8388864, 256); -f(8421633, 257); -f(16744959, 511); -f(16777728, 512); -f(16810497, 513); -f(33522687, 1023); -f(33555456, 1024); -f(33588225, 1025); -f(67078143, 2047); -f(67110912, 2048); -f(67143681, 2049); -f(134189055, 4095); -f(134221824, 4096); -f(134254593, 4097); -f(268410879, 8191); -f(268443648, 8192); -f(268476417, 8193); -f(536854527, 16383); -f(536887296, 16384); -f(536920065, 16385); -f(1073741823, 32767); -f(1073774592, 32768); -f(1073807361, 32769); -x = 65535; -f(0, 0); -f(65535, 1); -f(131070, 2); -f(196605, 3); -f(262140, 4); -f(327675, 5); -f(458745, 7); -f(524280, 8); -f(589815, 9); -f(983025, 15); -f(1048560, 16); -f(1114095, 17); -f(2031585, 31); -f(2097120, 32); -f(2162655, 33); -f(4128705, 63); -f(4194240, 64); -f(4259775, 65); -f(8322945, 127); -f(8388480, 128); -f(8454015, 129); -f(16711425, 255); -f(16776960, 256); -f(16842495, 257); -f(33488385, 511); -f(33553920, 512); -f(33619455, 513); -f(67042305, 1023); -f(67107840, 1024); -f(67173375, 1025); -f(134150145, 2047); -f(134215680, 2048); -f(134281215, 2049); -f(268365825, 4095); -f(268431360, 4096); -f(268496895, 4097); -f(536797185, 8191); -f(536862720, 8192); -f(536928255, 8193); -f(1073659905, 16383); -f(1073725440, 16384); -f(1073790975, 16385); -f(2147385345, 32767); -f(2147450880, 32768); -f(2147516415, 32769); -f(4294836225, 65535); -x = 65536; -f(0, 0); -f(65536, 1); -f(131072, 2); -f(196608, 3); -f(262144, 4); -f(327680, 5); -f(458752, 7); -f(524288, 8); -f(589824, 9); -f(983040, 15); -f(1048576, 16); -f(1114112, 17); -f(2031616, 31); -f(2097152, 32); -f(2162688, 33); -f(4128768, 63); -f(4194304, 64); -f(4259840, 65); -f(8323072, 127); -f(8388608, 128); -f(8454144, 129); -f(16711680, 255); -f(16777216, 256); -f(16842752, 257); -f(33488896, 511); -f(33554432, 512); -f(33619968, 513); -f(67043328, 1023); -f(67108864, 1024); -f(67174400, 1025); -f(134152192, 2047); -f(134217728, 2048); -f(134283264, 2049); -f(268369920, 4095); -f(268435456, 4096); -f(268500992, 4097); -f(536805376, 8191); -f(536870912, 8192); -f(536936448, 8193); -f(1073676288, 16383); -f(1073741824, 16384); -f(1073807360, 16385); -f(2147418112, 32767); -f(2147483648, 32768); -f(2147549184, 32769); -f(4294901760, 65535); -f(4294967296, 65536); -x = 65537; -f(0, 0); -f(65537, 1); -f(131074, 2); -f(196611, 3); -f(262148, 4); -f(327685, 5); -f(458759, 7); -f(524296, 8); -f(589833, 9); -f(983055, 15); -f(1048592, 16); -f(1114129, 17); -f(2031647, 31); -f(2097184, 32); -f(2162721, 33); -f(4128831, 63); -f(4194368, 64); -f(4259905, 65); -f(8323199, 127); -f(8388736, 128); -f(8454273, 129); -f(16711935, 255); -f(16777472, 256); -f(16843009, 257); -f(33489407, 511); -f(33554944, 512); -f(33620481, 513); -f(67044351, 1023); -f(67109888, 1024); -f(67175425, 1025); -f(134154239, 2047); -f(134219776, 2048); -f(134285313, 2049); -f(268374015, 4095); -f(268439552, 4096); -f(268505089, 4097); -f(536813567, 8191); -f(536879104, 8192); -f(536944641, 8193); -f(1073692671, 16383); -f(1073758208, 16384); -f(1073823745, 16385); -f(2147450879, 32767); -f(2147516416, 32768); -f(2147581953, 32769); -f(4294967295, 65535); -f(4295032832, 65536); -f(4295098369, 65537); -x = 131071; -f(0, 0); -f(131071, 1); -f(262142, 2); -f(393213, 3); -f(524284, 4); -f(655355, 5); -f(917497, 7); -f(1048568, 8); -f(1179639, 9); -f(1966065, 15); -f(2097136, 16); -f(2228207, 17); -f(4063201, 31); -f(4194272, 32); -f(4325343, 33); -f(8257473, 63); -f(8388544, 64); -f(8519615, 65); -f(16646017, 127); -f(16777088, 128); -f(16908159, 129); -f(33423105, 255); -f(33554176, 256); -f(33685247, 257); -f(66977281, 511); -f(67108352, 512); -f(67239423, 513); -f(134085633, 1023); -f(134216704, 1024); -f(134347775, 1025); -f(268302337, 2047); -f(268433408, 2048); -f(268564479, 2049); -f(536735745, 4095); -f(536866816, 4096); -f(536997887, 4097); -f(1073602561, 8191); -f(1073733632, 8192); -f(1073864703, 8193); -f(2147336193, 16383); -f(2147467264, 16384); -f(2147598335, 16385); -f(4294803457, 32767); -f(4294934528, 32768); -f(4295065599, 32769); -f(8589737985, 65535); -f(8589869056, 65536); -f(8590000127, 65537); -f(17179607041, 131071); -x = 131072; -f(0, 0); -f(131072, 1); -f(262144, 2); -f(393216, 3); -f(524288, 4); -f(655360, 5); -f(917504, 7); -f(1048576, 8); -f(1179648, 9); -f(1966080, 15); -f(2097152, 16); -f(2228224, 17); -f(4063232, 31); -f(4194304, 32); -f(4325376, 33); -f(8257536, 63); -f(8388608, 64); -f(8519680, 65); -f(16646144, 127); -f(16777216, 128); -f(16908288, 129); -f(33423360, 255); -f(33554432, 256); -f(33685504, 257); -f(66977792, 511); -f(67108864, 512); -f(67239936, 513); -f(134086656, 1023); -f(134217728, 1024); -f(134348800, 1025); -f(268304384, 2047); -f(268435456, 2048); -f(268566528, 2049); -f(536739840, 4095); -f(536870912, 4096); -f(537001984, 4097); -f(1073610752, 8191); -f(1073741824, 8192); -f(1073872896, 8193); -f(2147352576, 16383); -f(2147483648, 16384); -f(2147614720, 16385); -f(4294836224, 32767); -f(4294967296, 32768); -f(4295098368, 32769); -f(8589803520, 65535); -f(8589934592, 65536); -f(8590065664, 65537); -f(17179738112, 131071); -f(17179869184, 131072); -x = 131073; -f(0, 0); -f(131073, 1); -f(262146, 2); -f(393219, 3); -f(524292, 4); -f(655365, 5); -f(917511, 7); -f(1048584, 8); -f(1179657, 9); -f(1966095, 15); -f(2097168, 16); -f(2228241, 17); -f(4063263, 31); -f(4194336, 32); -f(4325409, 33); -f(8257599, 63); -f(8388672, 64); -f(8519745, 65); -f(16646271, 127); -f(16777344, 128); -f(16908417, 129); -f(33423615, 255); -f(33554688, 256); -f(33685761, 257); -f(66978303, 511); -f(67109376, 512); -f(67240449, 513); -f(134087679, 1023); -f(134218752, 1024); -f(134349825, 1025); -f(268306431, 2047); -f(268437504, 2048); -f(268568577, 2049); -f(536743935, 4095); -f(536875008, 4096); -f(537006081, 4097); -f(1073618943, 8191); -f(1073750016, 8192); -f(1073881089, 8193); -f(2147368959, 16383); -f(2147500032, 16384); -f(2147631105, 16385); -f(4294868991, 32767); -f(4295000064, 32768); -f(4295131137, 32769); -f(8589869055, 65535); -f(8590000128, 65536); -f(8590131201, 65537); -f(17179869183, 131071); -f(17180000256, 131072); -f(17180131329, 131073); -x = 262143; -f(0, 0); -f(262143, 1); -f(524286, 2); -f(786429, 3); -f(1048572, 4); -f(1310715, 5); -f(1835001, 7); -f(2097144, 8); -f(2359287, 9); -f(3932145, 15); -f(4194288, 16); -f(4456431, 17); -f(8126433, 31); -f(8388576, 32); -f(8650719, 33); -f(16515009, 63); -f(16777152, 64); -f(17039295, 65); -f(33292161, 127); -f(33554304, 128); -f(33816447, 129); -f(66846465, 255); -f(67108608, 256); -f(67370751, 257); -f(133955073, 511); -f(134217216, 512); -f(134479359, 513); -f(268172289, 1023); -f(268434432, 1024); -f(268696575, 1025); -f(536606721, 2047); -f(536868864, 2048); -f(537131007, 2049); -f(1073475585, 4095); -f(1073737728, 4096); -f(1073999871, 4097); -f(2147213313, 8191); -f(2147475456, 8192); -f(2147737599, 8193); -f(4294688769, 16383); -f(4294950912, 16384); -f(4295213055, 16385); -f(8589639681, 32767); -f(8589901824, 32768); -f(8590163967, 32769); -f(17179541505, 65535); -f(17179803648, 65536); -f(17180065791, 65537); -f(34359345153, 131071); -f(34359607296, 131072); -f(34359869439, 131073); -f(68718952449, 262143); -x = 262144; -f(0, 0); -f(262144, 1); -f(524288, 2); -f(786432, 3); -f(1048576, 4); -f(1310720, 5); -f(1835008, 7); -f(2097152, 8); -f(2359296, 9); -f(3932160, 15); -f(4194304, 16); -f(4456448, 17); -f(8126464, 31); -f(8388608, 32); -f(8650752, 33); -f(16515072, 63); -f(16777216, 64); -f(17039360, 65); -f(33292288, 127); -f(33554432, 128); -f(33816576, 129); -f(66846720, 255); -f(67108864, 256); -f(67371008, 257); -f(133955584, 511); -f(134217728, 512); -f(134479872, 513); -f(268173312, 1023); -f(268435456, 1024); -f(268697600, 1025); -f(536608768, 2047); -f(536870912, 2048); -f(537133056, 2049); -f(1073479680, 4095); -f(1073741824, 4096); -f(1074003968, 4097); -f(2147221504, 8191); -f(2147483648, 8192); -f(2147745792, 8193); -f(4294705152, 16383); -f(4294967296, 16384); -f(4295229440, 16385); -f(8589672448, 32767); -f(8589934592, 32768); -f(8590196736, 32769); -f(17179607040, 65535); -f(17179869184, 65536); -f(17180131328, 65537); -f(34359476224, 131071); -f(34359738368, 131072); -f(34360000512, 131073); -f(68719214592, 262143); -f(68719476736, 262144); -x = 262145; -f(0, 0); -f(262145, 1); -f(524290, 2); -f(786435, 3); -f(1048580, 4); -f(1310725, 5); -f(1835015, 7); -f(2097160, 8); -f(2359305, 9); -f(3932175, 15); -f(4194320, 16); -f(4456465, 17); -f(8126495, 31); -f(8388640, 32); -f(8650785, 33); -f(16515135, 63); -f(16777280, 64); -f(17039425, 65); -f(33292415, 127); -f(33554560, 128); -f(33816705, 129); -f(66846975, 255); -f(67109120, 256); -f(67371265, 257); -f(133956095, 511); -f(134218240, 512); -f(134480385, 513); -f(268174335, 1023); -f(268436480, 1024); -f(268698625, 1025); -f(536610815, 2047); -f(536872960, 2048); -f(537135105, 2049); -f(1073483775, 4095); -f(1073745920, 4096); -f(1074008065, 4097); -f(2147229695, 8191); -f(2147491840, 8192); -f(2147753985, 8193); -f(4294721535, 16383); -f(4294983680, 16384); -f(4295245825, 16385); -f(8589705215, 32767); -f(8589967360, 32768); -f(8590229505, 32769); -f(17179672575, 65535); -f(17179934720, 65536); -f(17180196865, 65537); -f(34359607295, 131071); -f(34359869440, 131072); -f(34360131585, 131073); -f(68719476735, 262143); -f(68719738880, 262144); -f(68720001025, 262145); -x = 524287; -f(0, 0); -f(524287, 1); -f(1048574, 2); -f(1572861, 3); -f(2097148, 4); -f(2621435, 5); -f(3670009, 7); -f(4194296, 8); -f(4718583, 9); -f(7864305, 15); -f(8388592, 16); -f(8912879, 17); -f(16252897, 31); -f(16777184, 32); -f(17301471, 33); -f(33030081, 63); -f(33554368, 64); -f(34078655, 65); -f(66584449, 127); -f(67108736, 128); -f(67633023, 129); -f(133693185, 255); -f(134217472, 256); -f(134741759, 257); -f(267910657, 511); -f(268434944, 512); -f(268959231, 513); -f(536345601, 1023); -f(536869888, 1024); -f(537394175, 1025); -f(1073215489, 2047); -f(1073739776, 2048); -f(1074264063, 2049); -f(2146955265, 4095); -f(2147479552, 4096); -f(2148003839, 4097); -f(4294434817, 8191); -f(4294959104, 8192); -f(4295483391, 8193); -f(8589393921, 16383); -f(8589918208, 16384); -f(8590442495, 16385); -f(17179312129, 32767); -f(17179836416, 32768); -f(17180360703, 32769); -f(34359148545, 65535); -f(34359672832, 65536); -f(34360197119, 65537); -f(68718821377, 131071); -f(68719345664, 131072); -f(68719869951, 131073); -f(137438167041, 262143); -f(137438691328, 262144); -f(137439215615, 262145); -f(274876858369, 524287); -x = 524288; -f(0, 0); -f(524288, 1); -f(1048576, 2); -f(1572864, 3); -f(2097152, 4); -f(2621440, 5); -f(3670016, 7); -f(4194304, 8); -f(4718592, 9); -f(7864320, 15); -f(8388608, 16); -f(8912896, 17); -f(16252928, 31); -f(16777216, 32); -f(17301504, 33); -f(33030144, 63); -f(33554432, 64); -f(34078720, 65); -f(66584576, 127); -f(67108864, 128); -f(67633152, 129); -f(133693440, 255); -f(134217728, 256); -f(134742016, 257); -f(267911168, 511); -f(268435456, 512); -f(268959744, 513); -f(536346624, 1023); -f(536870912, 1024); -f(537395200, 1025); -f(1073217536, 2047); -f(1073741824, 2048); -f(1074266112, 2049); -f(2146959360, 4095); -f(2147483648, 4096); -f(2148007936, 4097); -f(4294443008, 8191); -f(4294967296, 8192); -f(4295491584, 8193); -f(8589410304, 16383); -f(8589934592, 16384); -f(8590458880, 16385); -f(17179344896, 32767); -f(17179869184, 32768); -f(17180393472, 32769); -f(34359214080, 65535); -f(34359738368, 65536); -f(34360262656, 65537); -f(68718952448, 131071); -f(68719476736, 131072); -f(68720001024, 131073); -f(137438429184, 262143); -f(137438953472, 262144); -f(137439477760, 262145); -f(274877382656, 524287); -f(274877906944, 524288); -x = 524289; -f(0, 0); -f(524289, 1); -f(1048578, 2); -f(1572867, 3); -f(2097156, 4); -f(2621445, 5); -f(3670023, 7); -f(4194312, 8); -f(4718601, 9); -f(7864335, 15); -f(8388624, 16); -f(8912913, 17); -f(16252959, 31); -f(16777248, 32); -f(17301537, 33); -f(33030207, 63); -f(33554496, 64); -f(34078785, 65); -f(66584703, 127); -f(67108992, 128); -f(67633281, 129); -f(133693695, 255); -f(134217984, 256); -f(134742273, 257); -f(267911679, 511); -f(268435968, 512); -f(268960257, 513); -f(536347647, 1023); -f(536871936, 1024); -f(537396225, 1025); -f(1073219583, 2047); -f(1073743872, 2048); -f(1074268161, 2049); -f(2146963455, 4095); -f(2147487744, 4096); -f(2148012033, 4097); -f(4294451199, 8191); -f(4294975488, 8192); -f(4295499777, 8193); -f(8589426687, 16383); -f(8589950976, 16384); -f(8590475265, 16385); -f(17179377663, 32767); -f(17179901952, 32768); -f(17180426241, 32769); -f(34359279615, 65535); -f(34359803904, 65536); -f(34360328193, 65537); -f(68719083519, 131071); -f(68719607808, 131072); -f(68720132097, 131073); -f(137438691327, 262143); -f(137439215616, 262144); -f(137439739905, 262145); -f(274877906943, 524287); -f(274878431232, 524288); -f(274878955521, 524289); -x = 1048575; -f(0, 0); -f(1048575, 1); -f(2097150, 2); -f(3145725, 3); -f(4194300, 4); -f(5242875, 5); -f(7340025, 7); -f(8388600, 8); -f(9437175, 9); -f(15728625, 15); -f(16777200, 16); -f(17825775, 17); -f(32505825, 31); -f(33554400, 32); -f(34602975, 33); -f(66060225, 63); -f(67108800, 64); -f(68157375, 65); -f(133169025, 127); -f(134217600, 128); -f(135266175, 129); -f(267386625, 255); -f(268435200, 256); -f(269483775, 257); -f(535821825, 511); -f(536870400, 512); -f(537918975, 513); -f(1072692225, 1023); -f(1073740800, 1024); -f(1074789375, 1025); -f(2146433025, 2047); -f(2147481600, 2048); -f(2148530175, 2049); -f(4293914625, 4095); -f(4294963200, 4096); -f(4296011775, 4097); -f(8588877825, 8191); -f(8589926400, 8192); -f(8590974975, 8193); -f(17178804225, 16383); -f(17179852800, 16384); -f(17180901375, 16385); -f(34358657025, 32767); -f(34359705600, 32768); -f(34360754175, 32769); -f(68718362625, 65535); -f(68719411200, 65536); -f(68720459775, 65537); -f(137437773825, 131071); -f(137438822400, 131072); -f(137439870975, 131073); -f(274876596225, 262143); -f(274877644800, 262144); -f(274878693375, 262145); -f(549754241025, 524287); -f(549755289600, 524288); -f(549756338175, 524289); -f(1099509530625, 1048575); -x = 1048576; -f(0, 0); -f(1048576, 1); -f(2097152, 2); -f(3145728, 3); -f(4194304, 4); -f(5242880, 5); -f(7340032, 7); -f(8388608, 8); -f(9437184, 9); -f(15728640, 15); -f(16777216, 16); -f(17825792, 17); -f(32505856, 31); -f(33554432, 32); -f(34603008, 33); -f(66060288, 63); -f(67108864, 64); -f(68157440, 65); -f(133169152, 127); -f(134217728, 128); -f(135266304, 129); -f(267386880, 255); -f(268435456, 256); -f(269484032, 257); -f(535822336, 511); -f(536870912, 512); -f(537919488, 513); -f(1072693248, 1023); -f(1073741824, 1024); -f(1074790400, 1025); -f(2146435072, 2047); -f(2147483648, 2048); -f(2148532224, 2049); -f(4293918720, 4095); -f(4294967296, 4096); -f(4296015872, 4097); -f(8588886016, 8191); -f(8589934592, 8192); -f(8590983168, 8193); -f(17178820608, 16383); -f(17179869184, 16384); -f(17180917760, 16385); -f(34358689792, 32767); -f(34359738368, 32768); -f(34360786944, 32769); -f(68718428160, 65535); -f(68719476736, 65536); -f(68720525312, 65537); -f(137437904896, 131071); -f(137438953472, 131072); -f(137440002048, 131073); -f(274876858368, 262143); -f(274877906944, 262144); -f(274878955520, 262145); -f(549754765312, 524287); -f(549755813888, 524288); -f(549756862464, 524289); -f(1099510579200, 1048575); -f(1099511627776, 1048576); -x = 1048577; -f(0, 0); -f(1048577, 1); -f(2097154, 2); -f(3145731, 3); -f(4194308, 4); -f(5242885, 5); -f(7340039, 7); -f(8388616, 8); -f(9437193, 9); -f(15728655, 15); -f(16777232, 16); -f(17825809, 17); -f(32505887, 31); -f(33554464, 32); -f(34603041, 33); -f(66060351, 63); -f(67108928, 64); -f(68157505, 65); -f(133169279, 127); -f(134217856, 128); -f(135266433, 129); -f(267387135, 255); -f(268435712, 256); -f(269484289, 257); -f(535822847, 511); -f(536871424, 512); -f(537920001, 513); -f(1072694271, 1023); -f(1073742848, 1024); -f(1074791425, 1025); -f(2146437119, 2047); -f(2147485696, 2048); -f(2148534273, 2049); -f(4293922815, 4095); -f(4294971392, 4096); -f(4296019969, 4097); -f(8588894207, 8191); -f(8589942784, 8192); -f(8590991361, 8193); -f(17178836991, 16383); -f(17179885568, 16384); -f(17180934145, 16385); -f(34358722559, 32767); -f(34359771136, 32768); -f(34360819713, 32769); -f(68718493695, 65535); -f(68719542272, 65536); -f(68720590849, 65537); -f(137438035967, 131071); -f(137439084544, 131072); -f(137440133121, 131073); -f(274877120511, 262143); -f(274878169088, 262144); -f(274879217665, 262145); -f(549755289599, 524287); -f(549756338176, 524288); -f(549757386753, 524289); -f(1099511627775, 1048575); -f(1099512676352, 1048576); -f(1099513724929, 1048577); -x = 2097151; -f(0, 0); -f(2097151, 1); -f(4194302, 2); -f(6291453, 3); -f(8388604, 4); -f(10485755, 5); -f(14680057, 7); -f(16777208, 8); -f(18874359, 9); -f(31457265, 15); -f(33554416, 16); -f(35651567, 17); -f(65011681, 31); -f(67108832, 32); -f(69205983, 33); -f(132120513, 63); -f(134217664, 64); -f(136314815, 65); -f(266338177, 127); -f(268435328, 128); -f(270532479, 129); -f(534773505, 255); -f(536870656, 256); -f(538967807, 257); -f(1071644161, 511); -f(1073741312, 512); -f(1075838463, 513); -f(2145385473, 1023); -f(2147482624, 1024); -f(2149579775, 1025); -f(4292868097, 2047); -f(4294965248, 2048); -f(4297062399, 2049); -f(8587833345, 4095); -f(8589930496, 4096); -f(8592027647, 4097); -f(17177763841, 8191); -f(17179860992, 8192); -f(17181958143, 8193); -f(34357624833, 16383); -f(34359721984, 16384); -f(34361819135, 16385); -f(68717346817, 32767); -f(68719443968, 32768); -f(68721541119, 32769); -f(137436790785, 65535); -f(137438887936, 65536); -f(137440985087, 65537); -f(274875678721, 131071); -f(274877775872, 131072); -f(274879873023, 131073); -f(549753454593, 262143); -f(549755551744, 262144); -f(549757648895, 262145); -f(1099509006337, 524287); -f(1099511103488, 524288); -f(1099513200639, 524289); -f(2199020109825, 1048575); -f(2199022206976, 1048576); -f(2199024304127, 1048577); -f(4398042316801, 2097151); -x = 2097152; -f(0, 0); -f(2097152, 1); -f(4194304, 2); -f(6291456, 3); -f(8388608, 4); -f(10485760, 5); -f(14680064, 7); -f(16777216, 8); -f(18874368, 9); -f(31457280, 15); -f(33554432, 16); -f(35651584, 17); -f(65011712, 31); -f(67108864, 32); -f(69206016, 33); -f(132120576, 63); -f(134217728, 64); -f(136314880, 65); -f(266338304, 127); -f(268435456, 128); -f(270532608, 129); -f(534773760, 255); -f(536870912, 256); -f(538968064, 257); -f(1071644672, 511); -f(1073741824, 512); -f(1075838976, 513); -f(2145386496, 1023); -f(2147483648, 1024); -f(2149580800, 1025); -f(4292870144, 2047); -f(4294967296, 2048); -f(4297064448, 2049); -f(8587837440, 4095); -f(8589934592, 4096); -f(8592031744, 4097); -f(17177772032, 8191); -f(17179869184, 8192); -f(17181966336, 8193); -f(34357641216, 16383); -f(34359738368, 16384); -f(34361835520, 16385); -f(68717379584, 32767); -f(68719476736, 32768); -f(68721573888, 32769); -f(137436856320, 65535); -f(137438953472, 65536); -f(137441050624, 65537); -f(274875809792, 131071); -f(274877906944, 131072); -f(274880004096, 131073); -f(549753716736, 262143); -f(549755813888, 262144); -f(549757911040, 262145); -f(1099509530624, 524287); -f(1099511627776, 524288); -f(1099513724928, 524289); -f(2199021158400, 1048575); -f(2199023255552, 1048576); -f(2199025352704, 1048577); -f(4398044413952, 2097151); -f(4398046511104, 2097152); -x = 2097153; -f(0, 0); -f(2097153, 1); -f(4194306, 2); -f(6291459, 3); -f(8388612, 4); -f(10485765, 5); -f(14680071, 7); -f(16777224, 8); -f(18874377, 9); -f(31457295, 15); -f(33554448, 16); -f(35651601, 17); -f(65011743, 31); -f(67108896, 32); -f(69206049, 33); -f(132120639, 63); -f(134217792, 64); -f(136314945, 65); -f(266338431, 127); -f(268435584, 128); -f(270532737, 129); -f(534774015, 255); -f(536871168, 256); -f(538968321, 257); -f(1071645183, 511); -f(1073742336, 512); -f(1075839489, 513); -f(2145387519, 1023); -f(2147484672, 1024); -f(2149581825, 1025); -f(4292872191, 2047); -f(4294969344, 2048); -f(4297066497, 2049); -f(8587841535, 4095); -f(8589938688, 4096); -f(8592035841, 4097); -f(17177780223, 8191); -f(17179877376, 8192); -f(17181974529, 8193); -f(34357657599, 16383); -f(34359754752, 16384); -f(34361851905, 16385); -f(68717412351, 32767); -f(68719509504, 32768); -f(68721606657, 32769); -f(137436921855, 65535); -f(137439019008, 65536); -f(137441116161, 65537); -f(274875940863, 131071); -f(274878038016, 131072); -f(274880135169, 131073); -f(549753978879, 262143); -f(549756076032, 262144); -f(549758173185, 262145); -f(1099510054911, 524287); -f(1099512152064, 524288); -f(1099514249217, 524289); -f(2199022206975, 1048575); -f(2199024304128, 1048576); -f(2199026401281, 1048577); -f(4398046511103, 2097151); -f(4398048608256, 2097152); -f(4398050705409, 2097153); -x = 4194303; -f(0, 0); -f(4194303, 1); -f(8388606, 2); -f(12582909, 3); -f(16777212, 4); -f(20971515, 5); -f(29360121, 7); -f(33554424, 8); -f(37748727, 9); -f(62914545, 15); -f(67108848, 16); -f(71303151, 17); -f(130023393, 31); -f(134217696, 32); -f(138411999, 33); -f(264241089, 63); -f(268435392, 64); -f(272629695, 65); -f(532676481, 127); -f(536870784, 128); -f(541065087, 129); -f(1069547265, 255); -f(1073741568, 256); -f(1077935871, 257); -f(2143288833, 511); -f(2147483136, 512); -f(2151677439, 513); -f(4290771969, 1023); -f(4294966272, 1024); -f(4299160575, 1025); -f(8585738241, 2047); -f(8589932544, 2048); -f(8594126847, 2049); -f(17175670785, 4095); -f(17179865088, 4096); -f(17184059391, 4097); -f(34355535873, 8191); -f(34359730176, 8192); -f(34363924479, 8193); -f(68715266049, 16383); -f(68719460352, 16384); -f(68723654655, 16385); -f(137434726401, 32767); -f(137438920704, 32768); -f(137443115007, 32769); -f(274873647105, 65535); -f(274877841408, 65536); -f(274882035711, 65537); -f(549751488513, 131071); -f(549755682816, 131072); -f(549759877119, 131073); -f(1099507171329, 262143); -f(1099511365632, 262144); -f(1099515559935, 262145); -f(2199018536961, 524287); -f(2199022731264, 524288); -f(2199026925567, 524289); -f(4398041268225, 1048575); -f(4398045462528, 1048576); -f(4398049656831, 1048577); -f(8796086730753, 2097151); -f(8796090925056, 2097152); -f(8796095119359, 2097153); -f(17592177655809, 4194303); -x = 4194304; -f(0, 0); -f(4194304, 1); -f(8388608, 2); -f(12582912, 3); -f(16777216, 4); -f(20971520, 5); -f(29360128, 7); -f(33554432, 8); -f(37748736, 9); -f(62914560, 15); -f(67108864, 16); -f(71303168, 17); -f(130023424, 31); -f(134217728, 32); -f(138412032, 33); -f(264241152, 63); -f(268435456, 64); -f(272629760, 65); -f(532676608, 127); -f(536870912, 128); -f(541065216, 129); -f(1069547520, 255); -f(1073741824, 256); -f(1077936128, 257); -f(2143289344, 511); -f(2147483648, 512); -f(2151677952, 513); -f(4290772992, 1023); -f(4294967296, 1024); -f(4299161600, 1025); -f(8585740288, 2047); -f(8589934592, 2048); -f(8594128896, 2049); -f(17175674880, 4095); -f(17179869184, 4096); -f(17184063488, 4097); -f(34355544064, 8191); -f(34359738368, 8192); -f(34363932672, 8193); -f(68715282432, 16383); -f(68719476736, 16384); -f(68723671040, 16385); -f(137434759168, 32767); -f(137438953472, 32768); -f(137443147776, 32769); -f(274873712640, 65535); -f(274877906944, 65536); -f(274882101248, 65537); -f(549751619584, 131071); -f(549755813888, 131072); -f(549760008192, 131073); -f(1099507433472, 262143); -f(1099511627776, 262144); -f(1099515822080, 262145); -f(2199019061248, 524287); -f(2199023255552, 524288); -f(2199027449856, 524289); -f(4398042316800, 1048575); -f(4398046511104, 1048576); -f(4398050705408, 1048577); -f(8796088827904, 2097151); -f(8796093022208, 2097152); -f(8796097216512, 2097153); -f(17592181850112, 4194303); -f(17592186044416, 4194304); -x = 4194305; -f(0, 0); -f(4194305, 1); -f(8388610, 2); -f(12582915, 3); -f(16777220, 4); -f(20971525, 5); -f(29360135, 7); -f(33554440, 8); -f(37748745, 9); -f(62914575, 15); -f(67108880, 16); -f(71303185, 17); -f(130023455, 31); -f(134217760, 32); -f(138412065, 33); -f(264241215, 63); -f(268435520, 64); -f(272629825, 65); -f(532676735, 127); -f(536871040, 128); -f(541065345, 129); -f(1069547775, 255); -f(1073742080, 256); -f(1077936385, 257); -f(2143289855, 511); -f(2147484160, 512); -f(2151678465, 513); -f(4290774015, 1023); -f(4294968320, 1024); -f(4299162625, 1025); -f(8585742335, 2047); -f(8589936640, 2048); -f(8594130945, 2049); -f(17175678975, 4095); -f(17179873280, 4096); -f(17184067585, 4097); -f(34355552255, 8191); -f(34359746560, 8192); -f(34363940865, 8193); -f(68715298815, 16383); -f(68719493120, 16384); -f(68723687425, 16385); -f(137434791935, 32767); -f(137438986240, 32768); -f(137443180545, 32769); -f(274873778175, 65535); -f(274877972480, 65536); -f(274882166785, 65537); -f(549751750655, 131071); -f(549755944960, 131072); -f(549760139265, 131073); -f(1099507695615, 262143); -f(1099511889920, 262144); -f(1099516084225, 262145); -f(2199019585535, 524287); -f(2199023779840, 524288); -f(2199027974145, 524289); -f(4398043365375, 1048575); -f(4398047559680, 1048576); -f(4398051753985, 1048577); -f(8796090925055, 2097151); -f(8796095119360, 2097152); -f(8796099313665, 2097153); -f(17592186044415, 4194303); -f(17592190238720, 4194304); -f(17592194433025, 4194305); -x = 8388607; -f(0, 0); -f(8388607, 1); -f(16777214, 2); -f(25165821, 3); -f(33554428, 4); -f(41943035, 5); -f(58720249, 7); -f(67108856, 8); -f(75497463, 9); -f(125829105, 15); -f(134217712, 16); -f(142606319, 17); -f(260046817, 31); -f(268435424, 32); -f(276824031, 33); -f(528482241, 63); -f(536870848, 64); -f(545259455, 65); -f(1065353089, 127); -f(1073741696, 128); -f(1082130303, 129); -f(2139094785, 255); -f(2147483392, 256); -f(2155871999, 257); -f(4286578177, 511); -f(4294966784, 512); -f(4303355391, 513); -f(8581544961, 1023); -f(8589933568, 1024); -f(8598322175, 1025); -f(17171478529, 2047); -f(17179867136, 2048); -f(17188255743, 2049); -f(34351345665, 4095); -f(34359734272, 4096); -f(34368122879, 4097); -f(68711079937, 8191); -f(68719468544, 8192); -f(68727857151, 8193); -f(137430548481, 16383); -f(137438937088, 16384); -f(137447325695, 16385); -f(274869485569, 32767); -f(274877874176, 32768); -f(274886262783, 32769); -f(549747359745, 65535); -f(549755748352, 65536); -f(549764136959, 65537); -f(1099503108097, 131071); -f(1099511496704, 131072); -f(1099519885311, 131073); -f(2199014604801, 262143); -f(2199022993408, 262144); -f(2199031382015, 262145); -f(4398037598209, 524287); -f(4398045986816, 524288); -f(4398054375423, 524289); -f(8796083585025, 1048575); -f(8796091973632, 1048576); -f(8796100362239, 1048577); -f(17592175558657, 2097151); -f(17592183947264, 2097152); -f(17592192335871, 2097153); -f(35184359505921, 4194303); -f(35184367894528, 4194304); -f(35184376283135, 4194305); -f(70368727400449, 8388607); -x = 8388608; -f(0, 0); -f(8388608, 1); -f(16777216, 2); -f(25165824, 3); -f(33554432, 4); -f(41943040, 5); -f(58720256, 7); -f(67108864, 8); -f(75497472, 9); -f(125829120, 15); -f(134217728, 16); -f(142606336, 17); -f(260046848, 31); -f(268435456, 32); -f(276824064, 33); -f(528482304, 63); -f(536870912, 64); -f(545259520, 65); -f(1065353216, 127); -f(1073741824, 128); -f(1082130432, 129); -f(2139095040, 255); -f(2147483648, 256); -f(2155872256, 257); -f(4286578688, 511); -f(4294967296, 512); -f(4303355904, 513); -f(8581545984, 1023); -f(8589934592, 1024); -f(8598323200, 1025); -f(17171480576, 2047); -f(17179869184, 2048); -f(17188257792, 2049); -f(34351349760, 4095); -f(34359738368, 4096); -f(34368126976, 4097); -f(68711088128, 8191); -f(68719476736, 8192); -f(68727865344, 8193); -f(137430564864, 16383); -f(137438953472, 16384); -f(137447342080, 16385); -f(274869518336, 32767); -f(274877906944, 32768); -f(274886295552, 32769); -f(549747425280, 65535); -f(549755813888, 65536); -f(549764202496, 65537); -f(1099503239168, 131071); -f(1099511627776, 131072); -f(1099520016384, 131073); -f(2199014866944, 262143); -f(2199023255552, 262144); -f(2199031644160, 262145); -f(4398038122496, 524287); -f(4398046511104, 524288); -f(4398054899712, 524289); -f(8796084633600, 1048575); -f(8796093022208, 1048576); -f(8796101410816, 1048577); -f(17592177655808, 2097151); -f(17592186044416, 2097152); -f(17592194433024, 2097153); -f(35184363700224, 4194303); -f(35184372088832, 4194304); -f(35184380477440, 4194305); -f(70368735789056, 8388607); -f(70368744177664, 8388608); -x = 8388609; -f(0, 0); -f(8388609, 1); -f(16777218, 2); -f(25165827, 3); -f(33554436, 4); -f(41943045, 5); -f(58720263, 7); -f(67108872, 8); -f(75497481, 9); -f(125829135, 15); -f(134217744, 16); -f(142606353, 17); -f(260046879, 31); -f(268435488, 32); -f(276824097, 33); -f(528482367, 63); -f(536870976, 64); -f(545259585, 65); -f(1065353343, 127); -f(1073741952, 128); -f(1082130561, 129); -f(2139095295, 255); -f(2147483904, 256); -f(2155872513, 257); -f(4286579199, 511); -f(4294967808, 512); -f(4303356417, 513); -f(8581547007, 1023); -f(8589935616, 1024); -f(8598324225, 1025); -f(17171482623, 2047); -f(17179871232, 2048); -f(17188259841, 2049); -f(34351353855, 4095); -f(34359742464, 4096); -f(34368131073, 4097); -f(68711096319, 8191); -f(68719484928, 8192); -f(68727873537, 8193); -f(137430581247, 16383); -f(137438969856, 16384); -f(137447358465, 16385); -f(274869551103, 32767); -f(274877939712, 32768); -f(274886328321, 32769); -f(549747490815, 65535); -f(549755879424, 65536); -f(549764268033, 65537); -f(1099503370239, 131071); -f(1099511758848, 131072); -f(1099520147457, 131073); -f(2199015129087, 262143); -f(2199023517696, 262144); -f(2199031906305, 262145); -f(4398038646783, 524287); -f(4398047035392, 524288); -f(4398055424001, 524289); -f(8796085682175, 1048575); -f(8796094070784, 1048576); -f(8796102459393, 1048577); -f(17592179752959, 2097151); -f(17592188141568, 2097152); -f(17592196530177, 2097153); -f(35184367894527, 4194303); -f(35184376283136, 4194304); -f(35184384671745, 4194305); -f(70368744177663, 8388607); -f(70368752566272, 8388608); -f(70368760954881, 8388609); -x = 16777215; -f(0, 0); -f(16777215, 1); -f(33554430, 2); -f(50331645, 3); -f(67108860, 4); -f(83886075, 5); -f(117440505, 7); -f(134217720, 8); -f(150994935, 9); -f(251658225, 15); -f(268435440, 16); -f(285212655, 17); -f(520093665, 31); -f(536870880, 32); -f(553648095, 33); -f(1056964545, 63); -f(1073741760, 64); -f(1090518975, 65); -f(2130706305, 127); -f(2147483520, 128); -f(2164260735, 129); -f(4278189825, 255); -f(4294967040, 256); -f(4311744255, 257); -f(8573156865, 511); -f(8589934080, 512); -f(8606711295, 513); -f(17163090945, 1023); -f(17179868160, 1024); -f(17196645375, 1025); -f(34342959105, 2047); -f(34359736320, 2048); -f(34376513535, 2049); -f(68702695425, 4095); -f(68719472640, 4096); -f(68736249855, 4097); -f(137422168065, 8191); -f(137438945280, 8192); -f(137455722495, 8193); -f(274861113345, 16383); -f(274877890560, 16384); -f(274894667775, 16385); -f(549739003905, 32767); -f(549755781120, 32768); -f(549772558335, 32769); -f(1099494785025, 65535); -f(1099511562240, 65536); -f(1099528339455, 65537); -f(2199006347265, 131071); -f(2199023124480, 131072); -f(2199039901695, 131073); -f(4398029471745, 262143); -f(4398046248960, 262144); -f(4398063026175, 262145); -f(8796075720705, 524287); -f(8796092497920, 524288); -f(8796109275135, 524289); -f(17592168218625, 1048575); -f(17592184995840, 1048576); -f(17592201773055, 1048577); -f(35184353214465, 2097151); -f(35184369991680, 2097152); -f(35184386768895, 2097153); -f(70368723206145, 4194303); -f(70368739983360, 4194304); -f(70368756760575, 4194305); -f(140737463189505, 8388607); -f(140737479966720, 8388608); -f(140737496743935, 8388609); -f(281474943156225, 16777215); -x = 16777216; -f(0, 0); -f(16777216, 1); -f(33554432, 2); -f(50331648, 3); -f(67108864, 4); -f(83886080, 5); -f(117440512, 7); -f(134217728, 8); -f(150994944, 9); -f(251658240, 15); -f(268435456, 16); -f(285212672, 17); -f(520093696, 31); -f(536870912, 32); -f(553648128, 33); -f(1056964608, 63); -f(1073741824, 64); -f(1090519040, 65); -f(2130706432, 127); -f(2147483648, 128); -f(2164260864, 129); -f(4278190080, 255); -f(4294967296, 256); -f(4311744512, 257); -f(8573157376, 511); -f(8589934592, 512); -f(8606711808, 513); -f(17163091968, 1023); -f(17179869184, 1024); -f(17196646400, 1025); -f(34342961152, 2047); -f(34359738368, 2048); -f(34376515584, 2049); -f(68702699520, 4095); -f(68719476736, 4096); -f(68736253952, 4097); -f(137422176256, 8191); -f(137438953472, 8192); -f(137455730688, 8193); -f(274861129728, 16383); -f(274877906944, 16384); -f(274894684160, 16385); -f(549739036672, 32767); -f(549755813888, 32768); -f(549772591104, 32769); -f(1099494850560, 65535); -f(1099511627776, 65536); -f(1099528404992, 65537); -f(2199006478336, 131071); -f(2199023255552, 131072); -f(2199040032768, 131073); -f(4398029733888, 262143); -f(4398046511104, 262144); -f(4398063288320, 262145); -f(8796076244992, 524287); -f(8796093022208, 524288); -f(8796109799424, 524289); -f(17592169267200, 1048575); -f(17592186044416, 1048576); -f(17592202821632, 1048577); -f(35184355311616, 2097151); -f(35184372088832, 2097152); -f(35184388866048, 2097153); -f(70368727400448, 4194303); -f(70368744177664, 4194304); -f(70368760954880, 4194305); -f(140737471578112, 8388607); -f(140737488355328, 8388608); -f(140737505132544, 8388609); -f(281474959933440, 16777215); -f(281474976710656, 16777216); -x = 16777217; -f(0, 0); -f(16777217, 1); -f(33554434, 2); -f(50331651, 3); -f(67108868, 4); -f(83886085, 5); -f(117440519, 7); -f(134217736, 8); -f(150994953, 9); -f(251658255, 15); -f(268435472, 16); -f(285212689, 17); -f(520093727, 31); -f(536870944, 32); -f(553648161, 33); -f(1056964671, 63); -f(1073741888, 64); -f(1090519105, 65); -f(2130706559, 127); -f(2147483776, 128); -f(2164260993, 129); -f(4278190335, 255); -f(4294967552, 256); -f(4311744769, 257); -f(8573157887, 511); -f(8589935104, 512); -f(8606712321, 513); -f(17163092991, 1023); -f(17179870208, 1024); -f(17196647425, 1025); -f(34342963199, 2047); -f(34359740416, 2048); -f(34376517633, 2049); -f(68702703615, 4095); -f(68719480832, 4096); -f(68736258049, 4097); -f(137422184447, 8191); -f(137438961664, 8192); -f(137455738881, 8193); -f(274861146111, 16383); -f(274877923328, 16384); -f(274894700545, 16385); -f(549739069439, 32767); -f(549755846656, 32768); -f(549772623873, 32769); -f(1099494916095, 65535); -f(1099511693312, 65536); -f(1099528470529, 65537); -f(2199006609407, 131071); -f(2199023386624, 131072); -f(2199040163841, 131073); -f(4398029996031, 262143); -f(4398046773248, 262144); -f(4398063550465, 262145); -f(8796076769279, 524287); -f(8796093546496, 524288); -f(8796110323713, 524289); -f(17592170315775, 1048575); -f(17592187092992, 1048576); -f(17592203870209, 1048577); -f(35184357408767, 2097151); -f(35184374185984, 2097152); -f(35184390963201, 2097153); -f(70368731594751, 4194303); -f(70368748371968, 4194304); -f(70368765149185, 4194305); -f(140737479966719, 8388607); -f(140737496743936, 8388608); -f(140737513521153, 8388609); -f(281474976710655, 16777215); -f(281474993487872, 16777216); -f(281475010265089, 16777217); -x = 33554431; -f(0, 0); -f(33554431, 1); -f(67108862, 2); -f(100663293, 3); -f(134217724, 4); -f(167772155, 5); -f(234881017, 7); -f(268435448, 8); -f(301989879, 9); -f(503316465, 15); -f(536870896, 16); -f(570425327, 17); -f(1040187361, 31); -f(1073741792, 32); -f(1107296223, 33); -f(2113929153, 63); -f(2147483584, 64); -f(2181038015, 65); -f(4261412737, 127); -f(4294967168, 128); -f(4328521599, 129); -f(8556379905, 255); -f(8589934336, 256); -f(8623488767, 257); -f(17146314241, 511); -f(17179868672, 512); -f(17213423103, 513); -f(34326182913, 1023); -f(34359737344, 1024); -f(34393291775, 1025); -f(68685920257, 2047); -f(68719474688, 2048); -f(68753029119, 2049); -f(137405394945, 4095); -f(137438949376, 4096); -f(137472503807, 4097); -f(274844344321, 8191); -f(274877898752, 8192); -f(274911453183, 8193); -f(549722243073, 16383); -f(549755797504, 16384); -f(549789351935, 16385); -f(1099478040577, 32767); -f(1099511595008, 32768); -f(1099545149439, 32769); -f(2198989635585, 65535); -f(2199023190016, 65536); -f(2199056744447, 65537); -f(4398012825601, 131071); -f(4398046380032, 131072); -f(4398079934463, 131073); -f(8796059205633, 262143); -f(8796092760064, 262144); -f(8796126314495, 262145); -f(17592151965697, 524287); -f(17592185520128, 524288); -f(17592219074559, 524289); -f(35184337485825, 1048575); -f(35184371040256, 1048576); -f(35184404594687, 1048577); -f(70368708526081, 2097151); -f(70368742080512, 2097152); -f(70368775634943, 2097153); -f(140737450606593, 4194303); -f(140737484161024, 4194304); -f(140737517715455, 4194305); -f(281474934767617, 8388607); -f(281474968322048, 8388608); -f(281475001876479, 8388609); -f(562949903089665, 16777215); -f(562949936644096, 16777216); -f(562949970198527, 16777217); -f(1125899839733761, 33554431); -x = 33554432; -f(0, 0); -f(33554432, 1); -f(67108864, 2); -f(100663296, 3); -f(134217728, 4); -f(167772160, 5); -f(234881024, 7); -f(268435456, 8); -f(301989888, 9); -f(503316480, 15); -f(536870912, 16); -f(570425344, 17); -f(1040187392, 31); -f(1073741824, 32); -f(1107296256, 33); -f(2113929216, 63); -f(2147483648, 64); -f(2181038080, 65); -f(4261412864, 127); -f(4294967296, 128); -f(4328521728, 129); -f(8556380160, 255); -f(8589934592, 256); -f(8623489024, 257); -f(17146314752, 511); -f(17179869184, 512); -f(17213423616, 513); -f(34326183936, 1023); -f(34359738368, 1024); -f(34393292800, 1025); -f(68685922304, 2047); -f(68719476736, 2048); -f(68753031168, 2049); -f(137405399040, 4095); -f(137438953472, 4096); -f(137472507904, 4097); -f(274844352512, 8191); -f(274877906944, 8192); -f(274911461376, 8193); -f(549722259456, 16383); -f(549755813888, 16384); -f(549789368320, 16385); -f(1099478073344, 32767); -f(1099511627776, 32768); -f(1099545182208, 32769); -f(2198989701120, 65535); -f(2199023255552, 65536); -f(2199056809984, 65537); -f(4398012956672, 131071); -f(4398046511104, 131072); -f(4398080065536, 131073); -f(8796059467776, 262143); -f(8796093022208, 262144); -f(8796126576640, 262145); -f(17592152489984, 524287); -f(17592186044416, 524288); -f(17592219598848, 524289); -f(35184338534400, 1048575); -f(35184372088832, 1048576); -f(35184405643264, 1048577); -f(70368710623232, 2097151); -f(70368744177664, 2097152); -f(70368777732096, 2097153); -f(140737454800896, 4194303); -f(140737488355328, 4194304); -f(140737521909760, 4194305); -f(281474943156224, 8388607); -f(281474976710656, 8388608); -f(281475010265088, 8388609); -f(562949919866880, 16777215); -f(562949953421312, 16777216); -f(562949986975744, 16777217); -f(1125899873288192, 33554431); -f(1125899906842624, 33554432); -x = 33554433; -f(0, 0); -f(33554433, 1); -f(67108866, 2); -f(100663299, 3); -f(134217732, 4); -f(167772165, 5); -f(234881031, 7); -f(268435464, 8); -f(301989897, 9); -f(503316495, 15); -f(536870928, 16); -f(570425361, 17); -f(1040187423, 31); -f(1073741856, 32); -f(1107296289, 33); -f(2113929279, 63); -f(2147483712, 64); -f(2181038145, 65); -f(4261412991, 127); -f(4294967424, 128); -f(4328521857, 129); -f(8556380415, 255); -f(8589934848, 256); -f(8623489281, 257); -f(17146315263, 511); -f(17179869696, 512); -f(17213424129, 513); -f(34326184959, 1023); -f(34359739392, 1024); -f(34393293825, 1025); -f(68685924351, 2047); -f(68719478784, 2048); -f(68753033217, 2049); -f(137405403135, 4095); -f(137438957568, 4096); -f(137472512001, 4097); -f(274844360703, 8191); -f(274877915136, 8192); -f(274911469569, 8193); -f(549722275839, 16383); -f(549755830272, 16384); -f(549789384705, 16385); -f(1099478106111, 32767); -f(1099511660544, 32768); -f(1099545214977, 32769); -f(2198989766655, 65535); -f(2199023321088, 65536); -f(2199056875521, 65537); -f(4398013087743, 131071); -f(4398046642176, 131072); -f(4398080196609, 131073); -f(8796059729919, 262143); -f(8796093284352, 262144); -f(8796126838785, 262145); -f(17592153014271, 524287); -f(17592186568704, 524288); -f(17592220123137, 524289); -f(35184339582975, 1048575); -f(35184373137408, 1048576); -f(35184406691841, 1048577); -f(70368712720383, 2097151); -f(70368746274816, 2097152); -f(70368779829249, 2097153); -f(140737458995199, 4194303); -f(140737492549632, 4194304); -f(140737526104065, 4194305); -f(281474951544831, 8388607); -f(281474985099264, 8388608); -f(281475018653697, 8388609); -f(562949936644095, 16777215); -f(562949970198528, 16777216); -f(562950003752961, 16777217); -f(1125899906842623, 33554431); -f(1125899940397056, 33554432); -f(1125899973951489, 33554433); -x = 67108863; -f(0, 0); -f(67108863, 1); -f(134217726, 2); -f(201326589, 3); -f(268435452, 4); -f(335544315, 5); -f(469762041, 7); -f(536870904, 8); -f(603979767, 9); -f(1006632945, 15); -f(1073741808, 16); -f(1140850671, 17); -f(2080374753, 31); -f(2147483616, 32); -f(2214592479, 33); -f(4227858369, 63); -f(4294967232, 64); -f(4362076095, 65); -f(8522825601, 127); -f(8589934464, 128); -f(8657043327, 129); -f(17112760065, 255); -f(17179868928, 256); -f(17246977791, 257); -f(34292628993, 511); -f(34359737856, 512); -f(34426846719, 513); -f(68652366849, 1023); -f(68719475712, 1024); -f(68786584575, 1025); -f(137371842561, 2047); -f(137438951424, 2048); -f(137506060287, 2049); -f(274810793985, 4095); -f(274877902848, 4096); -f(274945011711, 4097); -f(549688696833, 8191); -f(549755805696, 8192); -f(549822914559, 8193); -f(1099444502529, 16383); -f(1099511611392, 16384); -f(1099578720255, 16385); -f(2198956113921, 32767); -f(2199023222784, 32768); -f(2199090331647, 32769); -f(4397979336705, 65535); -f(4398046445568, 65536); -f(4398113554431, 65537); -f(8796025782273, 131071); -f(8796092891136, 131072); -f(8796159999999, 131073); -f(17592118673409, 262143); -f(17592185782272, 262144); -f(17592252891135, 262145); -f(35184304455681, 524287); -f(35184371564544, 524288); -f(35184438673407, 524289); -f(70368676020225, 1048575); -f(70368743129088, 1048576); -f(70368810237951, 1048577); -f(140737419149313, 2097151); -f(140737486258176, 2097152); -f(140737553367039, 2097153); -f(281474905407489, 4194303); -f(281474972516352, 4194304); -f(281475039625215, 4194305); -f(562949877923841, 8388607); -f(562949945032704, 8388608); -f(562950012141567, 8388609); -f(1125899822956545, 16777215); -f(1125899890065408, 16777216); -f(1125899957174271, 16777217); -x = 67108864; -f(0, 0); -f(67108864, 1); -f(134217728, 2); -f(201326592, 3); -f(268435456, 4); -f(335544320, 5); -f(469762048, 7); -f(536870912, 8); -f(603979776, 9); -f(1006632960, 15); -f(1073741824, 16); -f(1140850688, 17); -f(2080374784, 31); -f(2147483648, 32); -f(2214592512, 33); -f(4227858432, 63); -f(4294967296, 64); -f(4362076160, 65); -f(8522825728, 127); -f(8589934592, 128); -f(8657043456, 129); -f(17112760320, 255); -f(17179869184, 256); -f(17246978048, 257); -f(34292629504, 511); -f(34359738368, 512); -f(34426847232, 513); -f(68652367872, 1023); -f(68719476736, 1024); -f(68786585600, 1025); -f(137371844608, 2047); -f(137438953472, 2048); -f(137506062336, 2049); -f(274810798080, 4095); -f(274877906944, 4096); -f(274945015808, 4097); -f(549688705024, 8191); -f(549755813888, 8192); -f(549822922752, 8193); -f(1099444518912, 16383); -f(1099511627776, 16384); -f(1099578736640, 16385); -f(2198956146688, 32767); -f(2199023255552, 32768); -f(2199090364416, 32769); -f(4397979402240, 65535); -f(4398046511104, 65536); -f(4398113619968, 65537); -f(8796025913344, 131071); -f(8796093022208, 131072); -f(8796160131072, 131073); -f(17592118935552, 262143); -f(17592186044416, 262144); -f(17592253153280, 262145); -f(35184304979968, 524287); -f(35184372088832, 524288); -f(35184439197696, 524289); -f(70368677068800, 1048575); -f(70368744177664, 1048576); -f(70368811286528, 1048577); -f(140737421246464, 2097151); -f(140737488355328, 2097152); -f(140737555464192, 2097153); -f(281474909601792, 4194303); -f(281474976710656, 4194304); -f(281475043819520, 4194305); -f(562949886312448, 8388607); -f(562949953421312, 8388608); -f(562950020530176, 8388609); -f(1125899839733760, 16777215); -f(1125899906842624, 16777216); -f(1125899973951488, 16777217); -x = 67108865; -f(0, 0); -f(67108865, 1); -f(134217730, 2); -f(201326595, 3); -f(268435460, 4); -f(335544325, 5); -f(469762055, 7); -f(536870920, 8); -f(603979785, 9); -f(1006632975, 15); -f(1073741840, 16); -f(1140850705, 17); -f(2080374815, 31); -f(2147483680, 32); -f(2214592545, 33); -f(4227858495, 63); -f(4294967360, 64); -f(4362076225, 65); -f(8522825855, 127); -f(8589934720, 128); -f(8657043585, 129); -f(17112760575, 255); -f(17179869440, 256); -f(17246978305, 257); -f(34292630015, 511); -f(34359738880, 512); -f(34426847745, 513); -f(68652368895, 1023); -f(68719477760, 1024); -f(68786586625, 1025); -f(137371846655, 2047); -f(137438955520, 2048); -f(137506064385, 2049); -f(274810802175, 4095); -f(274877911040, 4096); -f(274945019905, 4097); -f(549688713215, 8191); -f(549755822080, 8192); -f(549822930945, 8193); -f(1099444535295, 16383); -f(1099511644160, 16384); -f(1099578753025, 16385); -f(2198956179455, 32767); -f(2199023288320, 32768); -f(2199090397185, 32769); -f(4397979467775, 65535); -f(4398046576640, 65536); -f(4398113685505, 65537); -f(8796026044415, 131071); -f(8796093153280, 131072); -f(8796160262145, 131073); -f(17592119197695, 262143); -f(17592186306560, 262144); -f(17592253415425, 262145); -f(35184305504255, 524287); -f(35184372613120, 524288); -f(35184439721985, 524289); -f(70368678117375, 1048575); -f(70368745226240, 1048576); -f(70368812335105, 1048577); -f(140737423343615, 2097151); -f(140737490452480, 2097152); -f(140737557561345, 2097153); -f(281474913796095, 4194303); -f(281474980904960, 4194304); -f(281475048013825, 4194305); -f(562949894701055, 8388607); -f(562949961809920, 8388608); -f(562950028918785, 8388609); -f(1125899856510975, 16777215); -f(1125899923619840, 16777216); -f(1125899990728705, 16777217); -x = 134217727; -f(0, 0); -f(134217727, 1); -f(268435454, 2); -f(402653181, 3); -f(536870908, 4); -f(671088635, 5); -f(939524089, 7); -f(1073741816, 8); -f(1207959543, 9); -f(2013265905, 15); -f(2147483632, 16); -f(2281701359, 17); -f(4160749537, 31); -f(4294967264, 32); -f(4429184991, 33); -f(8455716801, 63); -f(8589934528, 64); -f(8724152255, 65); -f(17045651329, 127); -f(17179869056, 128); -f(17314086783, 129); -f(34225520385, 255); -f(34359738112, 256); -f(34493955839, 257); -f(68585258497, 511); -f(68719476224, 512); -f(68853693951, 513); -f(137304734721, 1023); -f(137438952448, 1024); -f(137573170175, 1025); -f(274743687169, 2047); -f(274877904896, 2048); -f(275012122623, 2049); -f(549621592065, 4095); -f(549755809792, 4096); -f(549890027519, 4097); -f(1099377401857, 8191); -f(1099511619584, 8192); -f(1099645837311, 8193); -f(2198889021441, 16383); -f(2199023239168, 16384); -f(2199157456895, 16385); -f(4397912260609, 32767); -f(4398046478336, 32768); -f(4398180696063, 32769); -f(8795958738945, 65535); -f(8796092956672, 65536); -f(8796227174399, 65537); -f(17592051695617, 131071); -f(17592185913344, 131072); -f(17592320131071, 131073); -f(35184237608961, 262143); -f(35184371826688, 262144); -f(35184506044415, 262145); -f(70368609435649, 524287); -f(70368743653376, 524288); -f(70368877871103, 524289); -f(140737353089025, 1048575); -f(140737487306752, 1048576); -f(140737621524479, 1048577); -f(281474840395777, 2097151); -f(281474974613504, 2097152); -f(281475108831231, 2097153); -f(562949815009281, 4194303); -f(562949949227008, 4194304); -f(562950083444735, 4194305); -f(1125899764236289, 8388607); -f(1125899898454016, 8388608); -f(1125900032671743, 8388609); -x = 134217728; -f(0, 0); -f(134217728, 1); -f(268435456, 2); -f(402653184, 3); -f(536870912, 4); -f(671088640, 5); -f(939524096, 7); -f(1073741824, 8); -f(1207959552, 9); -f(2013265920, 15); -f(2147483648, 16); -f(2281701376, 17); -f(4160749568, 31); -f(4294967296, 32); -f(4429185024, 33); -f(8455716864, 63); -f(8589934592, 64); -f(8724152320, 65); -f(17045651456, 127); -f(17179869184, 128); -f(17314086912, 129); -f(34225520640, 255); -f(34359738368, 256); -f(34493956096, 257); -f(68585259008, 511); -f(68719476736, 512); -f(68853694464, 513); -f(137304735744, 1023); -f(137438953472, 1024); -f(137573171200, 1025); -f(274743689216, 2047); -f(274877906944, 2048); -f(275012124672, 2049); -f(549621596160, 4095); -f(549755813888, 4096); -f(549890031616, 4097); -f(1099377410048, 8191); -f(1099511627776, 8192); -f(1099645845504, 8193); -f(2198889037824, 16383); -f(2199023255552, 16384); -f(2199157473280, 16385); -f(4397912293376, 32767); -f(4398046511104, 32768); -f(4398180728832, 32769); -f(8795958804480, 65535); -f(8796093022208, 65536); -f(8796227239936, 65537); -f(17592051826688, 131071); -f(17592186044416, 131072); -f(17592320262144, 131073); -f(35184237871104, 262143); -f(35184372088832, 262144); -f(35184506306560, 262145); -f(70368609959936, 524287); -f(70368744177664, 524288); -f(70368878395392, 524289); -f(140737354137600, 1048575); -f(140737488355328, 1048576); -f(140737622573056, 1048577); -f(281474842492928, 2097151); -f(281474976710656, 2097152); -f(281475110928384, 2097153); -f(562949819203584, 4194303); -f(562949953421312, 4194304); -f(562950087639040, 4194305); -f(1125899772624896, 8388607); -f(1125899906842624, 8388608); -f(1125900041060352, 8388609); -x = 134217729; -f(0, 0); -f(134217729, 1); -f(268435458, 2); -f(402653187, 3); -f(536870916, 4); -f(671088645, 5); -f(939524103, 7); -f(1073741832, 8); -f(1207959561, 9); -f(2013265935, 15); -f(2147483664, 16); -f(2281701393, 17); -f(4160749599, 31); -f(4294967328, 32); -f(4429185057, 33); -f(8455716927, 63); -f(8589934656, 64); -f(8724152385, 65); -f(17045651583, 127); -f(17179869312, 128); -f(17314087041, 129); -f(34225520895, 255); -f(34359738624, 256); -f(34493956353, 257); -f(68585259519, 511); -f(68719477248, 512); -f(68853694977, 513); -f(137304736767, 1023); -f(137438954496, 1024); -f(137573172225, 1025); -f(274743691263, 2047); -f(274877908992, 2048); -f(275012126721, 2049); -f(549621600255, 4095); -f(549755817984, 4096); -f(549890035713, 4097); -f(1099377418239, 8191); -f(1099511635968, 8192); -f(1099645853697, 8193); -f(2198889054207, 16383); -f(2199023271936, 16384); -f(2199157489665, 16385); -f(4397912326143, 32767); -f(4398046543872, 32768); -f(4398180761601, 32769); -f(8795958870015, 65535); -f(8796093087744, 65536); -f(8796227305473, 65537); -f(17592051957759, 131071); -f(17592186175488, 131072); -f(17592320393217, 131073); -f(35184238133247, 262143); -f(35184372350976, 262144); -f(35184506568705, 262145); -f(70368610484223, 524287); -f(70368744701952, 524288); -f(70368878919681, 524289); -f(140737355186175, 1048575); -f(140737489403904, 1048576); -f(140737623621633, 1048577); -f(281474844590079, 2097151); -f(281474978807808, 2097152); -f(281475113025537, 2097153); -f(562949823397887, 4194303); -f(562949957615616, 4194304); -f(562950091833345, 4194305); -f(1125899781013503, 8388607); -f(1125899915231232, 8388608); -f(1125900049448961, 8388609); -x = 268435455; -f(0, 0); -f(268435455, 1); -f(536870910, 2); -f(805306365, 3); -f(1073741820, 4); -f(1342177275, 5); -f(1879048185, 7); -f(2147483640, 8); -f(2415919095, 9); -f(4026531825, 15); -f(4294967280, 16); -f(4563402735, 17); -f(8321499105, 31); -f(8589934560, 32); -f(8858370015, 33); -f(16911433665, 63); -f(17179869120, 64); -f(17448304575, 65); -f(34091302785, 127); -f(34359738240, 128); -f(34628173695, 129); -f(68451041025, 255); -f(68719476480, 256); -f(68987911935, 257); -f(137170517505, 511); -f(137438952960, 512); -f(137707388415, 513); -f(274609470465, 1023); -f(274877905920, 1024); -f(275146341375, 1025); -f(549487376385, 2047); -f(549755811840, 2048); -f(550024247295, 2049); -f(1099243188225, 4095); -f(1099511623680, 4096); -f(1099780059135, 4097); -f(2198754811905, 8191); -f(2199023247360, 8192); -f(2199291682815, 8193); -f(4397778059265, 16383); -f(4398046494720, 16384); -f(4398314930175, 16385); -f(8795824553985, 32767); -f(8796092989440, 32768); -f(8796361424895, 32769); -f(17591917543425, 65535); -f(17592185978880, 65536); -f(17592454414335, 65537); -f(35184103522305, 131071); -f(35184371957760, 131072); -f(35184640393215, 131073); -f(70368475480065, 262143); -f(70368743915520, 262144); -f(70369012350975, 262145); -f(140737219395585, 524287); -f(140737487831040, 524288); -f(140737756266495, 524289); -f(281474707226625, 1048575); -f(281474975662080, 1048576); -f(281475244097535, 1048577); -f(562949682888705, 2097151); -f(562949951324160, 2097152); -f(562950219759615, 2097153); -f(1125899634212865, 4194303); -f(1125899902648320, 4194304); -f(1125900171083775, 4194305); -x = 268435456; -f(0, 0); -f(268435456, 1); -f(536870912, 2); -f(805306368, 3); -f(1073741824, 4); -f(1342177280, 5); -f(1879048192, 7); -f(2147483648, 8); -f(2415919104, 9); -f(4026531840, 15); -f(4294967296, 16); -f(4563402752, 17); -f(8321499136, 31); -f(8589934592, 32); -f(8858370048, 33); -f(16911433728, 63); -f(17179869184, 64); -f(17448304640, 65); -f(34091302912, 127); -f(34359738368, 128); -f(34628173824, 129); -f(68451041280, 255); -f(68719476736, 256); -f(68987912192, 257); -f(137170518016, 511); -f(137438953472, 512); -f(137707388928, 513); -f(274609471488, 1023); -f(274877906944, 1024); -f(275146342400, 1025); -f(549487378432, 2047); -f(549755813888, 2048); -f(550024249344, 2049); -f(1099243192320, 4095); -f(1099511627776, 4096); -f(1099780063232, 4097); -f(2198754820096, 8191); -f(2199023255552, 8192); -f(2199291691008, 8193); -f(4397778075648, 16383); -f(4398046511104, 16384); -f(4398314946560, 16385); -f(8795824586752, 32767); -f(8796093022208, 32768); -f(8796361457664, 32769); -f(17591917608960, 65535); -f(17592186044416, 65536); -f(17592454479872, 65537); -f(35184103653376, 131071); -f(35184372088832, 131072); -f(35184640524288, 131073); -f(70368475742208, 262143); -f(70368744177664, 262144); -f(70369012613120, 262145); -f(140737219919872, 524287); -f(140737488355328, 524288); -f(140737756790784, 524289); -f(281474708275200, 1048575); -f(281474976710656, 1048576); -f(281475245146112, 1048577); -f(562949684985856, 2097151); -f(562949953421312, 2097152); -f(562950221856768, 2097153); -f(1125899638407168, 4194303); -f(1125899906842624, 4194304); -f(1125900175278080, 4194305); -x = 268435457; -f(0, 0); -f(268435457, 1); -f(536870914, 2); -f(805306371, 3); -f(1073741828, 4); -f(1342177285, 5); -f(1879048199, 7); -f(2147483656, 8); -f(2415919113, 9); -f(4026531855, 15); -f(4294967312, 16); -f(4563402769, 17); -f(8321499167, 31); -f(8589934624, 32); -f(8858370081, 33); -f(16911433791, 63); -f(17179869248, 64); -f(17448304705, 65); -f(34091303039, 127); -f(34359738496, 128); -f(34628173953, 129); -f(68451041535, 255); -f(68719476992, 256); -f(68987912449, 257); -f(137170518527, 511); -f(137438953984, 512); -f(137707389441, 513); -f(274609472511, 1023); -f(274877907968, 1024); -f(275146343425, 1025); -f(549487380479, 2047); -f(549755815936, 2048); -f(550024251393, 2049); -f(1099243196415, 4095); -f(1099511631872, 4096); -f(1099780067329, 4097); -f(2198754828287, 8191); -f(2199023263744, 8192); -f(2199291699201, 8193); -f(4397778092031, 16383); -f(4398046527488, 16384); -f(4398314962945, 16385); -f(8795824619519, 32767); -f(8796093054976, 32768); -f(8796361490433, 32769); -f(17591917674495, 65535); -f(17592186109952, 65536); -f(17592454545409, 65537); -f(35184103784447, 131071); -f(35184372219904, 131072); -f(35184640655361, 131073); -f(70368476004351, 262143); -f(70368744439808, 262144); -f(70369012875265, 262145); -f(140737220444159, 524287); -f(140737488879616, 524288); -f(140737757315073, 524289); -f(281474709323775, 1048575); -f(281474977759232, 1048576); -f(281475246194689, 1048577); -f(562949687083007, 2097151); -f(562949955518464, 2097152); -f(562950223953921, 2097153); -f(1125899642601471, 4194303); -f(1125899911036928, 4194304); -f(1125900179472385, 4194305); -x = 536870911; -f(0, 0); -f(536870911, 1); -f(1073741822, 2); -f(1610612733, 3); -f(2147483644, 4); -f(2684354555, 5); -f(3758096377, 7); -f(4294967288, 8); -f(4831838199, 9); -f(8053063665, 15); -f(8589934576, 16); -f(9126805487, 17); -f(16642998241, 31); -f(17179869152, 32); -f(17716740063, 33); -f(33822867393, 63); -f(34359738304, 64); -f(34896609215, 65); -f(68182605697, 127); -f(68719476608, 128); -f(69256347519, 129); -f(136902082305, 255); -f(137438953216, 256); -f(137975824127, 257); -f(274341035521, 511); -f(274877906432, 512); -f(275414777343, 513); -f(549218941953, 1023); -f(549755812864, 1024); -f(550292683775, 1025); -f(1098974754817, 2047); -f(1099511625728, 2048); -f(1100048496639, 2049); -f(2198486380545, 4095); -f(2199023251456, 4096); -f(2199560122367, 4097); -f(4397509632001, 8191); -f(4398046502912, 8192); -f(4398583373823, 8193); -f(8795556134913, 16383); -f(8796093005824, 16384); -f(8796629876735, 16385); -f(17591649140737, 32767); -f(17592186011648, 32768); -f(17592722882559, 32769); -f(35183835152385, 65535); -f(35184372023296, 65536); -f(35184908894207, 65537); -f(70368207175681, 131071); -f(70368744046592, 131072); -f(70369280917503, 131073); -f(140736951222273, 262143); -f(140737488093184, 262144); -f(140738024964095, 262145); -f(281474439315457, 524287); -f(281474976186368, 524288); -f(281475513057279, 524289); -f(562949415501825, 1048575); -f(562949952372736, 1048576); -f(562950489243647, 1048577); -f(1125899367874561, 2097151); -f(1125899904745472, 2097152); -f(1125900441616383, 2097153); -x = 536870912; -f(0, 0); -f(536870912, 1); -f(1073741824, 2); -f(1610612736, 3); -f(2147483648, 4); -f(2684354560, 5); -f(3758096384, 7); -f(4294967296, 8); -f(4831838208, 9); -f(8053063680, 15); -f(8589934592, 16); -f(9126805504, 17); -f(16642998272, 31); -f(17179869184, 32); -f(17716740096, 33); -f(33822867456, 63); -f(34359738368, 64); -f(34896609280, 65); -f(68182605824, 127); -f(68719476736, 128); -f(69256347648, 129); -f(136902082560, 255); -f(137438953472, 256); -f(137975824384, 257); -f(274341036032, 511); -f(274877906944, 512); -f(275414777856, 513); -f(549218942976, 1023); -f(549755813888, 1024); -f(550292684800, 1025); -f(1098974756864, 2047); -f(1099511627776, 2048); -f(1100048498688, 2049); -f(2198486384640, 4095); -f(2199023255552, 4096); -f(2199560126464, 4097); -f(4397509640192, 8191); -f(4398046511104, 8192); -f(4398583382016, 8193); -f(8795556151296, 16383); -f(8796093022208, 16384); -f(8796629893120, 16385); -f(17591649173504, 32767); -f(17592186044416, 32768); -f(17592722915328, 32769); -f(35183835217920, 65535); -f(35184372088832, 65536); -f(35184908959744, 65537); -f(70368207306752, 131071); -f(70368744177664, 131072); -f(70369281048576, 131073); -f(140736951484416, 262143); -f(140737488355328, 262144); -f(140738025226240, 262145); -f(281474439839744, 524287); -f(281474976710656, 524288); -f(281475513581568, 524289); -f(562949416550400, 1048575); -f(562949953421312, 1048576); -f(562950490292224, 1048577); -f(1125899369971712, 2097151); -f(1125899906842624, 2097152); -f(1125900443713536, 2097153); -x = 536870913; -f(0, 0); -f(536870913, 1); -f(1073741826, 2); -f(1610612739, 3); -f(2147483652, 4); -f(2684354565, 5); -f(3758096391, 7); -f(4294967304, 8); -f(4831838217, 9); -f(8053063695, 15); -f(8589934608, 16); -f(9126805521, 17); -f(16642998303, 31); -f(17179869216, 32); -f(17716740129, 33); -f(33822867519, 63); -f(34359738432, 64); -f(34896609345, 65); -f(68182605951, 127); -f(68719476864, 128); -f(69256347777, 129); -f(136902082815, 255); -f(137438953728, 256); -f(137975824641, 257); -f(274341036543, 511); -f(274877907456, 512); -f(275414778369, 513); -f(549218943999, 1023); -f(549755814912, 1024); -f(550292685825, 1025); -f(1098974758911, 2047); -f(1099511629824, 2048); -f(1100048500737, 2049); -f(2198486388735, 4095); -f(2199023259648, 4096); -f(2199560130561, 4097); -f(4397509648383, 8191); -f(4398046519296, 8192); -f(4398583390209, 8193); -f(8795556167679, 16383); -f(8796093038592, 16384); -f(8796629909505, 16385); -f(17591649206271, 32767); -f(17592186077184, 32768); -f(17592722948097, 32769); -f(35183835283455, 65535); -f(35184372154368, 65536); -f(35184909025281, 65537); -f(70368207437823, 131071); -f(70368744308736, 131072); -f(70369281179649, 131073); -f(140736951746559, 262143); -f(140737488617472, 262144); -f(140738025488385, 262145); -f(281474440364031, 524287); -f(281474977234944, 524288); -f(281475514105857, 524289); -f(562949417598975, 1048575); -f(562949954469888, 1048576); -f(562950491340801, 1048577); -f(1125899372068863, 2097151); -f(1125899908939776, 2097152); -f(1125900445810689, 2097153); -x = 1073741823; -f(0, 0); -f(1073741823, 1); -f(2147483646, 2); -f(3221225469, 3); -f(4294967292, 4); -f(5368709115, 5); -f(7516192761, 7); -f(8589934584, 8); -f(9663676407, 9); -f(16106127345, 15); -f(17179869168, 16); -f(18253610991, 17); -f(33285996513, 31); -f(34359738336, 32); -f(35433480159, 33); -f(67645734849, 63); -f(68719476672, 64); -f(69793218495, 65); -f(136365211521, 127); -f(137438953344, 128); -f(138512695167, 129); -f(273804164865, 255); -f(274877906688, 256); -f(275951648511, 257); -f(548682071553, 511); -f(549755813376, 512); -f(550829555199, 513); -f(1098437884929, 1023); -f(1099511626752, 1024); -f(1100585368575, 1025); -f(2197949511681, 2047); -f(2199023253504, 2048); -f(2200096995327, 2049); -f(4396972765185, 4095); -f(4398046507008, 4096); -f(4399120248831, 4097); -f(8795019272193, 8191); -f(8796093014016, 8192); -f(8797166755839, 8193); -f(17591112286209, 16383); -f(17592186028032, 16384); -f(17593259769855, 16385); -f(35183298314241, 32767); -f(35184372056064, 32768); -f(35185445797887, 32769); -f(70367670370305, 65535); -f(70368744112128, 65536); -f(70369817853951, 65537); -f(140736414482433, 131071); -f(140737488224256, 131072); -f(140738561966079, 131073); -f(281473902706689, 262143); -f(281474976448512, 262144); -f(281476050190335, 262145); -f(562948879155201, 524287); -f(562949952897024, 524288); -f(562951026638847, 524289); -f(1125898832052225, 1048575); -f(1125899905794048, 1048576); -f(1125900979535871, 1048577); -x = 1073741824; -f(0, 0); -f(1073741824, 1); -f(2147483648, 2); -f(3221225472, 3); -f(4294967296, 4); -f(5368709120, 5); -f(7516192768, 7); -f(8589934592, 8); -f(9663676416, 9); -f(16106127360, 15); -f(17179869184, 16); -f(18253611008, 17); -f(33285996544, 31); -f(34359738368, 32); -f(35433480192, 33); -f(67645734912, 63); -f(68719476736, 64); -f(69793218560, 65); -f(136365211648, 127); -f(137438953472, 128); -f(138512695296, 129); -f(273804165120, 255); -f(274877906944, 256); -f(275951648768, 257); -f(548682072064, 511); -f(549755813888, 512); -f(550829555712, 513); -f(1098437885952, 1023); -f(1099511627776, 1024); -f(1100585369600, 1025); -f(2197949513728, 2047); -f(2199023255552, 2048); -f(2200096997376, 2049); -f(4396972769280, 4095); -f(4398046511104, 4096); -f(4399120252928, 4097); -f(8795019280384, 8191); -f(8796093022208, 8192); -f(8797166764032, 8193); -f(17591112302592, 16383); -f(17592186044416, 16384); -f(17593259786240, 16385); -f(35183298347008, 32767); -f(35184372088832, 32768); -f(35185445830656, 32769); -f(70367670435840, 65535); -f(70368744177664, 65536); -f(70369817919488, 65537); -f(140736414613504, 131071); -f(140737488355328, 131072); -f(140738562097152, 131073); -f(281473902968832, 262143); -f(281474976710656, 262144); -f(281476050452480, 262145); -f(562948879679488, 524287); -f(562949953421312, 524288); -f(562951027163136, 524289); -f(1125898833100800, 1048575); -f(1125899906842624, 1048576); -f(1125900980584448, 1048577); -x = 1073741825; -f(0, 0); -f(1073741825, 1); -f(2147483650, 2); -f(3221225475, 3); -f(4294967300, 4); -f(5368709125, 5); -f(7516192775, 7); -f(8589934600, 8); -f(9663676425, 9); -f(16106127375, 15); -f(17179869200, 16); -f(18253611025, 17); -f(33285996575, 31); -f(34359738400, 32); -f(35433480225, 33); -f(67645734975, 63); -f(68719476800, 64); -f(69793218625, 65); -f(136365211775, 127); -f(137438953600, 128); -f(138512695425, 129); -f(273804165375, 255); -f(274877907200, 256); -f(275951649025, 257); -f(548682072575, 511); -f(549755814400, 512); -f(550829556225, 513); -f(1098437886975, 1023); -f(1099511628800, 1024); -f(1100585370625, 1025); -f(2197949515775, 2047); -f(2199023257600, 2048); -f(2200096999425, 2049); -f(4396972773375, 4095); -f(4398046515200, 4096); -f(4399120257025, 4097); -f(8795019288575, 8191); -f(8796093030400, 8192); -f(8797166772225, 8193); -f(17591112318975, 16383); -f(17592186060800, 16384); -f(17593259802625, 16385); -f(35183298379775, 32767); -f(35184372121600, 32768); -f(35185445863425, 32769); -f(70367670501375, 65535); -f(70368744243200, 65536); -f(70369817985025, 65537); -f(140736414744575, 131071); -f(140737488486400, 131072); -f(140738562228225, 131073); -f(281473903230975, 262143); -f(281474976972800, 262144); -f(281476050714625, 262145); -f(562948880203775, 524287); -f(562949953945600, 524288); -f(562951027687425, 524289); -f(1125898834149375, 1048575); -f(1125899907891200, 1048576); -f(1125900981633025, 1048577); -x = 2147483647; -f(0, 0); -f(2147483647, 1); -f(4294967294, 2); -f(6442450941, 3); -f(8589934588, 4); -f(10737418235, 5); -f(15032385529, 7); -f(17179869176, 8); -f(19327352823, 9); -f(32212254705, 15); -f(34359738352, 16); -f(36507221999, 17); -f(66571993057, 31); -f(68719476704, 32); -f(70866960351, 33); -f(135291469761, 63); -f(137438953408, 64); -f(139586437055, 65); -f(272730423169, 127); -f(274877906816, 128); -f(277025390463, 129); -f(547608329985, 255); -f(549755813632, 256); -f(551903297279, 257); -f(1097364143617, 511); -f(1099511627264, 512); -f(1101659110911, 513); -f(2196875770881, 1023); -f(2199023254528, 1024); -f(2201170738175, 1025); -f(4395899025409, 2047); -f(4398046509056, 2048); -f(4400193992703, 2049); -f(8793945534465, 4095); -f(8796093018112, 4096); -f(8798240501759, 4097); -f(17590038552577, 8191); -f(17592186036224, 8192); -f(17594333519871, 8193); -f(35182224588801, 16383); -f(35184372072448, 16384); -f(35186519556095, 16385); -f(70366596661249, 32767); -f(70368744144896, 32768); -f(70370891628543, 32769); -f(140735340806145, 65535); -f(140737488289792, 65536); -f(140739635773439, 65537); -f(281472829095937, 131071); -f(281474976579584, 131072); -f(281477124063231, 131073); -f(562947805675521, 262143); -f(562949953159168, 262144); -f(562952100642815, 262145); -f(1125897758834689, 524287); -f(1125899906318336, 524288); -f(1125902053801983, 524289); -x = 2147483648; -f(0, 0); -f(2147483648, 1); -f(4294967296, 2); -f(6442450944, 3); -f(8589934592, 4); -f(10737418240, 5); -f(15032385536, 7); -f(17179869184, 8); -f(19327352832, 9); -f(32212254720, 15); -f(34359738368, 16); -f(36507222016, 17); -f(66571993088, 31); -f(68719476736, 32); -f(70866960384, 33); -f(135291469824, 63); -f(137438953472, 64); -f(139586437120, 65); -f(272730423296, 127); -f(274877906944, 128); -f(277025390592, 129); -f(547608330240, 255); -f(549755813888, 256); -f(551903297536, 257); -f(1097364144128, 511); -f(1099511627776, 512); -f(1101659111424, 513); -f(2196875771904, 1023); -f(2199023255552, 1024); -f(2201170739200, 1025); -f(4395899027456, 2047); -f(4398046511104, 2048); -f(4400193994752, 2049); -f(8793945538560, 4095); -f(8796093022208, 4096); -f(8798240505856, 4097); -f(17590038560768, 8191); -f(17592186044416, 8192); -f(17594333528064, 8193); -f(35182224605184, 16383); -f(35184372088832, 16384); -f(35186519572480, 16385); -f(70366596694016, 32767); -f(70368744177664, 32768); -f(70370891661312, 32769); -f(140735340871680, 65535); -f(140737488355328, 65536); -f(140739635838976, 65537); -f(281472829227008, 131071); -f(281474976710656, 131072); -f(281477124194304, 131073); -f(562947805937664, 262143); -f(562949953421312, 262144); -f(562952100904960, 262145); -f(1125897759358976, 524287); -f(1125899906842624, 524288); -f(1125902054326272, 524289); -x = 2147483649; -f(0, 0); -f(2147483649, 1); -f(4294967298, 2); -f(6442450947, 3); -f(8589934596, 4); -f(10737418245, 5); -f(15032385543, 7); -f(17179869192, 8); -f(19327352841, 9); -f(32212254735, 15); -f(34359738384, 16); -f(36507222033, 17); -f(66571993119, 31); -f(68719476768, 32); -f(70866960417, 33); -f(135291469887, 63); -f(137438953536, 64); -f(139586437185, 65); -f(272730423423, 127); -f(274877907072, 128); -f(277025390721, 129); -f(547608330495, 255); -f(549755814144, 256); -f(551903297793, 257); -f(1097364144639, 511); -f(1099511628288, 512); -f(1101659111937, 513); -f(2196875772927, 1023); -f(2199023256576, 1024); -f(2201170740225, 1025); -f(4395899029503, 2047); -f(4398046513152, 2048); -f(4400193996801, 2049); -f(8793945542655, 4095); -f(8796093026304, 4096); -f(8798240509953, 4097); -f(17590038568959, 8191); -f(17592186052608, 8192); -f(17594333536257, 8193); -f(35182224621567, 16383); -f(35184372105216, 16384); -f(35186519588865, 16385); -f(70366596726783, 32767); -f(70368744210432, 32768); -f(70370891694081, 32769); -f(140735340937215, 65535); -f(140737488420864, 65536); -f(140739635904513, 65537); -f(281472829358079, 131071); -f(281474976841728, 131072); -f(281477124325377, 131073); -f(562947806199807, 262143); -f(562949953683456, 262144); -f(562952101167105, 262145); -f(1125897759883263, 524287); -f(1125899907366912, 524288); -f(1125902054850561, 524289); -x = 4294967295; -f(0, 0); -f(4294967295, 1); -f(8589934590, 2); -f(12884901885, 3); -f(17179869180, 4); -f(21474836475, 5); -f(30064771065, 7); -f(34359738360, 8); -f(38654705655, 9); -f(64424509425, 15); -f(68719476720, 16); -f(73014444015, 17); -f(133143986145, 31); -f(137438953440, 32); -f(141733920735, 33); -f(270582939585, 63); -f(274877906880, 64); -f(279172874175, 65); -f(545460846465, 127); -f(549755813760, 128); -f(554050781055, 129); -f(1095216660225, 255); -f(1099511627520, 256); -f(1103806594815, 257); -f(2194728287745, 511); -f(2199023255040, 512); -f(2203318222335, 513); -f(4393751542785, 1023); -f(4398046510080, 1024); -f(4402341477375, 1025); -f(8791798052865, 2047); -f(8796093020160, 2048); -f(8800387987455, 2049); -f(17587891073025, 4095); -f(17592186040320, 4096); -f(17596481007615, 4097); -f(35180077113345, 8191); -f(35184372080640, 8192); -f(35188667047935, 8193); -f(70364449193985, 16383); -f(70368744161280, 16384); -f(70373039128575, 16385); -f(140733193355265, 32767); -f(140737488322560, 32768); -f(140741783289855, 32769); -f(281470681677825, 65535); -f(281474976645120, 65536); -f(281479271612415, 65537); -f(562945658322945, 131071); -f(562949953290240, 131072); -f(562954248257535, 131073); -f(1125895611613185, 262143); -f(1125899906580480, 262144); -f(1125904201547775, 262145); -x = 4294967296; -f(0, 0); -f(4294967296, 1); -f(8589934592, 2); -f(12884901888, 3); -f(17179869184, 4); -f(21474836480, 5); -f(30064771072, 7); -f(34359738368, 8); -f(38654705664, 9); -f(64424509440, 15); -f(68719476736, 16); -f(73014444032, 17); -f(133143986176, 31); -f(137438953472, 32); -f(141733920768, 33); -f(270582939648, 63); -f(274877906944, 64); -f(279172874240, 65); -f(545460846592, 127); -f(549755813888, 128); -f(554050781184, 129); -f(1095216660480, 255); -f(1099511627776, 256); -f(1103806595072, 257); -f(2194728288256, 511); -f(2199023255552, 512); -f(2203318222848, 513); -f(4393751543808, 1023); -f(4398046511104, 1024); -f(4402341478400, 1025); -f(8791798054912, 2047); -f(8796093022208, 2048); -f(8800387989504, 2049); -f(17587891077120, 4095); -f(17592186044416, 4096); -f(17596481011712, 4097); -f(35180077121536, 8191); -f(35184372088832, 8192); -f(35188667056128, 8193); -f(70364449210368, 16383); -f(70368744177664, 16384); -f(70373039144960, 16385); -f(140733193388032, 32767); -f(140737488355328, 32768); -f(140741783322624, 32769); -f(281470681743360, 65535); -f(281474976710656, 65536); -f(281479271677952, 65537); -f(562945658454016, 131071); -f(562949953421312, 131072); -f(562954248388608, 131073); -f(1125895611875328, 262143); -f(1125899906842624, 262144); -f(1125904201809920, 262145); -x = 4294967297; -f(0, 0); -f(4294967297, 1); -f(8589934594, 2); -f(12884901891, 3); -f(17179869188, 4); -f(21474836485, 5); -f(30064771079, 7); -f(34359738376, 8); -f(38654705673, 9); -f(64424509455, 15); -f(68719476752, 16); -f(73014444049, 17); -f(133143986207, 31); -f(137438953504, 32); -f(141733920801, 33); -f(270582939711, 63); -f(274877907008, 64); -f(279172874305, 65); -f(545460846719, 127); -f(549755814016, 128); -f(554050781313, 129); -f(1095216660735, 255); -f(1099511628032, 256); -f(1103806595329, 257); -f(2194728288767, 511); -f(2199023256064, 512); -f(2203318223361, 513); -f(4393751544831, 1023); -f(4398046512128, 1024); -f(4402341479425, 1025); -f(8791798056959, 2047); -f(8796093024256, 2048); -f(8800387991553, 2049); -f(17587891081215, 4095); -f(17592186048512, 4096); -f(17596481015809, 4097); -f(35180077129727, 8191); -f(35184372097024, 8192); -f(35188667064321, 8193); -f(70364449226751, 16383); -f(70368744194048, 16384); -f(70373039161345, 16385); -f(140733193420799, 32767); -f(140737488388096, 32768); -f(140741783355393, 32769); -f(281470681808895, 65535); -f(281474976776192, 65536); -f(281479271743489, 65537); -f(562945658585087, 131071); -f(562949953552384, 131072); -f(562954248519681, 131073); -f(1125895612137471, 262143); -f(1125899907104768, 262144); -f(1125904202072065, 262145); -x = 8589934591; -f(0, 0); -f(8589934591, 1); -f(17179869182, 2); -f(25769803773, 3); -f(34359738364, 4); -f(42949672955, 5); -f(60129542137, 7); -f(68719476728, 8); -f(77309411319, 9); -f(128849018865, 15); -f(137438953456, 16); -f(146028888047, 17); -f(266287972321, 31); -f(274877906912, 32); -f(283467841503, 33); -f(541165879233, 63); -f(549755813824, 64); -f(558345748415, 65); -f(1090921693057, 127); -f(1099511627648, 128); -f(1108101562239, 129); -f(2190433320705, 255); -f(2199023255296, 256); -f(2207613189887, 257); -f(4389456576001, 511); -f(4398046510592, 512); -f(4406636445183, 513); -f(8787503086593, 1023); -f(8796093021184, 1024); -f(8804682955775, 1025); -f(17583596107777, 2047); -f(17592186042368, 2048); -f(17600775976959, 2049); -f(35175782150145, 4095); -f(35184372084736, 4096); -f(35192962019327, 4097); -f(70360154234881, 8191); -f(70368744169472, 8192); -f(70377334104063, 8193); -f(140728898404353, 16383); -f(140737488338944, 16384); -f(140746078273535, 16385); -f(281466386743297, 32767); -f(281474976677888, 32768); -f(281483566612479, 32769); -f(562941363421185, 65535); -f(562949953355776, 65536); -f(562958543290367, 65537); -f(1125891316776961, 131071); -f(1125899906711552, 131072); -f(1125908496646143, 131073); -x = 8589934592; -f(0, 0); -f(8589934592, 1); -f(17179869184, 2); -f(25769803776, 3); -f(34359738368, 4); -f(42949672960, 5); -f(60129542144, 7); -f(68719476736, 8); -f(77309411328, 9); -f(128849018880, 15); -f(137438953472, 16); -f(146028888064, 17); -f(266287972352, 31); -f(274877906944, 32); -f(283467841536, 33); -f(541165879296, 63); -f(549755813888, 64); -f(558345748480, 65); -f(1090921693184, 127); -f(1099511627776, 128); -f(1108101562368, 129); -f(2190433320960, 255); -f(2199023255552, 256); -f(2207613190144, 257); -f(4389456576512, 511); -f(4398046511104, 512); -f(4406636445696, 513); -f(8787503087616, 1023); -f(8796093022208, 1024); -f(8804682956800, 1025); -f(17583596109824, 2047); -f(17592186044416, 2048); -f(17600775979008, 2049); -f(35175782154240, 4095); -f(35184372088832, 4096); -f(35192962023424, 4097); -f(70360154243072, 8191); -f(70368744177664, 8192); -f(70377334112256, 8193); -f(140728898420736, 16383); -f(140737488355328, 16384); -f(140746078289920, 16385); -f(281466386776064, 32767); -f(281474976710656, 32768); -f(281483566645248, 32769); -f(562941363486720, 65535); -f(562949953421312, 65536); -f(562958543355904, 65537); -f(1125891316908032, 131071); -f(1125899906842624, 131072); -f(1125908496777216, 131073); -x = 8589934593; -f(0, 0); -f(8589934593, 1); -f(17179869186, 2); -f(25769803779, 3); -f(34359738372, 4); -f(42949672965, 5); -f(60129542151, 7); -f(68719476744, 8); -f(77309411337, 9); -f(128849018895, 15); -f(137438953488, 16); -f(146028888081, 17); -f(266287972383, 31); -f(274877906976, 32); -f(283467841569, 33); -f(541165879359, 63); -f(549755813952, 64); -f(558345748545, 65); -f(1090921693311, 127); -f(1099511627904, 128); -f(1108101562497, 129); -f(2190433321215, 255); -f(2199023255808, 256); -f(2207613190401, 257); -f(4389456577023, 511); -f(4398046511616, 512); -f(4406636446209, 513); -f(8787503088639, 1023); -f(8796093023232, 1024); -f(8804682957825, 1025); -f(17583596111871, 2047); -f(17592186046464, 2048); -f(17600775981057, 2049); -f(35175782158335, 4095); -f(35184372092928, 4096); -f(35192962027521, 4097); -f(70360154251263, 8191); -f(70368744185856, 8192); -f(70377334120449, 8193); -f(140728898437119, 16383); -f(140737488371712, 16384); -f(140746078306305, 16385); -f(281466386808831, 32767); -f(281474976743424, 32768); -f(281483566678017, 32769); -f(562941363552255, 65535); -f(562949953486848, 65536); -f(562958543421441, 65537); -f(1125891317039103, 131071); -f(1125899906973696, 131072); -f(1125908496908289, 131073); -x = 17179869183; -f(0, 0); -f(17179869183, 1); -f(34359738366, 2); -f(51539607549, 3); -f(68719476732, 4); -f(85899345915, 5); -f(120259084281, 7); -f(137438953464, 8); -f(154618822647, 9); -f(257698037745, 15); -f(274877906928, 16); -f(292057776111, 17); -f(532575944673, 31); -f(549755813856, 32); -f(566935683039, 33); -f(1082331758529, 63); -f(1099511627712, 64); -f(1116691496895, 65); -f(2181843386241, 127); -f(2199023255424, 128); -f(2216203124607, 129); -f(4380866641665, 255); -f(4398046510848, 256); -f(4415226380031, 257); -f(8778913152513, 511); -f(8796093021696, 512); -f(8813272890879, 513); -f(17575006174209, 1023); -f(17592186043392, 1024); -f(17609365912575, 1025); -f(35167192217601, 2047); -f(35184372086784, 2048); -f(35201551955967, 2049); -f(70351564304385, 4095); -f(70368744173568, 4096); -f(70385924042751, 4097); -f(140720308477953, 8191); -f(140737488347136, 8192); -f(140754668216319, 8193); -f(281457796825089, 16383); -f(281474976694272, 16384); -f(281492156563455, 16385); -f(562932773519361, 32767); -f(562949953388544, 32768); -f(562967133257727, 32769); -f(1125882726907905, 65535); -f(1125899906777088, 65536); -f(1125917086646271, 65537); -x = 17179869184; -f(0, 0); -f(17179869184, 1); -f(34359738368, 2); -f(51539607552, 3); -f(68719476736, 4); -f(85899345920, 5); -f(120259084288, 7); -f(137438953472, 8); -f(154618822656, 9); -f(257698037760, 15); -f(274877906944, 16); -f(292057776128, 17); -f(532575944704, 31); -f(549755813888, 32); -f(566935683072, 33); -f(1082331758592, 63); -f(1099511627776, 64); -f(1116691496960, 65); -f(2181843386368, 127); -f(2199023255552, 128); -f(2216203124736, 129); -f(4380866641920, 255); -f(4398046511104, 256); -f(4415226380288, 257); -f(8778913153024, 511); -f(8796093022208, 512); -f(8813272891392, 513); -f(17575006175232, 1023); -f(17592186044416, 1024); -f(17609365913600, 1025); -f(35167192219648, 2047); -f(35184372088832, 2048); -f(35201551958016, 2049); -f(70351564308480, 4095); -f(70368744177664, 4096); -f(70385924046848, 4097); -f(140720308486144, 8191); -f(140737488355328, 8192); -f(140754668224512, 8193); -f(281457796841472, 16383); -f(281474976710656, 16384); -f(281492156579840, 16385); -f(562932773552128, 32767); -f(562949953421312, 32768); -f(562967133290496, 32769); -f(1125882726973440, 65535); -f(1125899906842624, 65536); -f(1125917086711808, 65537); -x = 17179869185; -f(0, 0); -f(17179869185, 1); -f(34359738370, 2); -f(51539607555, 3); -f(68719476740, 4); -f(85899345925, 5); -f(120259084295, 7); -f(137438953480, 8); -f(154618822665, 9); -f(257698037775, 15); -f(274877906960, 16); -f(292057776145, 17); -f(532575944735, 31); -f(549755813920, 32); -f(566935683105, 33); -f(1082331758655, 63); -f(1099511627840, 64); -f(1116691497025, 65); -f(2181843386495, 127); -f(2199023255680, 128); -f(2216203124865, 129); -f(4380866642175, 255); -f(4398046511360, 256); -f(4415226380545, 257); -f(8778913153535, 511); -f(8796093022720, 512); -f(8813272891905, 513); -f(17575006176255, 1023); -f(17592186045440, 1024); -f(17609365914625, 1025); -f(35167192221695, 2047); -f(35184372090880, 2048); -f(35201551960065, 2049); -f(70351564312575, 4095); -f(70368744181760, 4096); -f(70385924050945, 4097); -f(140720308494335, 8191); -f(140737488363520, 8192); -f(140754668232705, 8193); -f(281457796857855, 16383); -f(281474976727040, 16384); -f(281492156596225, 16385); -f(562932773584895, 32767); -f(562949953454080, 32768); -f(562967133323265, 32769); -f(1125882727038975, 65535); -f(1125899906908160, 65536); -f(1125917086777345, 65537); diff --git a/src/3rdparty/v8/test/mjsunit/new-function.js b/src/3rdparty/v8/test/mjsunit/new-function.js new file mode 100644 index 0000000..9e8cc27 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/new-function.js @@ -0,0 +1,34 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var x; +try { + Function("}), x = this, (function() {"); +} catch(e) { + print("Caught " + e); +} +assertTrue(x == "[object global]"); diff --git a/src/3rdparty/v8/test/mjsunit/numops-fuzz-part1.js b/src/3rdparty/v8/test/mjsunit/numops-fuzz-part1.js new file mode 100644 index 0000000..8e98ae6 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/numops-fuzz-part1.js @@ -0,0 +1,1172 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +function f() { + var x = 0; + var tmp = 0; + assertEquals(0, x /= (tmp = 798469700.4090232, tmp)); + assertEquals(0, x *= (2714102322.365509)); + assertEquals(0, x *= x); + assertEquals(139516372, x -= (tmp = -139516372, tmp)); + assertEquals(1, x /= (x%(2620399703.344006))); + assertEquals(0, x >>>= x); + assertEquals(-2772151192.8633175, x -= (tmp = 2772151192.8633175, tmp)); + assertEquals(-2786298206.8633175, x -= (14147014)); + assertEquals(1509750523, x |= ((1073767916)-(tmp = 919311632.2789925, tmp))); + assertEquals(2262404051.926751, x += ((752653528.9267509)%x)); + assertEquals(-270926893, x |= (tmp = 1837232194, tmp)); + assertEquals(0.17730273401688765, x /= ((tmp = -2657202795, tmp)-(((((x|(tmp = -1187733892.282897, tmp))-x)<<(556523578))-x)+(-57905508.42881298)))); + assertEquals(122483.56550261026, x *= ((((tmp = 2570017060.15193, tmp)%((-1862621126.9968336)>>x))>>(x>>(tmp = 2388674677, tmp)))>>>(-2919657526.470434))); + assertEquals(0, x ^= x); + assertEquals(0, x <<= (tmp = 2705124845.0455265, tmp)); + assertEquals(0, x &= (-135286835.07069612)); + assertEquals(-0, x *= ((tmp = -165810479.10020828, tmp)|x)); + assertEquals(248741888, x += ((735976871.1308595)<<(-2608055185.0700903))); + assertEquals(139526144, x &= (tmp = -1454301068, tmp)); + assertEquals(-0.047221345672746884, x /= (tmp = -2954726130.994727, tmp)); + assertEquals(0, x <<= (x>>x)); + assertEquals(0, x >>>= ((x+(912111201.488966))-(tmp = 1405800042.6070075, tmp))); + assertEquals(-1663642733, x |= (((-1663642733.5700119)<<(x^x))<<x)); + assertEquals(-914358272, x <<= ((((-308411676)-(-618261840.9113789))%(-68488626.58621716))-x)); + assertEquals(-1996488704, x &= (-1358622641.5848842)); + assertEquals(-345978263, x += (1650510441)); + assertEquals(3, x >>>= (-1106714178.701668)); + assertEquals(1, x %= (((x>>(x>>(tmp = -3052773846.817114, tmp)))*(tmp = 1659218887.379526, tmp))&x)); + assertEquals(-943225672, x += (-943225673)); + assertEquals(-0.41714300120060854, x /= (tmp = 2261156652, tmp)); + assertEquals(0, x >>>= ((3107060934.8863482)<<(tmp = 1902730887, tmp))); + assertEquals(0, x &= x); + assertEquals(1476628, x |= ((tmp = -2782899841.390033, tmp)>>>(2097653770))); + assertEquals(0.0008887648921591833, x /= ((tmp = 1661438264.5253348, tmp)%((tmp = 2555939813, tmp)*(-877024323.6515315)))); + assertEquals(0, x <<= (tmp = -2366551345, tmp)); + assertEquals(0, x &= (tmp = 1742843591, tmp)); + assertEquals(0, x -= x); + assertEquals(4239, x += ((-3183564176.232031)>>>(349622674.1255014))); + assertEquals(-67560, x -= ((2352742295)>>>x)); + assertEquals(-67560, x &= x); + assertEquals(-0.00003219917807302283, x /= (2098190203.699741)); + assertEquals(0, x -= x); + assertEquals(0, x >>= ((((tmp = -869086522.8358297, tmp)/(187820779))-(tmp = -2000970995.1931965, tmp))|(1853528755.6064696))); + assertEquals(0, x >>= (-3040509919)); + assertEquals(0, x %= (((tmp = -2386688049.194946, tmp)<<(tmp = -669711391, tmp))|x)); + assertEquals(0, x %= (tmp = -298431511.4839926, tmp)); + assertEquals(0, x /= (2830845091.2793818)); + assertEquals(0, x /= ((((-2529926178)|x)^((tmp = 2139313707.0894063, tmp)%((-1825768525.0541775)-(-952600362.7758243))))+x)); + assertEquals(NaN, x /= x); + assertEquals(NaN, x -= x); + assertEquals(NaN, x /= (tmp = -432944480, tmp)); + assertEquals(0, x <<= (((((x^((-1777523727)+(2194962794)))>>>(((((-590335134.8224905)%(x*(2198198974)))|(tmp = -2068556796, tmp))/(1060765637))*(-147051676)))/((tmp = -477350113.92686677, tmp)<<((x/(2018712621.0397925))^((tmp = 491163813.3921983, tmp)+(((x|((((x%(1990073256.812654))%((-2024388518.9599915)>>((tmp = 223182187, tmp)*(-722241065))))>>>(tmp = 2517147885.305745, tmp))%(1189996239.11222)))&x)%(-306932860))))))&((tmp = 1117802724.485684, tmp)+((-1391614045)-x)))%((((x>>((2958453447)*x))^(((410825859)|(((tmp = -1119269292.5495896, tmp)>>>(((((((x%(tmp = 648541746.6059314, tmp))*((-2304508480)<<((((x^(1408199888.1454597))|((251623937)|x))/((-382389946.9984102)|(tmp = -2082681143.5893767, tmp)))-(((tmp = 631243472, tmp)>>>(1407556544))/(((x>>>x)>>>(tmp = -6329025.47865057, tmp))>>>(tmp = 948664752.543093, tmp))))))/((((-183248880)>>x)&x)&x))>>x)&(((-978737284.8492057)%(tmp = 2983300011.737006, tmp))&(tmp = 2641937234.2954116, tmp)))<<x)>>(2795416632.9722223)))%((((tmp = -50926632, tmp)/x)&(((tmp = -2510786916, tmp)/x)/(-699755674)))|((((tmp = 1411792593, tmp)>>(924286570.2637128))>>((1609997725)>>(2735658951.0762663)))*(tmp = 726205435, tmp)))))<<(tmp = -2135055357.3156831, tmp)))/(tmp = 1408695065, tmp))^(tmp = -1343267739.8562133, tmp)))); + assertEquals(0, x %= (-437232116)); + assertEquals(-2463314518.2747326, x -= (2463314518.2747326)); + assertEquals(109, x >>= (2401429560)); + assertEquals(-2687641732.0253763, x += (-2687641841.0253763)); + assertEquals(-2336375490019484000, x *= (tmp = 869303174.6678596, tmp)); + assertEquals(5.458650430363785e+36, x *= x); + assertEquals(0, x |= ((((-1676972008.797291)*x)*((tmp = 2606991807, tmp)-x))<<x)); + assertEquals(0, x &= ((-3053393759.3496876)+(-1431008367))); + assertEquals(-856728369, x |= (x-(((((764337872)/x)<<((x|(((tmp = 1409368192.1268077, tmp)+(tmp = -848083676, tmp))|(-2797102463.7915916)))^x))/x)^(tmp = 856728369.0589117, tmp)))); + assertEquals(-0, x %= x); + assertEquals(1116550103, x ^= (-3178417193)); + assertEquals(1116550103, x %= (tmp = -1482481942, tmp)); + assertEquals(133, x >>>= x); + assertEquals(-1.381429241671034e-7, x /= ((tmp = -962771116.8101778, tmp)^x)); + assertEquals(-1092268961, x |= ((tmp = 3202672531, tmp)-((x-(tmp = 845529357, tmp))>>(tmp = -868680593, tmp)))); + assertEquals(-1092268961, x %= (tmp = 2670840415.304719, tmp)); + assertEquals(-122794480, x %= (tmp = 969474481, tmp)); + assertEquals(-297606521542193600, x *= (2423614820)); + assertEquals(72460064, x >>>= (tmp = -1230798655, tmp)); + assertEquals(-203714325373689600, x *= (-2811401400)); + assertEquals(2154914048, x >>>= (((2241377026.001436)/x)+x)); + assertEquals(1177864081, x ^= (tmp = -968513903, tmp)); + assertEquals(35947664, x &= (-2086226758.2704995)); + assertEquals(20795732539020670, x += (x*(578500247))); + assertEquals(-892004992, x >>= x); + assertEquals(-7023661.354330708, x /= ((((((1740714214)%((tmp = -459699286, tmp)+(tmp = -1700187400, tmp)))>>(tmp = -3170295237, tmp))+(tmp = -497509780, tmp))+((1971976144.6197853)+(661992813.6077721)))>>>(-1683802728))); + assertEquals(-1634205696, x <<= x); + assertEquals(-7, x >>= (-3187653764.930914)); + assertEquals(-5.095345981491203, x -= ((tmp = 748315289, tmp)/(tmp = -392887780, tmp))); + assertEquals(1486531570, x &= (1486531570.9300508)); + assertEquals(5670, x >>= (((tmp = -2486758205.26425, tmp)*(732510414))|x)); + assertEquals(5670, x >>= (((-1811879946.2553763)%(1797475764))/(((tmp = -2159923884, tmp)|x)+(tmp = -1774410807, tmp)))); + assertEquals(38, x %= (x>>>x)); + assertEquals(-151134215, x ^= (((tmp = -2593085609.5622163, tmp)+((tmp = -814992345.7516887, tmp)-(534809571)))|(tmp = -232678571, tmp))); + assertEquals(-234881024, x <<= x); + assertEquals(-234881024, x <<= (x>>>x)); + assertEquals(55169095435288580, x *= x); + assertEquals(0, x >>= (tmp = 1176612256, tmp)); + assertEquals(0, x <<= (1321866341.2486475)); + assertEquals(0, x %= (x-(-602577995))); + assertEquals(0, x >>>= (((((tmp = -125628635.79970193, tmp)^(tmp = 1294209955.229382, tmp))&(((tmp = -2353256654.0725203, tmp)|((-1136743028.9425385)|((((950703429.1110399)-(x>>>x))/((((x%(-252705869.21126103))/((tmp = 886957620, tmp)<<(x%((tmp = -1952249741, tmp)*(tmp = -1998149844, tmp)))))|(tmp = 1933366713, tmp))|((tmp = -2957141565, tmp)>>>(tmp = 1408598804, tmp))))+(((((((-2455002047.4910946)%(tmp = -528017836, tmp))&((-2693432769)/(tmp = 2484427670.9045153, tmp)))%(-356969659))-((((((tmp = 3104828644.0753174, tmp)%(x>>>(tmp = 820832137.8175925, tmp)))*((tmp = 763080553.9260503, tmp)+(3173597855)))<<(((-510785437)^x)<<(x|(((x*(x%((tmp = -1391951515, tmp)/x)))-x)|(x-((-522681793.93221474)/((2514619703.2162743)*(2936688324))))))))|x)>>>(-2093210042)))&(763129279.3651779))&x))))-x))%(((-1331164821)&(tmp = 1342684586, tmp))<<(x<<(tmp = 2675008614.588005, tmp))))>>((2625292569.8984914)+(-3185992401)))); + assertEquals(0, x *= (tmp = 671817215.1147974, tmp)); + assertEquals(-1608821121, x ^= ((tmp = 2686146175.04077, tmp)>>>x)); + assertEquals(-0, x %= x); + assertEquals(-0, x /= ((tmp = 286794551.0720866, tmp)|(x%x))); + assertEquals(0, x <<= (x|(tmp = 1095503996.2285218, tmp))); + assertEquals(443296752, x ^= (443296752)); + assertEquals(110824188, x >>= ((184708570)>>(x&x))); + assertEquals(0.7908194935161674, x /= ((((167151154.63381648)&((tmp = -1434120690, tmp)-(tmp = 2346173080, tmp)))/(56656051.87305987))^(140138414))); + assertEquals(-0.9027245492678485, x *= ((tmp = 1724366578, tmp)/(((2979477411)<<(((897038568)>>(tmp = 348960298, tmp))%(281056223.2037884)))^((((-1383133388)-(((-1379748375)-((x>>(x&(tmp = 2456582046, tmp)))>>>(-2923911755.565961)))&x))<<(-2825791731))^(tmp = -1979992970, tmp))))); + assertEquals(0, x &= (2482304279)); + assertEquals(-0, x *= (-2284213673)); + assertEquals(0, x <<= ((2874381218.015819)|x)); + assertEquals(0, x *= (x>>>(tmp = 2172786480, tmp))); + assertEquals(0, x &= (-1638727867.2978938)); + assertEquals(0, x %= ((tmp = -2213947368.285817, tmp)>>x)); + assertEquals(0, x >>>= (tmp = -531324706, tmp)); + assertEquals(0, x %= (tmp = -2338792486, tmp)); + assertEquals(0, x <<= (((tmp = 351012164, tmp)<<(x|((tmp = -3023836638.5337825, tmp)^(-2678806692))))|x)); + assertEquals(0, x %= (x-(tmp = -3220231305.45039, tmp))); + assertEquals(0, x <<= (-2132833261)); + assertEquals(0, x >>>= x); + assertEquals(0, x %= ((2544970469)+(((-2633093458.5911965)&(644108176))-(x>>>(tmp = -949043718, tmp))))); + assertEquals(-2750531265, x += (-2750531265)); + assertEquals(0, x >>= x); + assertEquals(0, x *= ((tmp = 1299005700, tmp)-x)); + assertEquals(0, x >>= x); + assertEquals(-1785515304, x -= (((((-806054462.5563161)/x)>>>x)+(1785515304))|((tmp = 2937069788.9396844, tmp)/x))); + assertEquals(-3810117159.173689, x -= (2024601855.1736891)); + assertEquals(-6.276064139320051, x /= (607087033.3053156)); + assertEquals(134217727, x >>>= (((x%(tmp = 924293127, tmp))^x)|((x>>>(x&((((tmp = -413386639, tmp)/(x>>(tmp = 599075308.8479941, tmp)))^(tmp = -1076703198, tmp))*((tmp = -2239117284, tmp)>>(655036983)))))-x))); + assertEquals(134217727, x %= (tmp = 2452642261.038778, tmp)); + assertEquals(-569504740360507, x *= ((tmp = -1086243941, tmp)>>(tmp = 1850668904.4885683, tmp))); + assertEquals(113378806, x >>>= (tmp = -2558233435, tmp)); + assertEquals(979264375, x -= (((x>>(1950008052))%((2917183569.0209)*(tmp = 1184250640.446752, tmp)))|((((tmp = -691875212, tmp)-(-2872881803))>>(tmp = 44162204.97461021, tmp))^(tmp = 865885647, tmp)))); + assertEquals(-1127813632, x <<= ((((tmp = -2210499281, tmp)>>>x)-(tmp = 2359697240, tmp))-x)); + assertEquals(-1707799657, x ^= (653518231.3995534)); + assertEquals(2916579668449318000, x *= x); + assertEquals(2916579669254640600, x += (x&(tmp = 2986558026.399422, tmp))); + assertEquals(870995175, x ^= (2598813927.8991632)); + assertEquals(870995175, x %= (-2857038782)); + assertEquals(1869503575895591000, x *= (x|(x|(((tmp = 2478650307.4118147, tmp)*((tmp = 2576240847.476932, tmp)>>>x))<<x)))); + assertEquals(-134947790, x |= ((tmp = 1150911808, tmp)*((2847735464)/(-2603172652.929262)))); + assertEquals(-137053182, x -= ((tmp = 2155921819.0929346, tmp)>>>(x-(((-1960937402)-(-1907735074.2875962))%((1827808310)^(tmp = -2788307127, tmp)))))); + assertEquals(-134824702, x |= (((2912578752.2395406)^(x%(((-2585660111.0638976)<<(((((tmp = 747742706, tmp)%(-1630261205))&((((x|(x|(-2619903144.278758)))|((2785710568.8651934)>>((-968301967.5982246)<<(x&x))))>>((x>>>((x>>>(tmp = -1402085797.0310762, tmp))*((tmp = -323729645.2250068, tmp)<<(tmp = 2234667799, tmp))))>>>(-167003745)))>>((924665972.4681011)<<x)))>>>x)<<((((x+x)+x)-(((tmp = 2399203431.0526247, tmp)-(-2872533271))-(((tmp = 914778794.2087344, tmp)-(tmp = 806353942.9502392, tmp))|(((tmp = 262924334.99231672, tmp)&x)|(tmp = -460248836.5602243, tmp)))))/x)))%((-1681000689)/(tmp = -2805054623.654228, tmp)))))*(tmp = 957346233.9619625, tmp))); + assertEquals(-3274838, x %= ((((tmp = 3155450543.3524327, tmp)>>>x)<<(tmp = 2103079652.3410985, tmp))>>x)); + assertEquals(-3274838, x |= ((((tmp = 2148004645.639173, tmp)>>>(tmp = -1285119223, tmp))<<(((((-711596054)>>>(tmp = -2779776371.3473206, tmp))^(((((tmp = -1338880329.383915, tmp)<<((-1245247254.477341)>>x))*(tmp = -2649052844.20065, tmp))>>((1734345880.4600453)%(x/(2723093117.118899))))*(1252918475.3285656)))<<(2911356885))^x))<<(-1019761103))); + assertEquals(1703281954, x &= (((tmp = 1036570471.7412028, tmp)+((tmp = 3043119517, tmp)%(2374310816.8346715)))%(tmp = -2979155076, tmp))); + assertEquals(1741588391, x |= ((tmp = 1230009575.6003838, tmp)>>>(-1247515003.8152597))); + assertEquals(72869474.64782429, x %= (tmp = 1668718916.3521757, tmp)); + assertEquals(770936242.104203, x += (698066767.4563787)); + assertEquals(-0.2820604726420833, x /= (tmp = -2733230342, tmp)); + assertEquals(403480578, x |= ((969730374)&(tmp = 1577889835, tmp))); + assertEquals(-1669557233, x ^= ((-1616812135)+(tmp = -456209292, tmp))); + assertEquals(-1630427, x >>= ((2327783031.1175823)/(226947662.4579488))); + assertEquals(131022, x >>>= ((tmp = -1325018897.2482083, tmp)>>(x&((((((-1588579772.9240348)<<(tmp = -1775580288.356329, tmp))<<(tmp = -1021528325.2075481, tmp))>>((tmp = 2373033451.079956, tmp)*(tmp = 810304612, tmp)))-((tmp = -639152097, tmp)<<(tmp = 513879484, tmp)))&(2593958513))))); + assertEquals(1, x >>= ((3033200222)-x)); + assertEquals(-561146816.4851823, x += (tmp = -561146817.4851823, tmp)); + assertEquals(-4.347990105831158, x /= ((((-1270435902)*x)%((tmp = 637328492.7386824, tmp)-(x>>(-749100689))))%(x+x))); + assertEquals(-1, x >>= x); + assertEquals(1, x *= x); + assertEquals(111316849706694460, x += ((966274056)*(x|(115202150)))); + assertEquals(-1001883840, x >>= x); + assertEquals(-1001883840, x &= x); + assertEquals(-3006880758, x += ((((-2275110637.4054556)/((x+(tmp = -1390035090.4324536, tmp))>>(-5910593)))&(tmp = 378982420, tmp))|(tmp = 2289970378.568629, tmp))); + assertEquals(314474, x >>>= (x>>((tmp = -228007336.31281257, tmp)%(tmp = 1127648013, tmp)))); + assertEquals(-17694827, x ^= ((tmp = 2095133598.1849852, tmp)|(-1978322311))); + assertEquals(1, x /= x); + assertEquals(1, x %= (-2323617209.7531185)); + assertEquals(0, x >>>= (x*(tmp = -1574455400.489434, tmp))); + assertEquals(0, x >>= (3131854684)); + assertEquals(2853609824, x += ((-231012098)-(tmp = -3084621922, tmp))); + assertEquals(8143089027629311000, x *= x); + assertEquals(313052685, x ^= (tmp = 2962303501, tmp)); + assertEquals(4776, x >>= (tmp = 2271457232, tmp)); + assertEquals(0.000002812258572702285, x /= (tmp = 1698279115, tmp)); + assertEquals(0, x >>>= (tmp = 1698465782.0927145, tmp)); + assertEquals(0, x <<= x); + assertEquals(0, x |= ((x<<((-1824760240.3040407)<<(2798263764.39145)))&(tmp = 1795988253.0493627, tmp))); + assertEquals(1782206945, x ^= (-2512760351.7881565)); + assertEquals(7610569113843172000, x *= (((tmp = -44415823.92972565, tmp)&(tmp = 1402483498.9421625, tmp))+(tmp = 2909778666, tmp))); + assertEquals(15221138227873292000, x += (x-(tmp = -186948658.394145, tmp))); + assertEquals(0, x -= x); + assertEquals(-2238823252, x -= ((tmp = 2238823252, tmp)+x)); + assertEquals(0, x -= x); + assertEquals(0, x >>= (2976069570)); + assertEquals(0, x >>= ((tmp = -2358157433, tmp)/x)); + assertEquals(-949967713, x ^= (tmp = -949967713, tmp)); + assertEquals(-1, x >>= x); + assertEquals(-1522291702.1977966, x *= (1522291702.1977966)); + assertEquals(-1522291702, x >>= ((((2290279800)|x)|(1793154434.6798015))&((-1161390929.0766077)>>>x))); + assertEquals(83894274, x &= (tmp = 1571058486, tmp)); + assertEquals(43186847.90522933, x += ((tmp = -1131332988.0947707, tmp)%x)); + assertEquals(0, x >>= (tmp = -1968312707.269359, tmp)); + assertEquals(0, x &= (2507747643.26175)); + assertEquals(0, x %= (tmp = 3190525303.366887, tmp)); + assertEquals(-1968984602, x ^= (((x/(x|(-1607062026.5338054)))<<(tmp = 2207669861.8770065, tmp))+(tmp = 2325982694.956348, tmp))); + assertEquals(554, x >>>= (((tmp = -2302283871.993821, tmp)>>>(-3151835112))|(((((x%(-1534374264))/((731246012)<<(((883830997.1194847)<<(((-1337895080.1937215)/(tmp = 3166402571.8157315, tmp))^(tmp = -1563897595.5799441, tmp)))>>(tmp = -556816951.0537591, tmp))))>>(-2682203577))<<(x/((1654294674.865079)+x)))/((x^(-2189474695.4259806))/(-475915245.7363057))))); + assertEquals(1372586111, x ^= (1372586581)); + assertEquals(1166831229, x -= ((-834168138)&(762573579))); + assertEquals(2333662456, x -= ((x>>x)-x)); + assertEquals(-1961304840, x &= x); + assertEquals(-2130143128, x &= (2982852718.0711775)); + assertEquals(1073741824, x <<= (-1446978661.6426942)); + assertEquals(2097152, x >>>= ((-1424728215)-(((127872198)%(tmp = -2596923298, tmp))&x))); + assertEquals(2097152, x >>>= x); + assertEquals(0, x &= (x/(tmp = -518419194.42994523, tmp))); + assertEquals(0, x >>= ((x/(-1865078245))%(tmp = 2959239210, tmp))); + assertEquals(-0, x *= ((x|(-1721307400))|(-3206147171.9491577))); + assertEquals(0, x >>>= ((-694741143)&(tmp = -2196513947.699142, tmp))); + assertEquals(0, x <<= x); + assertEquals(0, x &= ((tmp = 2037824385.8836646, tmp)+((tmp = 1203034986.4647732, tmp)/(x>>>(((-1374881234)/(899771270.3237157))+((-2296524362.8020077)|(-1529870870))))))); + assertEquals(0, x >>= (tmp = 2770637816, tmp)); + assertEquals(0, x ^= x); + assertEquals(-1861843456, x |= ((632402668)*((x|(tmp = -1032952662.8269436, tmp))|(tmp = 2671272511, tmp)))); + assertEquals(-1861843456, x >>= (((x>>>x)+x)<<(-1600908842))); + assertEquals(-58182608, x >>= (x-(tmp = -2496617861, tmp))); + assertEquals(-3636413, x >>= (tmp = -400700028, tmp)); + assertEquals(-7272826, x += x); + assertEquals(-1, x >>= ((tmp = -3184897005.3614545, tmp)-((-1799843014)|(tmp = 2832132915, tmp)))); + assertEquals(-121800925.94209385, x *= (121800925.94209385)); + assertEquals(-30450232, x >>= (-979274206.6261561)); + assertEquals(-30450232, x >>= (tmp = -1028204832.5078967, tmp)); + assertEquals(-30450232, x |= x); + assertEquals(965888871, x ^= (((((-2157753481.3375635)*((tmp = -1810667184.8165767, tmp)&((tmp = 2503908344.422232, tmp)|x)))>>(x>>(1601560785)))<<x)^(tmp = 943867311.6380403, tmp))); + assertEquals(7546006, x >>>= x); + assertEquals(7546006, x <<= ((tmp = 1388931761.780241, tmp)*(x-(tmp = -1245147647.0070577, tmp)))); + assertEquals(12985628, x += (x&(-1520746354))); + assertEquals(12985628, x &= x); + assertEquals(12985628, x %= (tmp = 308641965, tmp)); + assertEquals(685733278, x |= ((tmp = -1275653544, tmp)-((tmp = -1956798010.3773859, tmp)%(tmp = 2086889575.643448, tmp)))); + assertEquals(679679376, x &= (2860752368)); + assertEquals(1770773904, x |= (x<<(3200659207))); + assertEquals(1224886544, x &= (-585733767.6876519)); + assertEquals(1224886544, x %= ((tmp = -114218494, tmp)-x)); + assertEquals(1208109328, x &= (tmp = 1854361593, tmp)); + assertEquals(18434, x >>>= x); + assertEquals(-349394636955256100, x *= (x*(-1028198742))); + assertEquals(-519536600.7713163, x %= (-1054085356.9120367)); + assertEquals(-1610612736, x ^= ((tmp = -3126078854, tmp)&x)); + assertEquals(-2637321565906333700, x *= (1637464740.5658746)); + assertEquals(-2637321568051070500, x -= ((tmp = -1006718806, tmp)<<(3005848133.106345))); + assertEquals(368168695, x ^= (x^(tmp = 368168695.6881037, tmp))); + assertEquals(43, x >>>= x); + assertEquals(-2081297089, x |= ((167169305.77248895)+(-2248466405.3199244))); + assertEquals(-2474622167, x -= (tmp = 393325078, tmp)); + assertEquals(-135109701, x %= (-1169756233)); + assertEquals(0, x ^= x); + assertEquals(0, x >>= (((((tmp = -164768854, tmp)/(tmp = -1774989993.1909926, tmp))+x)-((-921438912)>>(tmp = -191772028.69249105, tmp)))-(tmp = 558728578.22033, tmp))); + assertEquals(0, x %= (tmp = 2188003745, tmp)); + assertEquals(0, x <<= (((tmp = -999335540, tmp)>>((((325101977)/(tmp = -3036991542, tmp))<<(tmp = -213302488, tmp))+x))|(tmp = -1054204587, tmp))); + assertEquals(0, x &= ((2844053429.4720345)>>>x)); + assertEquals(NaN, x %= x); + assertEquals(NaN, x -= (-1481729275.9118822)); + assertEquals(NaN, x *= (tmp = 1098314618.2397528, tmp)); + assertEquals(-1073741824, x ^= ((tmp = 1718545772, tmp)<<(((tmp = -81058910, tmp)-(2831123087.424368))+(tmp = 576710057.2361784, tmp)))); + assertEquals(-2921155898.4793186, x -= (1847414074.4793184)); + assertEquals(-1295646720, x <<= (2178621744)); + assertEquals(-0.8906779709597907, x /= ((tmp = -2840292585.6837263, tmp)<<(x&((tmp = 892527695.6172305, tmp)>>>x)))); + assertEquals(0, x <<= (((tmp = 3149667213.298993, tmp)>>(tmp = 1679370761.7226725, tmp))^(115417747.21537328))); + assertEquals(0, x |= x); + assertEquals(0, x %= ((-1112849427)>>(-1245508870.7514496))); + assertEquals(0, x &= x); + assertEquals(0, x |= x); + assertEquals(0, x >>>= ((3144100694.930459)>>>(tmp = 2408610503, tmp))); + assertEquals(0, x <<= ((tmp = 2671709754.0318713, tmp)%x)); + assertEquals(0, x >>>= (x|((tmp = -3048578701, tmp)-(674147224)))); + assertEquals(NaN, x %= x); + assertEquals(0, x &= ((tmp = -2084883715, tmp)|(((((-3008427069)+(875536047.4283574))>>>x)%(tmp = -450003426.1091652, tmp))%(((-2956878433.269356)|(x/((((x%((((((x<<(((tmp = -1581063482.510351, tmp)^x)-(tmp = 1364458217, tmp)))^((tmp = 1661446342, tmp)+(1307091014)))/(342270750.9901335))>>>(x&((1760980812.898993)&((tmp = 2878165745.6401143, tmp)/(((tmp = -981178013, tmp)/(-2338761668.29912))>>(-958462630))))))*((1807522840)^((tmp = 1885835034, tmp)^(-2538647938))))*(1673607540.0854697)))%x)>>x)<<x)))<<(853348877.2407281))))); + assertEquals(0, x >>>= x); + assertEquals(-1162790279, x -= (1162790279)); + assertEquals(-1162790279, x >>= (((-490178658)*x)/((((((tmp = -1883861998.6699312, tmp)/(tmp = -2369967345.240594, tmp))+(3142759868.266447))&(508784917.8158537))&x)>>(-2129532322)))); + assertEquals(-1360849740.9829152, x -= (x+(1360849740.9829152))); + assertEquals(1928392181, x ^= (-602670783)); + assertEquals(19478708.898989897, x /= (((-2617861994)>>(tmp = 797256920, tmp))%(-1784987906))); + assertEquals(-8648903.575540157, x *= (((tmp = 673979276, tmp)/(-1517908716))%(x/x))); + assertEquals(-8648903.575540157, x %= ((((643195610.4221292)>>>(tmp = 2342669302, tmp))>>>(tmp = -1682965878, tmp))^((tmp = -208158937.63443017, tmp)>>((907286989)&(x<<(448634893)))))); + assertEquals(1399288769, x ^= (tmp = -1407486728, tmp)); + assertEquals(0, x &= (((1999255838.815517)/(tmp = 564646001, tmp))/(-3075888101.3274765))); + assertEquals(0, x ^= ((-78451711.59404826)%x)); + assertEquals(-1351557131, x |= (2943410165)); + assertEquals(1715626371, x -= (-3067183502)); + assertEquals(71434240, x &= ((-1800066426)<<(((((x<<(-324796375))+x)<<(tmp = 2696824955.735132, tmp))^x)%(tmp = 444916469, tmp)))); + assertEquals(71434240, x >>>= (((x&((x%x)|x))+(tmp = 2226992348.3050146, tmp))<<(-305526260))); + assertEquals(0, x -= (x%(tmp = 582790928.5832802, tmp))); + assertEquals(0, x *= ((x%(1865155340))>>>((x<<(2600488191))^(-308995123)))); + assertEquals(0, x >>= (x&(-3120043868.8531103))); + assertEquals(0, x |= x); + assertEquals(-0, x *= (tmp = -172569944, tmp)); + assertEquals(0, x <<= (-1664372874)); + assertEquals(1377713344.6784928, x += (tmp = 1377713344.6784928, tmp)); + assertEquals(1377713344, x |= x); + assertEquals(-232833282, x |= (tmp = 2685870654, tmp)); + assertEquals(84639, x -= (((((2778531079.998492)%(2029165314))>>>(tmp = -468881172.3729558, tmp))^x)|((x>>>((((x%(3044318992.943596))&(1996754328.2214756))^(1985227172.7485228))%(tmp = -1984848676.1347625, tmp)))|((tmp = 2637662639, tmp)<<x)))); + assertEquals(0, x ^= x); + assertEquals(1237720303, x -= (-1237720303)); + assertEquals(2, x >>= (-2148785379.428976)); + assertEquals(2, x &= (tmp = -3087007874, tmp)); + assertEquals(0, x %= x); + assertEquals(0, x >>>= x); + assertEquals(0, x >>>= x); + assertEquals(0, x += x); + assertEquals(0, x &= (2055693082)); + assertEquals(-1349456492, x += (x^(-1349456492.315998))); + assertEquals(671088640, x <<= (x>>(-2030805724.5472062))); + assertEquals(-417654580004782100, x *= (tmp = -622353822, tmp)); + assertEquals(1538160360, x |= (195983080.56698656)); + assertEquals(733, x >>>= (tmp = 661085269, tmp)); + assertEquals(657, x &= (-1611460943.993404)); + assertEquals(431649, x *= x); + assertEquals(863298, x += x); + assertEquals(0, x &= ((1899423003)/((472439729)>>((tmp = 2903738952, tmp)+(tmp = 2164601630.3456993, tmp))))); + assertEquals(0, x &= (x>>>(tmp = 1939167951.2828958, tmp))); + assertEquals(1557813284, x |= (x-(-1557813284))); + assertEquals(72876068, x &= (662438974.2372154)); + assertEquals(0.6695448637501589, x /= (tmp = 108844189.45702457, tmp)); + assertEquals(0, x -= x); + assertEquals(2944889412, x += (2944889412)); + assertEquals(3787980288, x -= ((((tmp = -2003814373.2301111, tmp)<<x)>>>(tmp = -3088357284.4405823, tmp))-(843090884))); + assertEquals(1, x >>>= (729274079)); + assertEquals(1, x %= (-148002187.33869123)); + assertEquals(3073988415.673201, x *= (tmp = 3073988415.673201, tmp)); + assertEquals(4839166225.673201, x += (tmp = 1765177810, tmp)); + assertEquals(4529373898.673201, x += (-309792327)); + assertEquals(3097903.090496063, x %= (-150875866.51942348)); + assertEquals(1270874112, x <<= ((((((tmp = -960966763.1418135, tmp)>>((((-3208596981.613482)>>>(tmp = 746403937.6913509, tmp))>>>(-2190042854.066803))/(2449323432)))*(-1272232665.791577))<<(-99306767.7209444))^((-1942103828)/((1570981655)/(tmp = 2381666337, tmp))))+(tmp = -1946759395.1558368, tmp))); + assertEquals(1273845956, x |= (tmp = -3197282108.6120167, tmp)); + assertEquals(159230744, x >>= (((tmp = -1036031403.8108604, tmp)>>>(((3084964493)>>((x*x)^x))+(((2980108409.352001)^x)-(tmp = -2501685423.513927, tmp))))&(326263839))); + assertEquals(-370091747145550100, x *= (tmp = -2324248055.674161, tmp)); + assertEquals(143384219.54999557, x /= (tmp = -2581119096, tmp)); + assertEquals(1843396287, x |= (tmp = 1842718767, tmp)); + assertEquals(2.4895593465813803, x /= (740450831)); + assertEquals(2.4895593465813803, x %= ((((((((-3175333618)>>>((tmp = -1403880166, tmp)<<(tmp = -134875360, tmp)))>>>(2721317334.998084))<<(x&(tmp = 2924634208.1484184, tmp)))*((((x>>(tmp = -200319931.15328693, tmp))-(tmp = -495128933, tmp))+((-788052518.6610589)*((((tmp = 107902557, tmp)&(1221562660))%(x<<(((3155498059)*(((tmp = -1354381139.4897022, tmp)^(tmp = 3084557138.332852, tmp))*((((tmp = 1855251464.8464525, tmp)/((-1857403525.2008865)>>x))|x)-(-2061968455.0023944))))*(1917481864.84619))))^(x-(-508176709.52712965)))))+((((x%(-1942063404))+(x%(tmp = 855152281.180481, tmp)))|(-522863804))>>x)))>>>((tmp = -2515550553, tmp)&(((((-801095375)-(tmp = -2298729336.9792976, tmp))^x)/(tmp = 2370468053, tmp))>>(x|(tmp = -900008879, tmp)))))>>>(((tmp = -810295719.9509168, tmp)*((tmp = -1306212963.6226444, tmp)/(((tmp = 3175881540.9514832, tmp)|(-1439142297.819246))+((tmp = -134415617, tmp)|((-245801870)+x)))))>>(tmp = 1889815478, tmp)))-(((tmp = 597031177, tmp)%(858071823.7655672))+((tmp = 2320838665.8243756, tmp)|((938555608)<<(2351739219.6461897)))))); + assertEquals(6.197905740150709, x *= x); + assertEquals(1, x /= x); + assertEquals(0, x >>= (-1639664165.9076233)); + assertEquals(0, x >>= (-3135317748.801177)); + assertEquals(0, x &= (3185479232.5325994)); + assertEquals(-0, x *= ((-119759439.19668174)/(tmp = 2123964608, tmp))); + assertEquals(0, x /= (-1183061929.2827876)); + assertEquals(0, x <<= (-1981831198)); + assertEquals(0, x >>= ((((x<<(((((((-2133752838)&((tmp = -3045157736.9331336, tmp)>>>(x%x)))>>x)%(tmp = 3082217039, tmp))&(tmp = 270770770.97558427, tmp))|((-2212037556)^((((((2089224421)|(tmp = 360979560, tmp))<<x)%((tmp = -1679487690.6940534, tmp)+((173021423)|((tmp = 560900612, tmp)+((244376267.58977115)^x)))))<<(tmp = 2534513699, tmp))^x)))>>>(2915907189.4873834)))+(x*x))%(1637581117))%(tmp = 2363861105.3786244, tmp))); + assertEquals(0, x &= ((-2765495757.873004)&(1727406493))); + assertEquals(NaN, x -= (((((-1419667515.2616255)|x)-(150530256.48022234))%((((x|x)<<x)>>>(x^x))+x))-((-1216384577.3749187)*(495244398)))); + assertEquals(NaN, x += (x^((tmp = 2472035493, tmp)+x))); + assertEquals(NaN, x %= ((tmp = -1753037412.885754, tmp)|((tmp = 2507058310, tmp)<<(1475945705)))); + assertEquals(-1008981005, x |= ((tmp = -1140889842.6099494, tmp)-(tmp = -131908837, tmp))); + assertEquals(999230327.5872104, x -= (tmp = -2008211332.5872104, tmp)); + assertEquals(975810, x >>= (((-1211913874)*x)>>>((-2842129009)>>(x&(tmp = -1410865834, tmp))))); + assertEquals(7623, x >>= ((tmp = -1051327071, tmp)-(((tmp = -237716102.8005445, tmp)|((2938903833.416546)&x))|(((-1831064579)^x)/((tmp = 2999232092, tmp)-(981996301.2875179)))))); + assertEquals(0, x -= x); + assertEquals(0, x %= (x|(tmp = -666201160.5810485, tmp))); + assertEquals(-1347124100, x |= (-1347124100)); + assertEquals(-0, x %= (x&x)); + assertEquals(-661607963, x ^= (tmp = -661607963.3794863, tmp)); + assertEquals(3465, x >>>= (-828119020.8056595)); + assertEquals(-268431991, x -= (((tmp = -1386256352, tmp)^((tmp = 743629575, tmp)%((x*((tmp = -1719517658, tmp)>>(2019516558)))<<((2637317661)|x))))<<(tmp = -51637065, tmp))); + assertEquals(1578876380, x += ((tmp = 1847308371, tmp)&(((((((tmp = 1487934776.1893163, tmp)%(tmp = 1423264469.3137975, tmp))|(((2653260792.5668964)/(-2417905016.043802))>>>(2097411118.4501896)))^x)^(((tmp = -71334226, tmp)|x)>>>(tmp = -2771758874.7696714, tmp)))^((tmp = -1464849031.3240793, tmp)%(tmp = 2349739690.6430283, tmp)))/x))); + assertEquals(3269293934, x += (1690417554)); + assertEquals(4025392608.031957, x -= (((tmp = 268501120.7225704, tmp)<<(tmp = 2841620654.8903794, tmp))+((tmp = 1606704462.8455591, tmp)/((-2601879963)/(tmp = 2966620168.989736, tmp))))); + assertEquals(7, x >>>= (x^(-1913800035))); + assertEquals(1.4326776816275493e-8, x /= ((((tmp = -2703417892, tmp)/x)^((-2693772270.396241)>>>((x-(tmp = 615999818.5666655, tmp))>>((((2308121439.3702726)<<((-1794701502)>>(x+(tmp = -2253406035.972883, tmp))))<<((tmp = -197103799.0624652, tmp)|(629975898)))>>>x))))>>>((tmp = 2833656803, tmp)^(x^(tmp = -1580436025, tmp))))); + assertEquals(0, x >>>= (tmp = 1525372830.2126007, tmp)); + assertEquals(0, x %= ((2354010949.24469)>>>(x<<x))); + assertEquals(0, x ^= (((1112335059.6922574)*(tmp = -1874363935, tmp))&(((((2154894295.8360596)<<x)&(tmp = -270736315.13505507, tmp))&x)>>>(-2205692260.552064)))); + assertEquals(0, x >>>= (x<<((1488533932)*(tmp = 1707754286, tmp)))); + assertEquals(0, x >>= (((tmp = 1232547376.463387, tmp)%((x>>(711691823.1608362))>>>x))>>(((895039781.7478573)*(((((-334946524)&x)*(tmp = -1214529640, tmp))^(tmp = -1586820245, tmp))*(1062595445)))+x))); + assertEquals(0, x *= (1863299863.2631998)); + assertEquals(0, x /= (tmp = 1858428705.1330547, tmp)); + assertEquals(0, x &= x); + assertEquals(611788028, x += (x^(611788028.1510412))); + assertEquals(1, x /= x); + assertEquals(0, x >>= ((tmp = -1617320707.1784317, tmp)-((-2139400380)-(-1402777976)))); + assertEquals(0, x >>= (415866827.34665)); + assertEquals(-1990811897, x -= (tmp = 1990811897, tmp)); + assertEquals(-1990811895, x += ((x>>>(tmp = -2175453282.769696, tmp))&(tmp = -1459450498.7327478, tmp))); + assertEquals(-2377017935.149517, x += (-386206040.1495173)); + assertEquals(1946129845, x |= (tmp = -2890956796.936539, tmp)); + assertEquals(0, x %= x); + assertEquals(0, x <<= (1616188263)); + assertEquals(-1081213596, x ^= (tmp = 3213753700, tmp)); + assertEquals(3213753700, x >>>= (tmp = -3211181312, tmp)); + assertEquals(-1081213596, x &= x); + assertEquals(-1081213583, x ^= (((tmp = 1599988273.4926577, tmp)>>((((-1061394954.6331315)^x)+((-1835761078)*x))+(x%(tmp = -696221869, tmp))))/((tmp = -1156966790.3436491, tmp)^x))); + assertEquals(0, x ^= x); + assertEquals(NaN, x /= x); + assertEquals(NaN, x += (-1257400530.9263027)); + assertEquals(NaN, x /= (753062089)); + assertEquals(NaN, x *= ((tmp = 305418865.57012296, tmp)^(((-2797769706)+((((tmp = -33288276.988654375, tmp)%(tmp = 1242979846, tmp))|(-316574800))-((tmp = -1766083579.4203427, tmp)*(((x*(tmp = -2400342309.2349987, tmp))>>(tmp = 2632061795, tmp))^(tmp = -1001440809, tmp)))))^((((x-(tmp = -1469542637.6925495, tmp))-x)-(3184196890))%(((((((633226688)*((tmp = -2692547856, tmp)>>(((tmp = -1244311756, tmp)>>>x)+((1746013631.405202)>>>(941829464.1962085)))))%(x-x))+(995681795))-(tmp = -3047070551.3642616, tmp))/(1968259705))-((-2853237880)^(tmp = -2746628223.4540343, tmp))))))); + assertEquals(0, x >>= x); + assertEquals(0.5713172378854926, x += (((x+(((x+x)/(tmp = 2642822318, tmp))*(-2590095885.4280834)))|(tmp = -1769210836, tmp))/(tmp = -3096722308.8665104, tmp))); + assertEquals(-0.000002311097780334994, x /= ((2269858877.9010344)>>(-2992512915.984787))); + assertEquals(-0.000002311097780334994, x %= (-1139222821)); + assertEquals(-0.000004622195560669988, x += x); + assertEquals(1, x /= x); + assertEquals(1, x >>>= (((3002169429.6061807)/(-3068577366))>>>((tmp = -1844537620, tmp)%((((tmp = 2087505119, tmp)>>>x)+x)&(2179989542))))); + assertEquals(-534213071, x *= (-534213071)); + assertEquals(-534213077.3716287, x -= (((tmp = -2390432951.154034, tmp)^x)/(-290501980))); + assertEquals(1836305, x >>>= (x&x)); + assertEquals(1836305, x %= ((x|((3070123855)^(49986396)))+((-1863644960.4202995)>>>((tmp = 1886126804.6019692, tmp)^x)))); + assertEquals(28692, x >>>= ((2561362139.491764)>>(((((tmp = -1347469854.7413375, tmp)/(((x|(x+x))^((x^(tmp = -2737413775.4595394, tmp))^x))<<(((tmp = 225344844.07128417, tmp)&x)&(tmp = 145794498, tmp))))*x)<<(1424529187))/((-2924344715)/(tmp = -2125770148, tmp))))); + assertEquals(-2089419535.2717648, x += (-2089448227.2717648)); + assertEquals(18957929, x ^= (tmp = 2186590872, tmp)); + assertEquals(-708972800, x -= (727930729)); + assertEquals(-4198593, x |= (799483455.1885371)); + assertEquals(-1, x >>= (-2330654693.6413193)); + assertEquals(-1, x |= (((tmp = -116877155, tmp)>>>((((tmp = -1677422314.1333556, tmp)/(tmp = -3108738499.0798397, tmp))%((x&(x/x))%((tmp = -695607185.1561592, tmp)-(tmp = 2302449181.622259, tmp))))^(((-1482743646.5604773)^((897705064)>>>x))-(tmp = -2933836669, tmp))))%(((tmp = -2991584625, tmp)|(((x>>x)+(-1101066835))-x))>>(-33192973.819939613)))); + assertEquals(-1, x &= x); + assertEquals(-524288, x <<= (-1177513101.3087924)); + assertEquals(1978770334.9189441, x += (tmp = 1979294622.9189441, tmp)); + assertEquals(901783582, x &= ((-368584615)^(((((-478030699.2647903)<<x)<<x)+(tmp = 708725752, tmp))^((tmp = -3081556856, tmp)/(tmp = 1149958711.0676727, tmp))))); + assertEquals(-1480333211.8654308, x += (tmp = -2382116793.865431, tmp)); + assertEquals(956930239.6783283, x *= ((tmp = 956930239.6783283, tmp)/x)); + assertEquals(1277610.4668602513, x /= ((tmp = 1571029828, tmp)>>(tmp = 2417481141, tmp))); + assertEquals(-1077333228, x ^= (tmp = 3218755006, tmp)); + assertEquals(-50218, x |= (tmp = -1044436526.6435988, tmp)); + assertEquals(-1, x >>= (-154655245.18921852)); + assertEquals(0.00006276207290978003, x *= (((tmp = 2234286992.9800305, tmp)>>(tmp = 2132564046.0696363, tmp))/((((tmp = -2565534644.3428087, tmp)>>>(tmp = 2622809851.043325, tmp))>>>((tmp = 311277386, tmp)&x))-(tmp = -2003980974, tmp)))); + assertEquals(0, x %= x); + assertEquals(1282114076, x += ((((422838227)>>>((tmp = 1024613366.1899053, tmp)-((368275340)<<(((tmp = -3066121318, tmp)+(-2319101378))&x))))^(x>>(tmp = 1920136319.803412, tmp)))^(1282264803.3968434))); + assertEquals(-277097604, x |= (-283585688.9123297)); + assertEquals(553816692, x &= (x&(tmp = 554082036.676608, tmp))); + assertEquals(658505728, x <<= x); + assertEquals(658505728, x &= (x%(2846071230))); + assertEquals(39, x >>= (334728536.5172192)); + assertEquals(0, x -= x); + assertEquals(0, x += x); + assertEquals(0, x &= (tmp = -335285336, tmp)); + assertEquals(0, x <<= (tmp = 1255594828.3430014, tmp)); + assertEquals(0, x %= (-630772751.1248167)); + assertEquals(NaN, x /= ((((x&(tmp = -1576090612, tmp))%x)>>>x)*((-1038073094.2787619)>>>x))); + assertEquals(NaN, x += x); + assertEquals(NaN, x -= (((tmp = -2663887803, tmp)&((x+(-1402421046))/x))/(-2675654483))); + assertEquals(NaN, x %= (x&(tmp = 672002093, tmp))); + assertEquals(0, x |= x); + assertEquals(-2698925754, x += (tmp = -2698925754, tmp)); + assertEquals(-2057748993, x += ((tmp = -2263466497, tmp)^x)); + assertEquals(1, x /= x); + assertEquals(-2769559719.4045835, x -= (2769559720.4045835)); + assertEquals(-1.3964174646069973, x /= (tmp = 1983332198, tmp)); + assertEquals(-2140716624.3964174, x += (tmp = -2140716623, tmp)); + assertEquals(0, x <<= ((2589073007)-(-816764911.8571186))); + assertEquals(-2837097288.161354, x -= (tmp = 2837097288.161354, tmp)); + assertEquals(-1445059927.161354, x += (tmp = 1392037361, tmp)); + assertEquals(155197984, x &= (tmp = -2694712730.924674, tmp)); + assertEquals(155197984, x |= (x>>>(tmp = 69118015.20305443, tmp))); + assertEquals(155197984, x >>>= (((x^(-1353660241))*x)<<(((((x%(tmp = -1905584634, tmp))>>>(tmp = -860171244.5963638, tmp))&(-1084415001.7039547))+(x-(((tmp = 298064661, tmp)>>x)>>((tmp = 378629912.383446, tmp)-(x%x)))))+(((3212580683)/(((((x^x)>>(tmp = -1502887218, tmp))<<x)%(-142779025))|(((tmp = 1361745708, tmp)*(((((tmp = 1797072528.0673332, tmp)+x)%(tmp = 167297609, tmp))%(-287345856.1791787))^(((((((x*(tmp = -640510459.1514752, tmp))<<(x^(tmp = 1387982082.5646644, tmp)))>>(tmp = 2473373497.467914, tmp))^((234025940)*x))+(tmp = 520098202.9546956, tmp))*(x*(tmp = -362929250.1775775, tmp)))^(-2379972900))))*(tmp = -1385817972, tmp))))+(-1788631834))))); + assertEquals(0, x >>= ((tmp = -18671049, tmp)/((tmp = 651261550.6716013, tmp)>>(-58105114.70740628)))); + assertEquals(0, x *= ((((x>>(tmp = 2256492150.737681, tmp))<<(x<<(((-2738910707)&x)<<(1892428322))))*(tmp = 1547934638, tmp))>>((((319464033.7888391)|(((((tmp = 2705641070, tmp)<<((tmp = 1566904759.36666, tmp)*((-682175559.7540412)&(-691692016.3021002))))%(tmp = 1118101737, tmp))|(902774462))<<x))^((tmp = -388997180, tmp)<<(x<<((((((-88462733)+(x>>>x))%x)*(tmp = -20297481.556210756, tmp))>>>(1927423855.1719701))-((2047811185.6278129)-(tmp = 2952219346.72126, tmp))))))|(-1685518403.7513878)))); + assertEquals(0, x /= (tmp = 1858074757.563318, tmp)); + assertEquals(-1351623058, x ^= (-1351623058.4756806)); + assertEquals(1, x /= x); + assertEquals(0, x ^= x); + assertEquals(0, x -= (x&(997878144.9798675))); + assertEquals(-0, x /= (-2769731277)); + assertEquals(0, x >>>= ((-2598508325)>>(-1355571351))); + assertEquals(0, x >>>= x); + assertEquals(0, x -= (x&(tmp = 1672810223, tmp))); + assertEquals(-924449908.1999881, x -= (924449908.1999881)); + assertEquals(-0, x %= x); + assertEquals(-0, x /= (tmp = 2007131382.059545, tmp)); + assertEquals(-0, x += x); + assertEquals(225132064, x += ((((tmp = -2422670578.1260514, tmp)|x)+x)^(1660142894.7066057))); + assertEquals(Infinity, x /= (x-x)); + assertEquals(0, x ^= x); + assertEquals(0, x <<= x); + assertEquals(-2455424946.732606, x -= (2455424946.732606)); + assertEquals(1208029258, x &= ((tmp = 1823728509, tmp)+x)); + assertEquals(1.3682499724725645, x /= ((((tmp = 1267938464.3854322, tmp)%((tmp = 2510853574, tmp)+(((2979355693.866435)-(tmp = 1989726095.7746763, tmp))<<x)))%((-1382092141.1627176)+(((-901799353)+((-2936414080.8254457)>>>(2515004943.0865674)))-(2532799222.353197))))<<(tmp = -2168058960.2694826, tmp))); + assertEquals(0.13799826710735907, x %= ((-1090423235)/(tmp = 2659024727, tmp))); + assertEquals(0, x >>= (1688542889.082693)); + assertEquals(0, x <<= x); + assertEquals(NaN, x %= ((((tmp = 1461037539, tmp)<<((x<<(tmp = 2101282906.5302017, tmp))>>(-2792197742)))%(((x%x)^(((tmp = 1399565526, tmp)^(tmp = 643902, tmp))-((tmp = -1449543738, tmp)|x)))/x))*(x<<(471967867)))); + assertEquals(0, x &= ((tmp = -2121748100.6824129, tmp)>>(tmp = -2817271480.6497793, tmp))); + assertEquals(0, x &= (3169130964.6291866)); + assertEquals(-0, x /= (-2303316806)); + assertEquals(0, x <<= (tmp = 120185946.51617038, tmp)); + assertEquals(449448375, x ^= ((((tmp = -836410266.014014, tmp)/x)&((x>>>(tmp = -2602671283, tmp))+x))+(tmp = 449448375, tmp))); + assertEquals(202003841790140640, x *= x); + assertEquals(202003840800829020, x += (((tmp = -1339865843, tmp)+(tmp = 350554234.15375435, tmp))<<((((((tmp = -1798499687.8208885, tmp)>>(((x-(x^x))|((tmp = 463627396.23932934, tmp)/(2714928060)))&(tmp = 3048222568.1103754, tmp)))&(-3127578553))<<(tmp = -2569797028.8299003, tmp))&x)<<((tmp = 2104393646, tmp)/((tmp = 2314471015.742891, tmp)<<((2704090554.1746845)>>(((tmp = 1935999696, tmp)*(((1348554815)>>>x)>>>(146665093.82445252)))%x))))))); + assertEquals(202003841764125400, x -= (tmp = -963296372.2846234, tmp)); + assertEquals(-413485056, x <<= (tmp = -2474480506.6054573, tmp)); + assertEquals(-3171894580.186845, x += ((tmp = -1261111102, tmp)+(tmp = -1497298422.1868448, tmp))); + assertEquals(17136, x >>= (tmp = 3055058160, tmp)); + assertEquals(17136, x %= (tmp = 1706784063.3577294, tmp)); + assertEquals(17136, x >>= ((tmp = 2161213808, tmp)*x)); + assertEquals(-17136, x /= ((((tmp = -1492618154, tmp)>>x)|(1381949066))>>(tmp = 2014457960, tmp))); + assertEquals(-34272, x += x); + assertEquals(-1498690902, x += (-1498656630)); + assertEquals(-1168674482, x ^= (486325220)); + assertEquals(-1168674482, x <<= ((x^x)*x)); + assertEquals(794521557347068000, x *= (-679848469)); + assertEquals(1.3330392590424505e+26, x *= (tmp = 167778866, tmp)); + assertEquals(0, x <<= (tmp = -2501540637.3664584, tmp)); + assertEquals(0, x >>>= (x-(x*(-890638026.1825848)))); + assertEquals(0, x %= ((-285010538.2813468)&(1314684460.7634423))); + assertEquals(0, x -= x); + assertEquals(0, x *= x); + assertEquals(NaN, x %= (x*(x<<x))); + assertEquals(NaN, x %= (x<<(((tmp = -1763171810.601149, tmp)&(-138151449.18303752))^(x|x)))); + assertEquals(0, x |= (x>>x)); + assertEquals(0, x &= (tmp = 1107152048, tmp)); + assertEquals(0, x >>= (1489117056.8200984)); + assertEquals(518749976, x ^= (518749976.20107937)); + assertEquals(356718654, x += (tmp = -162031322, tmp)); + assertEquals(356718654, x %= (((x>>>((tmp = -373747439.09634733, tmp)*(tmp = 563665566, tmp)))*(tmp = 2853322586.588251, tmp))*((1303537213)%(-2995314284)))); + assertEquals(5573728, x >>= (tmp = -2095997978, tmp)); + assertEquals(5573728, x <<= x); + assertEquals(5573728, x >>= (((((tmp = 1745399178.334154, tmp)<<(tmp = 2647999783.8219824, tmp))^(tmp = 1571286759, tmp))%x)/(2166250345.181711))); + assertEquals(10886, x >>>= ((682837289)+(x*x))); + assertEquals(170, x >>>= x); + assertEquals(169.95167497151652, x -= (((tmp = 527356024.19706845, tmp)+((tmp = 1263164619.2954736, tmp)|(tmp = 2942471886, tmp)))/((3017909419.131321)+(tmp = 2137746252.8006272, tmp)))); + assertEquals(-1915170061, x ^= (tmp = -1915170214, tmp)); + assertEquals(206045792, x &= (((tmp = 887031922, tmp)>>>x)-((-1861922770)|(9633541)))); + assertEquals(-1940321674, x |= (tmp = -2012149162.1817405, tmp)); + assertEquals(-1940321674, x &= x); + assertEquals(1128412272.160699, x += (tmp = 3068733946.160699, tmp)); + assertEquals(0.47486363523180236, x /= (tmp = 2376286976.807289, tmp)); + assertEquals(-1.4931079540252477e-10, x /= (tmp = -3180370407.5892467, tmp)); + assertEquals(0, x |= (((1220765170.5933602)*(884017786))*((x%(tmp = -2538196897.226384, tmp))<<(x^x)))); + assertEquals(-525529894, x += (tmp = -525529894, tmp)); + assertEquals(1621426184, x &= ((3046517714)*(((((-162481040.8033898)+(x/((x&(1489724492))/((x|(tmp = 943542303, tmp))>>>((-1840491388.1365871)<<(2338177232))))))+(((-2268887573.2430763)>>>(((tmp = 2919141667, tmp)+((tmp = 1326295559.692003, tmp)<<(-2256653815)))>>>(((((tmp = 1602731976.7514615, tmp)*(856036244.3730336))^x)>>>((((2846316421.252943)&(915324162))%(tmp = 1144577211.0221815, tmp))%x))*(x*x))))%(tmp = -2641416560, tmp)))*(x+(x>>>x)))>>x))); + assertEquals(1621426184, x %= (tmp = 1898223948, tmp)); + assertEquals(-3.383396676504762, x /= ((tmp = 2211088034.5234556, tmp)^x)); + assertEquals(7120923705.122882, x *= (((((tmp = 2632382342.914504, tmp)/(-615440284.1762738))&(2162453853.6658797))<<(-849038082.5298986))|(tmp = -2104667110.5603983, tmp))); + assertEquals(-1469010887, x &= x); + assertEquals(850767635866964700, x *= (tmp = -579143179.5338116, tmp)); + assertEquals(0, x %= x); + assertEquals(-571457, x |= ((2849326490.8464212)|(tmp = 1450592063, tmp))); + assertEquals(-571457, x &= x); + assertEquals(-0.00018638416434019244, x /= (3066016912.021368)); + assertEquals(0, x <<= (2058262829)); + assertEquals(NaN, x %= ((x|((x%x)>>>x))%((tmp = -2970314895.6974382, tmp)+x))); + assertEquals(NaN, x *= (-698693934.9483855)); + assertEquals(NaN, x += (-100150720.64391875)); + assertEquals(NaN, x %= x); + assertEquals(NaN, x -= (-530301478)); + assertEquals(NaN, x /= (1507673244)); + assertEquals(0, x <<= (x%(tmp = 2977838420.857235, tmp))); + assertEquals(0, x <<= (tmp = 3200877763, tmp)); + assertEquals(0, x <<= (tmp = -2592127060, tmp)); + assertEquals(NaN, x -= (((((((1930632619)*(3018666359))<<((tmp = 2676511886, tmp)&(-2786714482.25468)))%x)-(-633193192))<<((tmp = 403293598, tmp)*(-2765170226)))%x)); + assertEquals(530062092, x |= (tmp = 530062092, tmp)); + assertEquals(129409, x >>>= x); + assertEquals(-152430382316341.78, x *= (-1177896300.229055)); + assertEquals(-304860764632683.56, x += x); + assertEquals(0, x ^= x); + assertEquals(0, x %= (tmp = -63071565.367660046, tmp)); + assertEquals(0, x &= ((((tmp = -1007464338, tmp)<<(x<<((x^(tmp = -726826835, tmp))|x)))>>>x)*(((tmp = 469293335.9161849, tmp)<<(((((tmp = 1035077379, tmp)*(tmp = -555174353.7567515, tmp))&(3109222796.8286266))-(((((x-(tmp = 1128900353.6650414, tmp))|(tmp = 3119921303, tmp))&((-1353827690)&(x%((-924615958)&x))))>>>x)+(tmp = 1167787910, tmp)))+x))%((605363594)>>(1784370958.269381))))); + assertEquals(0, x %= (2953812835.9781704)); + assertEquals(0, x -= x); + assertEquals(0, x <<= x); + assertEquals(-901209266, x += (-901209266)); + assertEquals(-901209266, x &= x); + assertEquals(404, x >>>= (-3195686249)); + assertEquals(824237108, x ^= (824237472)); + assertEquals(497790936.1853996, x /= ((tmp = 1253776028, tmp)/(757207285))); + assertEquals(497790936, x >>>= ((tmp = -2212598336, tmp)<<(x^(1335355792.9363852)))); + assertEquals(0, x %= x); + assertEquals(-2659887352.6415873, x += (tmp = -2659887352.6415873, tmp)); + assertEquals(1635079945, x |= ((x&(1234659380))>>((((tmp = 2694276886.979136, tmp)|x)^((tmp = 132795582, tmp)<<((-1089828902)>>>x)))<<((((tmp = -2098728613.0310376, tmp)<<(x/(tmp = -2253865599, tmp)))*((x+(x>>>((48633053.82579231)-(385301592))))*(tmp = -1847454853.333535, tmp)))/((-540428068.8583717)+x))))); + assertEquals(1, x /= x); + assertEquals(33554432, x <<= ((((2803140769)<<x)|(tmp = -1965793804, tmp))>>>(tmp = -2273336965.575082, tmp))); + assertEquals(67108864, x += x); + assertEquals(9007199254740992, x *= (x+((x>>x)%(2674760854)))); + assertEquals(55369784, x %= (x|(-170725544.20038843))); + assertEquals(55369784, x %= (-1186186787)); + assertEquals(0, x ^= x); + assertEquals(0, x <<= x); + assertEquals(NaN, x /= ((-2968110098)-((x/(x|(((((x|((x&((-130329882)>>>(((-135670650)|(x<<(tmp = 1280371822, tmp)))^x)))-(-1183024707.2230911)))&(-1072829280))>>>(-340696948.41492534))>>>(tmp = 436308526.4938295, tmp))<<(((tmp = 3113787500, tmp)*((2038309320)>>>(-1818917055)))&((2808000707)/(774731251))))))%x))); + assertEquals(0, x |= (x*(tmp = -843074864, tmp))); + assertEquals(0, x &= (tmp = -752261173.8090212, tmp)); + assertEquals(0, x >>>= (tmp = 1532349931.7517128, tmp)); + assertEquals(0, x <<= ((tmp = -8628768, tmp)-((((tmp = 225928543, tmp)%(x>>>(x+x)))^((tmp = -2051536806.5249376, tmp)-x))-((tmp = -2274310376.9964137, tmp)%(tmp = 2251342739, tmp))))); + assertEquals(0, x >>= (1011388449)); + assertEquals(0, x += x); + assertEquals(0, x >>>= x); + assertEquals(-0, x *= ((-1781234179.8663826)>>(((1514201119.9761915)>>(((((1174857164.90042)^(tmp = 1124973934, tmp))^x)+((-1059246013.8834443)<<(2997611138.4876065)))%(((798188010)*(-1428293122))>>>(tmp = -3087267036.8035297, tmp))))<<x))); + assertEquals(1752554372, x ^= (tmp = -2542412924, tmp)); + assertEquals(1752554372, x %= (tmp = 3037553410.2298307, tmp)); + assertEquals(1859383977, x -= (x^(2446603103))); + assertEquals(1183048193, x &= ((tmp = -962336957, tmp)/(x/x))); + assertEquals(67738157, x %= ((((tmp = -1813911745.5223546, tmp)+x)<<(x-(((-1980179168)^x)|x)))|(1913769561.1308007))); + assertEquals(67698724, x &= ((1801574998.3142045)*((tmp = -2057492249, tmp)/((1713854494.72282)>>x)))); + assertEquals(0, x -= x); + assertEquals(-25232836, x -= ((tmp = 25232836, tmp)|x)); + assertEquals(-49, x >>= (x+((tmp = 2201204630.2897243, tmp)|(-1929326509)))); + assertEquals(-1605632, x <<= x); + assertEquals(-165965313, x += (tmp = -164359681, tmp)); + assertEquals(9.220413724941365e-10, x /= (((((tmp = 2579760013.0808706, tmp)*(tmp = -2535370639.9805303, tmp))>>((tmp = 2138199747.0301933, tmp)-(tmp = -2698019325.0972376, tmp)))*(tmp = -425284716, tmp))/((-1951538149.6611228)/(x^(2632919130))))); + assertEquals(0, x &= x); + assertEquals(0, x &= ((-645189137)/(tmp = 800952748, tmp))); + assertEquals(0, x &= (tmp = -1773606925, tmp)); + assertEquals(0, x += x); + assertEquals(0, x >>>= (tmp = 211399355.0741787, tmp)); + assertEquals(0, x <<= ((-1317040231.5737965)/((((((tmp = 838897586.0147077, tmp)|((-1902447594)|(tmp = 404942728.83034873, tmp)))^(2462760692.2907705))%((((((x%(tmp = -2888980287, tmp))<<(-368505224.49609876))-((x>>>(532513369))&(((((((tmp = -1298067543, tmp)^(tmp = -3130435881.100909, tmp))>>x)/(tmp = -3041161992, tmp))>>(x|(-431685991.95776653)))^((tmp = 1031777777, tmp)^((-105610810)>>>((-631433779)>>(tmp = -2577780871.167671, tmp)))))%(tmp = -3170517650.088039, tmp))))-(((tmp = 2175146237.968785, tmp)-((384631158.50508535)>>((893912279.4646157)|(tmp = -1478803924.5338967, tmp))))%(x/(-1089156420))))<<(tmp = -2024709456, tmp))>>x))*(tmp = -1423824994.6993582, tmp))%(tmp = 1739143409, tmp)))); + assertEquals(-1799353648, x |= ((-1799353648.3589036)>>>((((x&(-923571640.1012449))%x)+((tmp = 971885508, tmp)>>((tmp = -2207464428.2123804, tmp)+(-3108177894.0459776))))-(-2048954486.7014258)))); + assertEquals(-3666808032.2958965, x -= (tmp = 1867454384.2958965, tmp)); + assertEquals(-260069478915415100, x *= (tmp = 70925305.23136711, tmp)); + assertEquals(1142096768, x &= (tmp = 1866401706.9144325, tmp)); + assertEquals(1, x >>>= (tmp = 2701377150.5717473, tmp)); + assertEquals(1865946805, x |= (tmp = -2429020492, tmp)); + assertEquals(1424222287, x ^= ((((tmp = 433781338, tmp)>>(x>>>((-2914418422.4829016)/(tmp = 1600920669, tmp))))|(tmp = 588320482.9566053, tmp))>>>((((((x+(tmp = -2556387365.5071325, tmp))+(tmp = -2381889946.1830974, tmp))/(3154278191))>>>(-1069701268.8022757))>>(((tmp = 182049089.28866422, tmp)>>x)>>>(tmp = -447146173, tmp)))/(x-(2103883357.0929923))))); + assertEquals(0, x ^= x); + assertEquals(0, x -= (x%(3036884806))); + assertEquals(0, x >>>= (tmp = -652793480.3870945, tmp)); + assertEquals(0, x += x); + assertEquals(304031003, x ^= ((tmp = -900156495, tmp)^(-666397014.0711515))); + assertEquals(1, x /= x); + assertEquals(-1974501681, x |= (x^(-1974501681.4628205))); + assertEquals(-1.3089278317616264, x /= (((-1723703186.962839)>>>x)|((2061022161.6239533)<<x))); + assertEquals(-1, x |= (tmp = -1987006457, tmp)); + assertEquals(-0.14285714285714285, x /= ((((((x|(-1767793799.7595732))-(-1391656680))<<x)|(x>>(tmp = -2301588485.2811003, tmp)))>>>(((tmp = 1812723993, tmp)>>>((x^(((tmp = -3154100157.951021, tmp)%((tmp = -1254955564.4553523, tmp)-(((x>>>(((-1762886343)*x)*x))*(x^(x*(-750918563.4387553))))*x)))|((x>>x)>>(x<<((((-1766797454.5634143)^(tmp = -2251474340, tmp))-(-787637516.5276759))<<((1390653368)^(-1937605249.245374)))))))|(((tmp = 1156611894, tmp)<<x)<<(x>>((((x+(tmp = 2170166060.881797, tmp))&(x>>>(tmp = -1749295923.1498983, tmp)))>>(((-1014973878)|x)&(1302866805.684057)))*(tmp = 560439074.4002491, tmp))))))|(-2758270803.4510045)))&x)); + assertEquals(0, x |= x); + assertEquals(0, x += ((x>>((x+(tmp = -2776680860.870219, tmp))-(((688502468)<<(((tmp = 475364260.57888806, tmp)<<x)+(329071671)))/(-1097134948))))*(tmp = -1281834214.3416953, tmp))); + assertEquals(0, x *= ((((1159762330)<<(tmp = -1892429200, tmp))%x)<<x)); + assertEquals(0, x >>>= (-770595225)); + assertEquals(NaN, x += (((x>>x)/(tmp = 281621135, tmp))/x)); + assertEquals(0, x >>= (1363890241)); + assertEquals(1639023942.9945002, x += (1639023942.9945002)); + assertEquals(-2568590958567747000, x *= (-1567146697)); + assertEquals(1793554700, x ^= (tmp = 3215813388.405799, tmp)); + assertEquals(437879, x >>= x); + assertEquals(1339485943, x |= (1339220210)); + assertEquals(1, x /= x); + assertEquals(512, x <<= (2509226729.1477118)); + assertEquals(512, x <<= ((x>>(1326274040.7181284))<<(tmp = -760670199, tmp))); + assertEquals(1, x /= (x<<(x^x))); + assertEquals(0, x >>>= (((((1382512625.8298302)&(x>>>x))*(tmp = -815316595, tmp))>>>x)-(-95538051))); + assertEquals(-544344229.3548596, x -= (tmp = 544344229.3548596, tmp)); + assertEquals(-1088688458.7097192, x += x); + assertEquals(-1022850479579041900, x *= (939525418.3104812)); + assertEquals(2069622661, x |= (-2632744187.7721186)); + assertEquals(-1353480538017756400, x -= ((tmp = 1308085980, tmp)*((x>>>(-629663391.5165792))&(tmp = 3182319856.674114, tmp)))); + assertEquals(1.3702811563654176e+27, x *= ((((3061414617.6321163)/(tmp = 2628865442, tmp))+(-1549548261))+(x&((tmp = 809684398, tmp)|(x^(tmp = 801765002, tmp)))))); + assertEquals(0, x >>>= ((-2988504159)&((tmp = -260444190.02252054, tmp)^(2178729442.260293)))); + assertEquals(-1518607002, x -= (tmp = 1518607002, tmp)); + assertEquals(724566016, x <<= (tmp = 1042915731.7055794, tmp)); + assertEquals(707584, x >>>= (-208959862.93305588)); + assertEquals(0, x >>>= (((tmp = 877181764, tmp)>>(-970697753.3318911))%x)); + assertEquals(0, x ^= x); + assertEquals(0, x += x); + assertEquals(0, x <<= x); + assertEquals(0, x /= (x^((x/(-2903618412.4936123))+(tmp = 1169288899, tmp)))); + assertEquals(0, x >>>= x); + assertEquals(-1302645245, x ^= ((1855892732.3544865)+(tmp = 1136429319.5633948, tmp))); + assertEquals(0, x ^= x); + assertEquals(0, x &= (-1384534597.409375)); + assertEquals(-0, x /= (tmp = -680466419.8289509, tmp)); + assertEquals(-0, x *= (318728599.95017374)); + assertEquals(NaN, x %= (x>>(2019695267))); + assertEquals(0, x >>= (tmp = 1280789995, tmp)); + assertEquals(0, x *= (tmp = 2336951458, tmp)); + assertEquals(0, x >>= ((2981466013.758637)%(731947033))); + assertEquals(0, x -= x); + assertEquals(0, x ^= x); + assertEquals(0, x /= ((((3068070149.1452317)>>x)%(((1448965452)*((tmp = -2961594129, tmp)+(1829082104.0681171)))>>(-2331499703)))>>>(tmp = -3206314941.2626476, tmp))); + assertEquals(0, x >>= (x%(1869217101.9823673))); + assertEquals(0, x <<= (x+x)); + assertEquals(0, x >>>= ((1202130282)>>>x)); + assertEquals(0, x += x); + assertEquals(2603245248.6273212, x += (tmp = 2603245248.6273212, tmp)); + assertEquals(-1691864471, x ^= (x>>>(2504513614.117516))); + assertEquals(136835305, x -= ((-1618979896)&(-746953306))); + assertEquals(-2568499564.1261334, x += (tmp = -2705334869.1261334, tmp)); + assertEquals(1038075700, x ^= (1530399136)); + assertEquals(2076151400, x += x); + assertEquals(-524018410.1751909, x -= ((2398973627.175191)-(-201196183))); + assertEquals(0.327110599608614, x /= ((3181340288.602796)&x)); + assertEquals(0.327110599608614, x %= (tmp = -2284484060, tmp)); + assertEquals(0, x |= x); + assertEquals(403217947.5779772, x += (tmp = 403217947.5779772, tmp)); + assertEquals(403217947, x |= x); + assertEquals(-Infinity, x *= ((58693583.845808744)+(((tmp = -1527787016, tmp)*x)/((((2532689893.3191843)/(tmp = 2781746479.850424, tmp))|(((((460850355.9211761)/((((tmp = 626683450, tmp)<<((tmp = 1349974710, tmp)-((tmp = -1349602292, tmp)/(-2199808871.1229663))))>>((x/(-3092436372.3078623))&(tmp = -1190631012.0323825, tmp)))^((-2907082828.4552956)-(tmp = 1858683340.1157017, tmp))))^(-1513755598.5398848))%x)/x))&(1147739260.136806))))); + assertEquals(0, x &= (tmp = -3047356844.109563, tmp)); + assertEquals(637934616, x -= (tmp = -637934616, tmp)); + assertEquals(-1553350083, x ^= (-2056266203.094929)); + assertEquals(-0.13467351026547192, x %= ((tmp = 824736251, tmp)/(2544186314))); + assertEquals(1, x /= x); + assertEquals(1, x |= x); + assertEquals(0, x >>>= (2166609431.9515543)); + assertEquals(0, x <<= (x|(tmp = 121899222.14603412, tmp))); + assertEquals(0, x *= (1300447849.6595674)); + assertEquals(0, x %= (tmp = -2360500865.3944597, tmp)); + assertEquals(0, x %= (tmp = -1693401247, tmp)); + assertEquals(0, x >>= x); + assertEquals(0, x /= (471265307)); + assertEquals(257349748, x ^= (257349748.689448)); + assertEquals(257349748, x &= x); + assertEquals(981, x >>>= (tmp = -1959001422, tmp)); + assertEquals(0, x >>= ((-79932778.18114972)/x)); + assertEquals(0, x <<= (((-2599621472)^(tmp = 662071103, tmp))%(tmp = -2675822640.7641535, tmp))); + assertEquals(0, x &= (tmp = 2582354953.878623, tmp)); + assertEquals(0, x /= ((-953254484)/((-2571632163.376176)-(tmp = -342034471, tmp)))); + assertEquals(0, x <<= ((x-(tmp = -3013057672, tmp))&(tmp = -3204761036, tmp))); + assertEquals(0, x ^= ((x&((515934453)>>>x))/x)); + assertEquals(1, x |= ((-1914707646.2075093)>>>(tmp = -1918045025, tmp))); + assertEquals(-2002844120.8792589, x += (tmp = -2002844121.8792589, tmp)); + assertEquals(573030794, x >>>= (tmp = 1707788162, tmp)); + assertEquals(1.917619109627369, x /= ((1909436830.484202)%((123114323)<<(tmp = -1288988388.6444468, tmp)))); + assertEquals(-1400358045, x |= (-1400358046)); + assertEquals(-2043022529.4273133, x += (tmp = -642664484.4273133, tmp)); + assertEquals(-81408068.86728716, x %= (tmp = -980807230.2800131, tmp)); + assertEquals(0.1436896445024992, x /= (((tmp = 3201789924.913518, tmp)%(tmp = -962242528.6008646, tmp))^((tmp = -338830119.55884504, tmp)*(tmp = -916120166, tmp)))); + assertEquals(0.1436896445024992, x %= (tmp = 2598469263, tmp)); + assertEquals(0, x *= (x-x)); + assertEquals(-1409286144, x += (((-111514798.64745283)|(2372059654))<<(tmp = 175644313, tmp))); + assertEquals(-2393905467.0073113, x += (-984619323.0073113)); + assertEquals(-835111172.0073113, x %= (x^(-765900532.5585573))); + assertEquals(-835111172.0073113, x %= (tmp = -946478116, tmp)); + assertEquals(-100, x >>= ((-1020515908)>>(((x&((x^(169474253.53811646))>>(-221739002)))+x)*((201939882.92880356)/(tmp = -50402570, tmp))))); + assertEquals(2131506964, x &= (tmp = -2163460268, tmp)); + assertEquals(1074275840, x &= ((-1561930379.8719592)*(tmp = -2871750052.876917, tmp))); + assertEquals(-954232605.5377102, x -= (tmp = 2028508445.5377102, tmp)); + assertEquals(-29, x >>= (-279577351.87217045)); + assertEquals(-232, x <<= x); + assertEquals(-70, x |= (215185578)); + assertEquals(-1, x >>= (x>>(-1691303095))); + assertEquals(1, x /= x); + assertEquals(3149465364.2236686, x *= (3149465364.2236686)); + assertEquals(3304787832.3790073, x += (tmp = 155322468.15533853, tmp)); + assertEquals(100068712.23500109, x %= (tmp = 3204719120.1440063, tmp)); + assertEquals(91628864, x &= (tmp = 629090241, tmp)); + assertEquals(-113202292046379710, x *= (-1235443583)); + assertEquals(122, x >>>= (tmp = 3196555256, tmp)); + assertEquals(122, x >>>= (((2226535734)-x)^(2248399036.393125))); + assertEquals(6.904199169070746e-8, x /= (tmp = 1767040564.9149356, tmp)); + assertEquals(-212687449.99999994, x += ((((2244322375)*(((2515994102)^x)>>x))<<(x-(-832407685.3251972)))^(2266670502))); + assertEquals(366515938514778750, x *= (tmp = -1723260768.3940866, tmp)); + assertEquals(366515938514778750, x += ((-1643386193.9159095)/(tmp = 425161225.95316494, tmp))); + assertEquals(654872716.4123061, x /= ((-1377382984)-(tmp = -1937058061.811642, tmp))); + assertEquals(654872716, x &= x); + assertEquals(-86260926.17813063, x -= (tmp = 741133642.1781306, tmp)); + assertEquals(1052176592, x >>>= x); + assertEquals(2020882856, x ^= (-3107796616)); + assertEquals(0, x <<= ((606939871.9812952)|(tmp = -3127138319.1557302, tmp))); + assertEquals(NaN, x -= ((x%((1120711400.2242608)%x))*(tmp = -930171286.7999947, tmp))); + assertEquals(NaN, x %= (3215044180)); + assertEquals(NaN, x %= (tmp = 2882893804.20102, tmp)); + assertEquals(NaN, x %= ((217170359.5778643)^x)); + assertEquals(0, x &= ((-1095125960.9903677)>>(x^(-2227981276)))); + assertEquals(-748549860, x += (-748549860)); + assertEquals(1816208256, x <<= (-610872411.3826082)); + assertEquals(201400576, x &= (((tmp = 1910394603.4836266, tmp)<<x)^x)); + assertEquals(0, x %= x); + assertEquals(NaN, x %= x); + assertEquals(0, x <<= (((((2670901339.6696005)%(2180020861))*((2134469504)/(2237096063.0680027)))*((tmp = 1203829756, tmp)>>((765467065)+(x|(2673651811.9494815)))))<<((-1463378514)|(((x/(tmp = -1075050081, tmp))-((-879974865)+x))>>>(tmp = 2172883926, tmp))))); + assertEquals(433013198, x ^= (433013198.2833413)); + assertEquals(0, x >>= ((((-2404431196)%(x%(tmp = 1443152875.8809233, tmp)))&(x|((1414364997.0517852)/((tmp = -435854369, tmp)+(tmp = 2737625141, tmp)))))|(((tmp = 2241746562.2197237, tmp)^(tmp = -1606928010.1992552, tmp))|((tmp = -3083227418.686173, tmp)>>(tmp = -2717460410, tmp))))); + assertEquals(0, x >>= x); + assertEquals(0, x *= ((tmp = 2302521322, tmp)>>>(((((((tmp = 344089066.9725498, tmp)%(tmp = 1765830559, tmp))-x)|x)^(((-2450263325)/(tmp = 371928405.17475057, tmp))>>>(1330100413.7731652)))^(((173024329)%(tmp = -2927276187, tmp))+(x>>>(-1042229940.308507))))|(((((tmp = 379074096, tmp)+((142762508)-((-2773070834.526266)-(x&((tmp = 57957493, tmp)<<(2189553500))))))+((36991093)+(tmp = 339487168.58069587, tmp)))*(-1257565451))&(tmp = 645233114, tmp))))); + assertEquals(-2644503151.1185284, x += (-2644503151.1185284)); + assertEquals(-5289006302.237057, x += x); + assertEquals(-4008773824.2370567, x -= (tmp = -1280232478, tmp)); + assertEquals(1975449413, x |= ((tmp = 1957832005.4285066, tmp)>>((1681236712.9715524)&(-675823978)))); + assertEquals(-146472960, x <<= (-648510672.5644083)); + assertEquals(-3, x |= (((((x>>>(tmp = 2271744104, tmp))+(tmp = -210058133.30147195, tmp))+(tmp = -2827493425, tmp))/(tmp = 765962538, tmp))%(tmp = 1048631551, tmp))); + assertEquals(1, x /= x); + assertEquals(0, x >>= (1070524782.5154183)); + assertEquals(0, x <<= (462502504)); + assertEquals(0, x %= (540589670.0730014)); + assertEquals(NaN, x %= x); + assertEquals(NaN, x /= ((-1268640098)%x)); + assertEquals(NaN, x %= (1741157613.744652)); + assertEquals(NaN, x += x); + assertEquals(NaN, x %= ((x|(tmp = 1992323492.7000637, tmp))*x)); + assertEquals(NaN, x /= ((tmp = -2271503368.0341196, tmp)>>((tmp = 1224449194, tmp)>>>(tmp = 2976803997, tmp)))); + assertEquals(NaN, x += (tmp = -1078313742.1633894, tmp)); + assertEquals(NaN, x += (-787923311)); + assertEquals(NaN, x %= x); + assertEquals(-1299878219, x ^= (2995089077)); + assertEquals(536887953, x &= ((625660571.2651105)&(x^(((tmp = 950150725.2319129, tmp)+(-2122154205.466675))/(tmp = 1754964696.974752, tmp))))); + assertEquals(4096, x >>>= x); + assertEquals(1, x /= x); + assertEquals(-82508517, x ^= (((-930231800)%(tmp = -423861640.4356506, tmp))+x)); + assertEquals(-82508517, x &= (x&x)); + assertEquals(-479519, x %= ((tmp = 1861364600.595756, tmp)|x)); + assertEquals(479518, x ^= (((x>>(-1539139751.6860313))>>(tmp = -456165734, tmp))|(-2786433531))); + assertEquals(959036, x += x); + assertEquals(29, x >>>= ((tmp = -1049329009.7632706, tmp)^(((((((1117739997)/(((-841179741.4939663)*(-1211599672))>>>((-413696355)%(tmp = -1753423217.2170188, tmp))))<<(tmp = 1599076219.09274, tmp))>>>(-1382960317))^(((x^(tmp = 515115394, tmp))>>>(tmp = -388476217, tmp))>>>(x/x)))^x)<<(136327532.213817)))); + assertEquals(24, x &= (2388755418)); + assertEquals(0, x >>>= (tmp = -405535917, tmp)); + assertEquals(0, x &= (tmp = -1427139674, tmp)); + assertEquals(NaN, x /= (x^((1530470340)%x))); + assertEquals(0, x |= ((x>>(-1429690909.8472774))*((((tmp = 2033516515, tmp)/(1314782862))>>>x)>>(tmp = 1737186497.6441216, tmp)))); + assertEquals(0, x -= x); + assertEquals(0, x %= (3115422786)); + assertEquals(-0, x *= (x+(tmp = -2558930842.267017, tmp))); + assertEquals(NaN, x %= x); + assertEquals(0, x &= (2695531252.254449)); + assertEquals(-613178182, x ^= (-613178182)); + assertEquals(54, x >>>= (x%(((tmp = 2277868389, tmp)^((((tmp = -1143932265.3616111, tmp)^((x&((x-((-2100384445.7850044)|(tmp = 908075129.3456883, tmp)))*x))+(((tmp = 1031013284.0275401, tmp)*((((tmp = -233393205, tmp)>>>(tmp = -111859419, tmp))*(-1199307178))|(tmp = -1998399599, tmp)))>>>((((-731759641.9036775)>>>(tmp = 2147849691, tmp))>>>(tmp = -2121899736, tmp))>>>(x>>>x)))))>>((1900348757.360562)^(tmp = 2726336203.6149445, tmp)))>>>((x*((tmp = -2697628471.0234947, tmp)%((x^(tmp = -2751379613.9474974, tmp))*x)))+(x>>(tmp = 42868998.384643435, tmp)))))+(598988941)))); + assertEquals(34, x &= ((tmp = 2736218794.4991407, tmp)%(2169273288.1339874))); + assertEquals(2.086197133417468, x /= ((tmp = 2176358852.297597, tmp)%x)); + assertEquals(2, x <<= (((tmp = -1767330075, tmp)|(-3107230779.8512735))&x)); + assertEquals(4194304, x <<= (tmp = 1061841749.105744, tmp)); + assertEquals(48609515, x ^= (44415211.320786595)); + assertEquals(48609515, x %= (1308576139)); + assertEquals(23735, x >>>= ((-324667786)-x)); + assertEquals(23735, x <<= ((-1270911229)<<(((((tmp = -882992909.2692418, tmp)+(tmp = 394833767.947718, tmp))-x)<<(702856751))/x))); + assertEquals(-31080872939240, x *= (tmp = -1309495384, tmp)); + assertEquals(-14625.31935626114, x /= ((668084131)+(1457057357))); + assertEquals(-14625.31935626114, x %= (266351304.6585492)); + assertEquals(-12577, x |= (-945583977.619837)); + assertEquals(-4097, x |= ((tmp = -2621808583.2322493, tmp)-(tmp = -2219802863.9072213, tmp))); + assertEquals(-1004843865, x &= ((-1004839768)+((tmp = 2094772311, tmp)/(-1340720370.275643)))); + assertEquals(-31401371, x >>= ((2035921047)>>>((tmp = -1756995278, tmp)>>>(-537713689)))); + assertEquals(1791746374.016472, x -= ((tmp = -1823147745, tmp)-(x/(tmp = -1906333520, tmp)))); + assertEquals(3.7289343120517406, x /= (tmp = 480498240, tmp)); + assertEquals(7.457868624103481, x += x); + assertEquals(234881024, x <<= (-781128807.2532628)); + assertEquals(67108864, x &= (tmp = -2060391332, tmp)); + assertEquals(-605958718, x -= (673067582)); + assertEquals(-605958718, x <<= ((x%x)&((tmp = 1350579401.0801518, tmp)|x))); + assertEquals(-109268090.4715271, x %= (tmp = -496690627.5284729, tmp)); + assertEquals(-109268090, x <<= (((-2004197436.8023896)%((x|((tmp = 271117765.61283946, tmp)-((1595775845.0754795)*(555248692.2512416))))/x))<<x)); + assertEquals(-652725370, x &= (-543590449)); + assertEquals(0.321858133298825, x /= (tmp = -2027990914.2267523, tmp)); + assertEquals(1959498446, x ^= (1959498446)); + assertEquals(1959498446, x &= (x%(tmp = 3155552362.973523, tmp))); + assertEquals(14949, x >>>= ((tmp = 586618136, tmp)>>>(tmp = 699144121.9458897, tmp))); + assertEquals(-28611391568319.285, x *= (tmp = -1913933478.3811147, tmp)); + assertEquals(1680557633, x &= (((tmp = 2606436319.199714, tmp)<<(1575299025.6917372))|((-1092689109)/(735420388)))); + assertEquals(1680361024, x &= ((tmp = 1860756552.2186172, tmp)|(-360434860.1699109))); + assertEquals(820488, x >>>= (1788658731)); + assertEquals(820488, x >>= (-1555444352)); + assertEquals(2104296413, x ^= (2103543509)); + assertEquals(16843328, x &= ((x<<((-2920883149)/(1299091676)))-(((((tmp = 3199460211, tmp)+(-237287821.61504316))&(tmp = -1524515028.3596857, tmp))-(tmp = -700644414.6785603, tmp))+(-180715428.86124516)))); + assertEquals(1326969834, x |= (tmp = -2968063574.793867, tmp)); + assertEquals(0, x %= (x>>>(tmp = 1350490461.0012388, tmp))); + assertEquals(0, x &= ((-2620439260.902854)+x)); + assertEquals(-1775533561, x |= ((-1775533561)|(((x>>>((861896808.2264911)>>>(970216466.6532537)))%x)%(tmp = 2007357223.8893046, tmp)))); + assertEquals(-1775533561, x &= x); + assertEquals(-23058877.415584415, x /= ((tmp = -3002439857, tmp)>>((((x-(tmp = 1583620685.137125, tmp))|x)%(-2568798248.6863875))^x))); + assertEquals(-577.4155844151974, x %= (((-1440361053.047877)+((tmp = 821546785.0910633, tmp)-(((tmp = 1023830881.1444875, tmp)/(-754884477))+(tmp = 651938896.6258571, tmp))))>>(tmp = 346467413.8959185, tmp))); + assertEquals(-1, x >>= (tmp = 2993867511, tmp)); + assertEquals(-1, x |= (tmp = 823150253.4916545, tmp)); + assertEquals(-0, x %= x); + assertEquals(-0, x /= ((tmp = 997969036, tmp)&((((tmp = 928480121, tmp)>>(((-2610875857.086055)>>>(tmp = -2251704283, tmp))|x))+(10781750))>>x))); + assertEquals(0, x >>>= ((tmp = -1872319523, tmp)>>>(-278173884))); + assertEquals(0, x |= (x/(x*x))); + assertEquals(0, x %= ((77912826.10575807)^(tmp = 2770214585.3019757, tmp))); + assertEquals(0, x &= (tmp = 722275824, tmp)); + assertEquals(-1417226266, x |= (tmp = 2877741030.1195555, tmp)); + assertEquals(0, x ^= x); + assertEquals(0, x %= (tmp = -1740126105, tmp)); + assertEquals(910709964, x |= (tmp = 910709964, tmp)); + assertEquals(-1744830464, x <<= (tmp = -2445932551.1762686, tmp)); + assertEquals(318767104, x >>>= (tmp = -2465332061.628887, tmp)); + assertEquals(301989888, x &= (-2771167302.022801)); + assertEquals(301989888, x |= x); + assertEquals(37748736, x >>= (tmp = -835820125, tmp)); + assertEquals(1474977371, x ^= (tmp = -2857738661.6610327, tmp)); + assertEquals(470467500, x += (-1004509871)); + assertEquals(0.30466562575942585, x /= (((tmp = 1515955042, tmp)<<(x+((1607647367)-(tmp = 1427642709.697169, tmp))))^x)); + assertEquals(1.0348231148499734e-10, x /= (tmp = 2944132397, tmp)); + assertEquals(0, x >>= (x>>>(tmp = -2847037519.569043, tmp))); + assertEquals(NaN, x /= x); + assertEquals(0, x >>>= (-1817784819.9058492)); + assertEquals(0, x >>= x); + assertEquals(-0, x *= ((tmp = -1387748473, tmp)|(x+(352432111)))); + assertEquals(-0, x *= (((-2591789329)/(tmp = -2144460203, tmp))>>(tmp = -568837912.5033123, tmp))); + assertEquals(0, x <<= (-2963600437.305708)); + assertEquals(0, x &= ((588720662)>>>x)); + assertEquals(1561910729, x += (1561910729)); + assertEquals(0, x ^= x); + assertEquals(-0, x *= (-2722445702)); + assertEquals(0, x &= (tmp = -2738643199.732308, tmp)); + assertEquals(0, x /= (((1859901899.227291)>>>((tmp = -1067365693, tmp)+((-1975435278)|x)))|((1844023313.3719304)&(tmp = -624215417.0227654, tmp)))); + assertEquals(NaN, x %= x); + assertEquals(NaN, x %= (-2852766277)); + assertEquals(0, x <<= (-1482859558)); + assertEquals(0, x >>= x); + assertEquals(-1196775786, x += (tmp = -1196775786, tmp)); + assertEquals(-68176201, x |= ((tmp = 2336517643, tmp)+x)); + assertEquals(0, x ^= x); + assertEquals(0, x <<= x); + assertEquals(0, x >>= (2969141362.868086)); + assertEquals(NaN, x %= x); + assertEquals(0, x >>= ((x-((((tmp = -905994835, tmp)|(tmp = 2850569869.33876, tmp))<<((-2405056608.27147)>>(tmp = 1280271785, tmp)))&(-1942926558)))*(tmp = 707499803.177796, tmp))); + assertEquals(0, x &= ((-697565829.8780258)+((2978584888.549406)%x))); + assertEquals(0, x >>= (748642824.4181392)); + assertEquals(0, x += x); + assertEquals(0, x >>>= (-1701028721)); + assertEquals(92042539, x -= ((-92042539)|(x*(x%(-293705541.00228095))))); + assertEquals(0, x %= x); + assertEquals(0, x >>= x); + assertEquals(0, x %= (-2278672472.458228)); + assertEquals(0, x %= (((-2374117528.0359464)/((tmp = -2809986062, tmp)|(tmp = 895734980, tmp)))&(tmp = 1564711307.41494, tmp))); + assertEquals(0, x >>>= x); + assertEquals(0, x += x); + assertEquals(-0, x /= ((tmp = -2749286790.3666043, tmp)<<(x^(-2966741582.324482)))); + assertEquals(0, x *= x); + assertEquals(0, x >>>= x); + assertEquals(-1882562314, x ^= (2412404982.782115)); + assertEquals(-806620, x %= (((tmp = 1527219936.5232096, tmp)*(-1139841417))>>>(tmp = 201632907.3236668, tmp))); + assertEquals(-1613240, x += x); + assertEquals(-1664766177387640, x *= (1031939561)); + assertEquals(-9.478083550117849e+23, x *= (tmp = 569334221.1571662, tmp)); + assertEquals(-8.462574598319509e+21, x /= ((x-(tmp = -2985531211.114498, tmp))>>(tmp = 174615992.91117632, tmp))); + assertEquals(1638924288, x <<= (((((x>>((-1823401733.4788911)+((tmp = 1362371590, tmp)>>>x)))^(tmp = -56634380, tmp))/(tmp = 2387980757.1540084, tmp))%((((tmp = -3175469977, tmp)^(tmp = -1816794042, tmp))+(232726694))*(tmp = 822706176, tmp)))/(tmp = 1466729893.836311, tmp))); + assertEquals(2686072821796307000, x *= x); + assertEquals(-1007977445.9812208, x /= (-2664814408.800125)); + assertEquals(-1007977445, x &= x); + assertEquals(322314656346249100, x *= (tmp = -319763758.54942775, tmp)); + assertEquals(197436885.26815608, x /= (tmp = 1632494637, tmp)); + assertEquals(-67191339, x |= ((-399580815.1746769)/((1335558363)/(tmp = 224694526, tmp)))); + assertEquals(1229588737, x &= (tmp = 1296763683.5732255, tmp)); + assertEquals(1229588737, x -= ((((1171546503)|((tmp = -2701891308, tmp)%(-2155432197.022206)))/(-306122816.85682726))>>x)); + assertEquals(4162606632, x -= (tmp = -2933017895, tmp)); + assertEquals(1.6487311395551163, x /= (2524733434.1748486)); + assertEquals(-1929308648.9913044, x += (-1929308650.6400356)); + assertEquals(-3858617297.982609, x += x); + assertEquals(788529152, x <<= (x^(1401824663))); + assertEquals(6160384, x >>>= ((((((x>>>x)>>((((x*(tmp = -1958877151, tmp))>>>(1310891043))-(tmp = 564909413.9962088, tmp))%(-175978438)))%x)|((tmp = -1193552419.7837512, tmp)*(tmp = 1508330424.9068346, tmp)))|(1428324616.3303494))-((1828673751)/(tmp = 1281364779, tmp)))); + assertEquals(6160384, x |= x); + assertEquals(1, x /= x); + assertEquals(1, x &= (tmp = -855689741, tmp)); + assertEquals(0, x >>>= x); + assertEquals(-1088569655.3528988, x -= (tmp = 1088569655.3528988, tmp)); + assertEquals(-1088569655, x >>= ((tmp = 2429646226.626727, tmp)<<((-1539293782.4487276)>>(x^((tmp = 1140855945.537702, tmp)+x))))); + assertEquals(-311, x %= ((x/x)<<x)); + assertEquals(1.2007722007722008, x /= (x|(tmp = 448796341.87655175, tmp))); + assertEquals(3, x |= (x+x)); + assertEquals(-9.32416092168023e-10, x /= (-3217447688)); + assertEquals(0, x >>= (615837464.0921166)); + assertEquals(0, x >>>= (tmp = -2993750670.683118, tmp)); + assertEquals(0, x >>>= (x%x)); + assertEquals(1610612736, x ^= ((-1322905256.6770213)<<(-2567950598))); + assertEquals(1693676493, x ^= (83063757.63660407)); + assertEquals(-758030371, x ^= (tmp = -1239274480, tmp)); + assertEquals(-758030371, x %= (tmp = 1961339006, tmp)); + assertEquals(-1509754528, x ^= (tmp = 1960027837, tmp)); + assertEquals(-1509754528, x <<= x); + assertEquals(-1509754528, x -= (((tmp = -50690205.33559728, tmp)/((tmp = -1364565380, tmp)<<(tmp = 2585052504, tmp)))<<(tmp = -2356889596, tmp))); + assertEquals(1, x >>>= (-3204164321)); + assertEquals(1, x *= x); + assertEquals(1114370230.591965, x *= ((tmp = 1114370229.591965, tmp)+x)); + assertEquals(-4.886305275432552, x /= ((-228059887.33344483)%(2841553631.3685856))); + assertEquals(2.358309397373389e-9, x /= (((x*(tmp = 203428818.08174622, tmp))&(x-(((510438355)*x)+x)))+x)); + assertEquals(0, x >>>= ((tmp = 1444810010, tmp)&(tmp = -3135701995.2235208, tmp))); + assertEquals(0, x /= (1865982928.6819582)); + assertEquals(0, x *= x); + assertEquals(2078726016.3772051, x -= (tmp = -2078726016.3772051, tmp)); + assertEquals(1580337898, x ^= ((tmp = -2714629398.447015, tmp)^x)); + assertEquals(1268363034, x -= ((x+((tmp = 1144068248.3834887, tmp)&(-954104940.155973)))<<(tmp = 1270573731.7828264, tmp))); + assertEquals(1744830464, x <<= (((1444869551.7830744)>>>((((x+(tmp = -904688528, tmp))<<x)-((tmp = 121151912.85873199, tmp)/(tmp = -2414150217.66479, tmp)))|(((-472906698)|(3215236833.8417764))+(907737193.9056952))))-((x&(-732223723))|(-221800427.7392578)))); + assertEquals(717338523283226600, x *= (x^(tmp = -2407450097.0604715, tmp))); + assertEquals(402653184, x >>= ((-3191405201.168252)*((tmp = -1941299639.695196, tmp)|(((x>>(((3215741220)>>>x)/(x+x)))^(((tmp = -2144862025.9842231, tmp)|((tmp = -1966913385, tmp)&x))%x))*((tmp = -1124749626.6112225, tmp)/(tmp = 837842574, tmp)))))); + assertEquals(402653184, x &= ((x|x)>>x)); + assertEquals(134217728, x &= ((2720231644.3849487)*x)); + assertEquals(134217726.75839183, x -= ((2438054684.738043)/(((((-984359711)*(x|((tmp = 177559682, tmp)^x)))/(-1253443505))/((2727868438.416792)*(x+((x<<(((tmp = 3023774345, tmp)&(-705699616.0846889))/x))<<x))))^(1963626488.548761)))); + assertEquals(1, x /= x); + assertEquals(245781494, x += ((tmp = 2551445099, tmp)^(2528486814))); + assertEquals(-1474427807, x ^= (-1497868393.342241)); + assertEquals(-1057271682, x += ((((((x>>x)%(-1556081693))|(x/(((1166243186.6325684)-(((tmp = 2870118257.1019487, tmp)/(x+(-69909960)))^(2270610694.671496)))/((1463187204.5849519)-x))))-x)-(x<<(-3077313003)))%x)); + assertEquals(-1065725846, x &= ((tmp = -1808223767, tmp)|(-481628214.3871765))); + assertEquals(-1065725846, x ^= (x&(((tmp = -1785170598, tmp)-(tmp = -2525350446.346484, tmp))/((((((-1783948056)^(tmp = 3027265884.41588, tmp))|((((tmp = 2195362566.2237773, tmp)<<(-2919444619))<<((tmp = -2507253075.2897573, tmp)^(x^((tmp = 1067516137, tmp)+((667737752)^(x*(tmp = -1187604212.7293758, tmp)))))))%(-617406719.5140038)))*(tmp = 511060465.6632478, tmp))*((tmp = 2580189800.752836, tmp)|((((tmp = 2357895660, tmp)%((-814381220)*(x-((x>>>(((x<<x)<<(tmp = 1919573020, tmp))-x))>>>((-2756011312.136148)>>(tmp = -1603458856, tmp))))))/((tmp = -1609199312, tmp)&(-3127643445)))%x)))<<(-2261731798))))); + assertEquals(1.6020307924030301, x /= (tmp = -665234308.2628405, tmp)); + assertEquals(-1120020556.697667, x *= (tmp = -699125486.2321637, tmp)); + assertEquals(-215875188, x -= (((((tmp = -1307845034, tmp)>>>((((-2820720421)^x)-(((x<<x)|(tmp = -3042092997.57406, tmp))+(((-1294857544)+((tmp = -668029108.1487186, tmp)>>(x<<x)))^(912144065.5274727))))^(389671596.2983854)))|(-2774264897.146559))%(x-((tmp = 1378085269, tmp)^x)))+((-1659377450.5247462)&(((1613063452.834885)>>>((-344896580.0694165)>>>((-13450558)+x)))^x)))); + assertEquals(1, x /= x); + assertEquals(0, x >>>= (2355750790)); + assertEquals(1969435421.4409347, x += (1969435421.4409347)); + assertEquals(0, x -= x); + assertEquals(0, x >>>= (((x*((-1022802960.6953495)<<(tmp = -2848428731.8339424, tmp)))^(-1630921485))%(1532937011))); + assertEquals(0, x <<= ((x+((x^(x^(tmp = 2017651860, tmp)))&(((x<<(((tmp = -1913317290.8189478, tmp)|(x-((((x%((tmp = -3035245210, tmp)+(-2270863807)))>>>((-2351852712)*(x^(-2422943296.0239563))))&((((-1578312517)%x)*x)*(-65592270.28452802)))>>>(tmp = 1104329727.2094703, tmp))))-(tmp = -1431159990.3340137, tmp)))&x)|((tmp = -2589292678.801344, tmp)&(x+((((tmp = -2557773457.456996, tmp)>>(451910805.309445))-x)>>(((tmp = -1937832765.7654495, tmp)^x)%x)))))))%x)); + assertEquals(0, x %= (tmp = -626944459, tmp)); + assertEquals(-732310021, x |= (tmp = -732310021, tmp)); + assertEquals(-732310021, x |= x); + assertEquals(671352839, x ^= (x-((-3087309090.7153115)|x))); + assertEquals(134479872, x &= (tmp = 2357183984, tmp)); + assertEquals(18084835973136384, x *= x); + assertEquals(0, x <<= ((1040482277)-(tmp = -357113781.82650447, tmp))); + assertEquals(74957, x |= ((((tmp = -70789345.7489841, tmp)%(tmp = 1415750131, tmp))&x)|((307027314)>>(2284275468)))); + assertEquals(9, x >>>= x); + assertEquals(0, x &= (x&((x*((x*(x%x))%(x>>x)))/x))); + assertEquals(-1872875060, x |= (2422092236.6850452)); + assertEquals(9, x >>>= (-382763684)); + assertEquals(4608, x <<= x); + assertEquals(40.480234260614935, x /= (((((((tmp = 814638767.5666755, tmp)&((tmp = 2081507162, tmp)^(x>>>(1460148331.2229118))))&(tmp = 1187669197.7318723, tmp))<<(412000677.93339765))^((tmp = 556111951, tmp)>>(tmp = -2232569601.292395, tmp)))&(-3006386864))/x)); + assertEquals(32, x &= (-3053435209.383913)); + assertEquals(418357217, x ^= (418357185)); + assertEquals(204275, x >>= ((-1188650337.9010527)^((51494580)%(-2544545273)))); + assertEquals(982392804, x += (((x+(((tmp = -982596937.9757051, tmp)+x)%(-2298479347)))^((((tmp = 1610297674.0732534, tmp)>>>x)*(((x>>(-2746780903.08599))&(-2376190704.247188))^(((20545353)/(tmp = 1468302977, tmp))-(x<<x))))>>(((-1434332028.0447056)/((tmp = 1983686888, tmp)&((tmp = 2324500847, tmp)%(394330230.6163173))))%(((-1129687479.2158055)+((-3127595161)*((-3066570223)&((tmp = 3192134577.4963055, tmp)/(-2697915283.3233275)))))+(-1112243977.5306559)))))|(x&(-2622725228)))); + assertEquals(-2735750653096133600, x *= (-2784782870.9218984)); + assertEquals(-1876329472, x |= ((((((2752866171)<<(-1681590319))/x)>>((tmp = 1451415208, tmp)>>>(1126858636.6634417)))+(((tmp = 2165569430.4844217, tmp)/x)^(((tmp = -1675421843.4364457, tmp)-(-2187743422.2866993))|x)))*x)); + assertEquals(3520612287495799000, x *= x); + assertEquals(-200278016, x |= ((((-2379590931)%((((-1558827450.833285)&x)>>(-665140792))-((tmp = -445783631.05567217, tmp)+(tmp = 93938389.53113222, tmp))))/(3103476273.734701))^x)); + assertEquals(-9178285062592.75, x *= ((2042671875.7211144)%(((tmp = 589269308.0452716, tmp)/x)<<(-130695915.9934752)))); + assertEquals(60048960, x |= (x<<x)); + assertEquals(60048960, x <<= ((((((tmp = -2793966650, tmp)/(-2882180652))&(((x<<((tmp = -384468710, tmp)+(2236162820.9930468)))>>>((((969371919)>>((tmp = -3153268403.2565875, tmp)-((((573811084)/x)^(tmp = -968372697.4844134, tmp))>>>(((-3096129189)>>x)/(tmp = 830228804.6249363, tmp)))))<<(((1243972633.3592157)|x)&((-1687610429)&(tmp = -1945063977.458529, tmp))))<<(((tmp = -217456781.37068868, tmp)-(400259171.68077815))^x)))>>>x))%(((2728450651.300167)/(((-2713666705.089135)%(tmp = 740472459, tmp))^x))|x))^x)*(-2463032364))); + assertEquals(60048960, x %= (tmp = -442107222.9513445, tmp)); + assertEquals(-1573781504, x <<= (960581227)); + assertEquals(1297, x >>>= (tmp = -1692919563, tmp)); + assertEquals(1297, x &= x); + assertEquals(-3113308397155.233, x *= (tmp = -2400391979.3024154, tmp)); + assertEquals(-3115513013486.233, x -= (2204616331)); + assertEquals(-3113809649082.233, x -= (-1703364404)); + assertEquals(0, x >>>= (((-1181206665)-(550946816.586771))|(tmp = -2346300456, tmp))); + assertEquals(0, x %= (tmp = 1649529739.2785435, tmp)); + assertEquals(0, x ^= ((tmp = -2452761827.2870226, tmp)%(((1090281070.5550141)/(tmp = 992149154.6500508, tmp))*(x<<((((((x>>>x)|((tmp = -2410892363, tmp)%(tmp = 2585150431.0231533, tmp)))/x)*(tmp = 1541294271, tmp))+x)&((97566561.77126992)&((((-640933510.1287451)&(((((x>>>((-1821077041)<<((tmp = -1138504062.093695, tmp)-(tmp = -181292160, tmp))))%x)-(x>>((x&(((tmp = 1067551355, tmp)/(x|(1004837864.8550552)))&(x-(-103229639.25084043))))&((tmp = 2064184671.210937, tmp)+((((tmp = -2245728052, tmp)|(1538407002.8365717))+(x<<((x>>((76549490)/(tmp = 628901902.6084052, tmp)))<<((x<<x)^(-1907669184)))))+(-1409123688))))))>>>((((-1911547456.933543)-((-512313175)+((tmp = -2620903017, tmp)^(tmp = 2148757592.244808, tmp))))<<((-1740876865)>>>x))+((tmp = 691314720.9488736, tmp)<<(614057604.4104803))))|(x^((tmp = -3040687.291528702, tmp)/(x^(((x+(-2899641915))^((tmp = -1220211746, tmp)/x))%x))))))^(tmp = 119850608, tmp))%(2091975696)))))))); + assertEquals(291273239, x -= (tmp = -291273239, tmp)); + assertEquals(2206394018, x += (1915120779)); + assertEquals(235641480, x <<= (x&(x&(-1810963865.1415658)))); + assertEquals(28764, x >>= ((tmp = -1927011875, tmp)^((tmp = -1986461808, tmp)|((-868139264.8399222)*((421956566)%(3068424525)))))); + assertEquals(-99780626900900, x *= ((tmp = -1512869526.3223472, tmp)+(tmp = -1956071751, tmp))); + assertEquals(51218520, x &= (((-2353401311)>>>x)-(2216842509))); + assertEquals(51218520, x >>>= ((tmp = -1534539302.6990812, tmp)<<x)); + assertEquals(-2147483648, x <<= (-292608644)); + assertEquals(-2147483648, x |= ((((((x<<((-2981292735)-x))>>((tmp = 2540545320.96558, tmp)&(tmp = -2343790880, tmp)))>>>((((((x^((-172697043.94487858)/((2627260337)>>(2879112814.1247935))))&(tmp = 3000943191, tmp))<<(tmp = 1094830905, tmp))-x)>>>x)>>((((tmp = 3095796200, tmp)^(x|(tmp = 1460377694, tmp)))<<(x^(tmp = -357546193, tmp)))/((2729539495)>>x))))%(tmp = 268894171.74961245, tmp))|(x>>(tmp = 2735650924, tmp)))/(-2197885357.09768))); + assertEquals(-2147483648, x |= x); + assertEquals(-1967162776824578000, x *= (tmp = 916031551, tmp)); + assertEquals(-2147483648, x &= x); + assertEquals(-457743917756973060, x *= (tmp = 213153622, tmp)); + assertEquals(0, x >>>= ((((tmp = 2930076928.480559, tmp)+(x^x))<<(tmp = -1349755597.1280541, tmp))|(x+(2865632849)))); + assertEquals(0, x <<= ((x>>x)-(x>>(-2629977861)))); + assertEquals(0, x <<= x); + assertEquals(NaN, x /= x); + assertEquals(0, x |= x); + assertEquals(0, x >>>= x); + assertEquals(749327478, x |= ((tmp = 749327478, tmp)^(x>>(tmp = 881107862, tmp)))); + assertEquals(1897869364, x += (1148541886)); + assertEquals(463347, x >>>= (tmp = -726431220, tmp)); + assertEquals(-395990542, x += (-396453889)); + assertEquals(-2824792585.1675367, x -= (2428802043.1675367)); + assertEquals(-2147483648, x <<= (tmp = -1420072385.9175675, tmp)); + assertEquals(8388608, x >>>= (-2211390680.488455)); + assertEquals(8388608, x >>= (((x/(x|(((x^(((tmp = -2175960170.8055067, tmp)|((tmp = -1964957385.9669886, tmp)/(tmp = -475033330, tmp)))&((x|((tmp = 1386597019.2014387, tmp)>>((tmp = -2406589229.8801174, tmp)+x)))<<(tmp = -844032843.8415492, tmp))))>>(x^x))|x)))-((x&((tmp = 1858138856, tmp)*(-3156357504)))%x))<<(((2046448340)+x)/(-2645926916)))); + assertEquals(8359470765396279, x *= ((tmp = 871437183.7888144, tmp)-(-125089387.17460155))); + assertEquals(0, x ^= x); + assertEquals(-303039014, x += ((tmp = -2475713214, tmp)|(-372871718.2343409))); + assertEquals(2655126577, x -= (-2958165591)); + assertEquals(1830332793, x ^= (tmp = -212161208, tmp)); + assertEquals(1830332793, x ^= (((2352454407.0126333)<<((((tmp = 3083552367, tmp)/x)-(-1243111279))-((tmp = -1669093976, tmp)%(((-757485455)-(tmp = -116051602, tmp))<<x))))>>(((((-2235071915.9536905)>>(tmp = -1284656185, tmp))-x)>>((-1807028069.7202528)>>>((x%((tmp = -3070857953.311804, tmp)+((tmp = 2759633693.441942, tmp)%((169489938)*(-1582267384)))))<<(x^((tmp = -787578860, tmp)<<x)))))>>((x/(x|(409464362)))-(tmp = -64033017, tmp))))); + assertEquals(397605933.90319204, x %= (tmp = 716363429.548404, tmp)); + assertEquals(186400, x &= (((x%(-1745754586))>>>x)<<(x&(x&((-2163627752)-((1784050895)+(((-2864781121.899456)>>>x)&x))))))); + assertEquals(186400, x %= (tmp = -423209729, tmp)); + assertEquals(186400, x <<= ((x<<(x+(1232575114.4447284)))*x)); + assertEquals(1386299, x ^= ((tmp = -1074209615, tmp)>>>(x>>>((tmp = -1456741008.2654872, tmp)>>((1724761067)>>(-2016103779.9084842)))))); + assertEquals(347302967.20758367, x -= (-345916668.20758367)); + assertEquals(1.9325619389304094, x /= (179711170.03359854)); + assertEquals(-3703324711.628227, x *= (tmp = -1916277371, tmp)); + assertEquals(-920980517031624800, x *= (tmp = 248690187.53332615, tmp)); + assertEquals(0, x &= (((tmp = -2753945953.082594, tmp)*x)-(172907186))); + assertEquals(-0, x /= (((((-2744323543.187253)>>((tmp = 2663112845, tmp)>>(((-121791600)+(x^x))*(2758944252.4214177))))|x)/(tmp = -2746716631.6805267, tmp))-x)); + assertEquals(0, x ^= ((tmp = 983113117, tmp)&((2638307333)+((((tmp = 3076361304.56189, tmp)<<(-2663410588.5895214))%((-1109962112)-(tmp = -2381021732, tmp)))%((tmp = 410559095, tmp)&x))))); + assertEquals(0, x <<= (tmp = 1510895336.5111506, tmp)); + assertEquals(0, x <<= (tmp = -1688348296.2730422, tmp)); + assertEquals(2269471424, x -= (-2269471424)); + assertEquals(-2022580224, x ^= (x%((tmp = 160999480.21415842, tmp)&x))); + assertEquals(-2077171712, x &= (tmp = 3032415014.3817654, tmp)); + assertEquals(270727, x >>>= (2973489165.1553965)); + assertEquals(270727, x |= x); + assertEquals(-1895894537, x |= ((tmp = -1895903118.129186, tmp)|x)); + assertEquals(-1895894537, x -= ((((((((3143124509)>>>(-2866190144.8724117))*((x>>((961021882)*(tmp = 2363055833.8634424, tmp)))/((2032785518)+((2713643671.3420825)>>((-447782997.0173557)*((tmp = 1174918125.3178625, tmp)*((((tmp = -541539365.548115, tmp)%(-359633101))|(1765169562.2880063))+(tmp = -2512371966.374508, tmp))))))))/x)>>(x*((((-847238927.6399388)&(857288850))%(-2427015402))^((2221426567)%(x+x)))))>>>x)<<((tmp = 2009453564.2808268, tmp)>>((2924411494)<<(x>>(tmp = -1240031020.8711805, tmp)))))%(tmp = 3118159353, tmp))); + assertEquals(0, x ^= x); + assertEquals(0, x %= (-30151583)); + assertEquals(-1035186736, x ^= ((tmp = -517593368, tmp)<<(tmp = 3216155585, tmp))); + assertEquals(49740, x >>>= x); + assertEquals(49740, x %= (640223506)); + assertEquals(388, x >>>= ((x>>(tmp = 3161620923.50496, tmp))+(2605183207))); + assertEquals(776, x += x); + assertEquals(-97905, x ^= ((((((tmp = 145447047.8783008, tmp)^(((x>>>(tmp = 3014858214.2409887, tmp))>>>(629911626.132971))>>(((x+((369309637.229408)-x))<<(-2661038814.9204755))*(x+(x%(3025191323.4780884))))))+x)*(-482550691))|(-632782135))/x)); + assertEquals(-97905, x %= ((((-492914681)-((-2508632959.269368)&(tmp = 1209318291, tmp)))>>(-723512989.459533))>>>(((-528429623.985692)&(x^(tmp = -925044503, tmp)))-(-1696531234)))); + assertEquals(9585389025, x *= x); + assertEquals(-715425728, x <<= ((583763091)<<(-1223615295))); + assertEquals(-520093696, x <<= ((tmp = -1891357699.671592, tmp)*(((tmp = 3206095739.5163193, tmp)+(-2908596651.798733))>>>((tmp = -2820415686, tmp)>>(x|((((tmp = -566367675.6250327, tmp)*(-959117054))>>((((-187457085.89686918)*x)*(tmp = -2394776877.5373516, tmp))>>>x))|(((tmp = 80478970.46290505, tmp)<<(tmp = 2173570349.493097, tmp))-(x/((-2896765964)-((x/((tmp = 198741535.7034216, tmp)%(436741457)))%(tmp = 2936044280.0587225, tmp))))))))))); + assertEquals(-2520.5909527086624, x /= ((211290893.06029093)>>(663265322))); + assertEquals(-2520.5909527086624, x %= (x^((1057915688)<<(tmp = 1914820571.1142511, tmp)))); + assertEquals(1, x >>>= (((894963408.7746166)+(tmp = -2888351666, tmp))|x)); + assertEquals(-1989841636629996300, x += ((1424670316.224575)*((-2144149843.0876865)|((((421479301.0983993)|((3082651798)^(tmp = -271906497, tmp)))>>x)+((tmp = -178372083, tmp)%x))))); + assertEquals(17935384255.088326, x /= (((((((tmp = 1168194849.2361898, tmp)>>>(-107316520.53815603))>>>(x^(((x%((x>>>(((-2456622387)/x)&((2124689803)|(((-1130151701)^(2796315158))>>x))))-((-884686033.5491502)>>>((-2371185318.5358763)&x))))+(tmp = 558422989, tmp))|((tmp = -420359120.0596726, tmp)/((-1820568437.0587764)&(2298602280.266465))))))>>(x-((tmp = -1164568978, tmp)^x)))^x)-x)+x)); + assertEquals(134233150, x &= ((x>>(((tmp = 98498118.13041973, tmp)-(804574397))/(tmp = -1564490985.7904541, tmp)))+x)); + assertEquals(4, x >>= (449610809)); + assertEquals(1912543790, x |= (1912543790)); + assertEquals(2487274263, x += (tmp = 574730473, tmp)); + assertEquals(-2140759118, x ^= (tmp = 338055333.9701035, tmp)); + assertEquals(311607367, x += (2452366485)); + assertEquals(9509, x >>= (372113647.84365284)); + assertEquals(-2001075684.1562128, x += (-2001085193.1562128)); + assertEquals(-638703280, x ^= (((tmp = 1096152237, tmp)&x)|((2707404245.0966487)-(((tmp = 1550233654.9691348, tmp)+(tmp = 2008619647, tmp))&((tmp = -2653266325, tmp)+(tmp = -280936332, tmp)))))); + assertEquals(-101811850, x |= (-2250090202)); + assertEquals(-13, x >>= ((-561312810.0218933)|(tmp = 79838949.86521482, tmp))); + assertEquals(-13, x >>= ((tmp = -936543584, tmp)/(1180727664.1746705))); + assertEquals(-1547, x *= (((tmp = 1005197689, tmp)>>>x)>>>(tmp = 34607588, tmp))); + assertEquals(2393209, x *= x); + assertEquals(2393209, x |= x); + assertEquals(0, x >>= (-2691279235.1215696)); + assertEquals(0, x *= (((896175510.4920144)*((((tmp = 1770236555.7788959, tmp)%(537168585.7310632))/x)&(tmp = 1094337576, tmp)))&(((x-x)-x)>>x))); + assertEquals(-1922620126, x ^= (-1922620126)); + assertEquals(3.43481396325761, x /= (tmp = -559745053.6088333, tmp)); + assertEquals(0, x >>= x); + assertEquals(0, x >>>= (tmp = 2106956255.6602135, tmp)); + assertEquals(-1339003770, x ^= ((tmp = 2955963526.960022, tmp)+x)); + assertEquals(-0, x *= ((((tmp = 368669994, tmp)>>>(x*x))<<(tmp = 2355889375, tmp))&(tmp = -2267550563.9174895, tmp))); + assertEquals(0, x >>= (753848520.8946902)); + assertEquals(0, x >>>= x); + assertEquals(0, x %= ((tmp = -2872753234.2257266, tmp)|x)); + assertEquals(NaN, x %= (x>>>(tmp = 890474186.0898918, tmp))); + assertEquals(NaN, x %= ((tmp = 1341133992.284471, tmp)&(tmp = -2979219283.794898, tmp))); + assertEquals(NaN, x += (-2865467651.1743298)); + assertEquals(NaN, x += ((-1424445677)%(x^(tmp = 1150366884, tmp)))); + assertEquals(0, x &= (x+((tmp = 1499426534, tmp)+x))); + assertEquals(0, x |= (((((tmp = -2413914642, tmp)<<((x>>>x)^(1218748804)))+((((-1085643932.2642736)-(-1199134221.533854))>>(tmp = 2148778719, tmp))-((tmp = 1589158782.0040946, tmp)/(tmp = -2485474016.1575155, tmp))))>>>(x>>x))/(2230919719))); + assertEquals(0, x %= ((tmp = -2576387170.517563, tmp)>>>((tmp = -2362334915.919525, tmp)>>>(((3096453582)-(700067891.4834484))^(2396394772.9253683))))); + assertEquals(-1798103432, x ^= (((((tmp = 2396144191, tmp)*(x>>>(1512158325)))&(((-1256228298.5444434)&(((-2963136043.434966)&((tmp = 2472984854, tmp)+(tmp = -454900927, tmp)))%(tmp = 484255852.65332687, tmp)))>>((x%x)-x)))&(tmp = 929723984, tmp))^(tmp = -1798103432.5838807, tmp))); + assertEquals(-2137913344, x &= ((((x|(-2970116473))&(((x/x)/((tmp = 2853070005, tmp)>>>x))%(((tmp = -3123344846, tmp)/((2224296621.6742916)-(tmp = -2246403296.455411, tmp)))+((x&(((x^(x*(2829687641)))+x)&(tmp = 988992521, tmp)))^x))))<<((((-820608336)^(tmp = 2851897085, tmp))>>(tmp = -402427624, tmp))>>>x))-(((x*(((-2287402266.4821453)%(tmp = -520664172.1831205, tmp))^(x/(1875488837))))<<(tmp = 402393637, tmp))&(tmp = 1576638746.3047547, tmp)))); + assertEquals(-2827557853031924000, x *= (tmp = 1322578326.6507945, tmp)); + assertEquals(6.424459501778244e+27, x *= (tmp = -2272087729.3065624, tmp)); + assertEquals(-1586887483, x |= (-1586887483)); + assertEquals(-567868980691736100, x *= (tmp = 357850816, tmp)); + assertEquals(1489101591, x ^= (x%(x|(421921075)))); + assertEquals(-801213804822328000, x *= (x|(-672326904.6888077))); + assertEquals(612257233.6612054, x /= (((tmp = -350127617, tmp)>>>(-1140467595.9752212))<<((x^x)+(-3117914887)))); + assertEquals(19097.231243331422, x /= ((x^(tmp = -570012517, tmp))>>>x)); + assertEquals(0, x >>= ((x%(((-2347648358)%((x-(tmp = -456496327, tmp))|(x^(-1977407615.4582832))))<<(x/(tmp = -2021394626.214082, tmp))))%(tmp = -949323000.2442119, tmp))); + assertEquals(0, x <<= x); + assertEquals(NaN, x %= (x^(x>>(((tmp = 597147546.7701412, tmp)&(((((-972400689.6267757)|(tmp = -2390675341.6367044, tmp))|(tmp = 1890069123.9831812, tmp))<<(((1606974563)-(tmp = -2211617255.8450356, tmp))&((((x+((2433096953)&(-2527357746.681596)))*(tmp = -313956807.55609417, tmp))|((tmp = -2146031047.968496, tmp)/(tmp = 2851650714.68952, tmp)))>>(((tmp = 2630692376.6265225, tmp)-(tmp = -3162222598, tmp))>>((tmp = 1915552466, tmp)*(x>>>(-2413248225.7536864)))))))&(x%((((1218471556)|x)+(tmp = -849693122.6355379, tmp))+x))))>>>(x/((tmp = 689889363, tmp)/x)))))); + assertEquals(0, x >>>= (45649573.23297)); + assertEquals(0, x >>>= (tmp = 1084439432.771266, tmp)); + assertEquals(NaN, x /= x); + assertEquals(NaN, x *= (tmp = 1642750077, tmp)); + assertEquals(0, x >>>= (tmp = -1944001182.0778434, tmp)); + assertEquals(1682573000, x |= (tmp = -2612394296.2858696, tmp)); + assertEquals(3041823595, x -= (((tmp = 720576773, tmp)|(x^(-1068335724.2253149)))>>(x*(-2501017061)))); + assertEquals(6083647190, x += x); + assertEquals(-6536258988089986000, x *= ((tmp = 632312939.6147232, tmp)|((-1621821634)+(((tmp = -2281369913.562131, tmp)&((tmp = -381226774, tmp)|x))&(664399051))))); + assertEquals(4.272268155938712e+37, x *= x); + assertEquals(733271152, x %= (-1345127171)); + assertEquals(847089925, x ^= (tmp = 432620917.57699084, tmp)); + assertEquals(1337073824, x <<= x); + assertEquals(-25810602, x ^= (tmp = 2982414838, tmp)); + assertEquals(-25282209, x |= ((tmp = -2927596922, tmp)>>>(-2404046645.01413))); + assertEquals(639190091919681, x *= x); + assertEquals(173568320, x &= ((((tmp = -718515534.4119437, tmp)&(tmp = 2989263401, tmp))<<x)|((tmp = 537073030.5331153, tmp)-(tmp = 883595389.314624, tmp)))); + assertEquals(0, x -= x); + assertEquals(0, x >>>= (tmp = -1844717424.917882, tmp)); + assertEquals(0, x >>= (tmp = -462881544.2225325, tmp)); + assertEquals(0, x >>= x); + assertEquals(-1868450038, x ^= (2426517258.6111603)); + assertEquals(1, x /= x); + assertEquals(1175936039.4202638, x += (tmp = 1175936038.4202638, tmp)); + assertEquals(-127916015, x ^= ((x/(1841969600.3012052))-(tmp = 1099467723, tmp))); + assertEquals(395713785658171900, x *= (-3093543726)); + assertEquals(395713787128560900, x += (((((-717204758)*(tmp = -588182129.6898501, tmp))-x)+(tmp = 20638023, tmp))^x)); + assertEquals(-962609355, x |= ((x^(-3118556619.912983))<<((tmp = 876126864, tmp)&x))); + assertEquals(-962609355, x %= (tmp = -2079049990, tmp)); +} +f(); diff --git a/src/3rdparty/v8/test/mjsunit/numops-fuzz-part2.js b/src/3rdparty/v8/test/mjsunit/numops-fuzz-part2.js new file mode 100644 index 0000000..51260a4 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/numops-fuzz-part2.js @@ -0,0 +1,1178 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +function f() { + var x = -962609355; + var tmp = 0; + assertEquals(-114583755, x -= (((-2806715240)&(((1961136061.0329285)>>>((2087162059)*x))+((tmp = -1890084022.7631018, tmp)%(tmp = 2137514142.358262, tmp))))+(x<<(tmp = 2991240918, tmp)))); + assertEquals(-425721856, x <<= x); + assertEquals(3778560, x >>>= ((x|(3198503572))>>(1158434541.1099558))); + assertEquals(3778560, x %= (tmp = -2592585378.9592104, tmp)); + assertEquals(624640, x &= (tmp = 2261638192.9864054, tmp)); + assertEquals(1249280, x += x); + assertEquals(1048576, x &= ((tmp = -2144301819.9892588, tmp)^((x-x)<<x))); + assertEquals(2097152, x <<= (x/x)); + assertEquals(5069061551149729, x *= (tmp = 2417116904.8069615, tmp)); + assertEquals(1.4836296666029616e+25, x += ((tmp = 2926833006.7121572, tmp)*x)); + assertEquals(-256, x >>= ((-469330345.3589895)%((x^(((2554170843.4978285)/(2495676674.815263))>>>x))*(-918892963)))); + assertEquals(-134217728, x <<= (x|(((((1687450853.1321645)+(tmp = 2369533014.5803776, tmp))+(tmp = -2613779445, tmp))+(tmp = -2488826226.3733397, tmp))>>(tmp = -220646936.41245174, tmp)))); + assertEquals(704164545131708400, x *= ((-2632786741)+(-2613647956))); + assertEquals(9216, x >>>= (-1925405359.657349)); + assertEquals(4491403261551.008, x *= (tmp = 487348444.1787118, tmp)); + assertEquals(4490606381829.008, x -= (tmp = 796879722, tmp)); + assertEquals(-60294056, x >>= x); + assertEquals(-3193966580.494005, x += (tmp = -3133672524.494005, tmp)); + assertEquals(550500358, x >>>= ((tmp = -2779637628.390116, tmp)-((tmp = 29230786.984039664, tmp)%(tmp = -310649504.7704866, tmp)))); + assertEquals(68812544, x >>= (-1347584797)); + assertEquals(1.2120221595741834e-11, x /= ((2791020260)*((((1964870148.6358237)^x)|(-3082869417))-((x^x)&((1234292117.8790703)<<(-1792461937.2469518)))))); + assertEquals(1.2120221595741834e-11, x %= (x-(2780439348))); + assertEquals(-1421552183, x |= (tmp = -1421552183.5930738, tmp)); + assertEquals(-1420954119, x |= ((((-2547788562.5735893)<<x)%(435385623))>>(x|x))); + assertEquals(1, x /= x); + assertEquals(1, x >>= (x>>>(((2975715011.501709)-(tmp = -1473273552.981069, tmp))/(1654883913.042487)))); + assertEquals(-65382, x ^= ((x/((tmp = -2780026200, tmp)<<x))^(((-2683084424)<<x)>>(-1716245874)))); + assertEquals(1530921106, x &= (1530940914)); + assertEquals(1, x /= x); + assertEquals(0, x >>= x); + assertEquals(0, x /= (tmp = 773741434.1972584, tmp)); + assertEquals(0, x |= x); + assertEquals(0, x <<= (-67977514.99888301)); + assertEquals(0, x %= (2496550482.524729)); + assertEquals(-0, x /= (tmp = -515040417, tmp)); + assertEquals(0, x <<= (-1673460935.2858837)); + assertEquals(-2638209488, x += (-2638209488)); + assertEquals(-2400951839498683400, x *= (910068685)); + assertEquals(1600582036, x ^= (((-1247602308.4812562)>>(((-2393714444.179732)>>>x)%(-778140635.7165127)))+(-1933914727.2268424))); + assertEquals(0, x *= ((x-x)>>(-1270234575))); + assertEquals(0, x >>>= (tmp = 3193676327.493656, tmp)); + assertEquals(0, x ^= (x>>>(1148676785.389884))); + assertEquals(0, x >>= (tmp = -2269181763.8663893, tmp)); + assertEquals(0, x >>= (3149450221)); + assertEquals(0, x >>= (1069630750)); + assertEquals(-625009654, x ^= ((-2143499112)%(-759244728.6214335))); + assertEquals(3583943, x >>>= (-2942645558.1204453)); + assertEquals(1791971, x >>= (x/x)); + assertEquals(223996, x >>= x); + assertEquals(6999, x >>= (tmp = -1051883611.9443719, tmp)); + assertEquals(1459617792, x <<= (-1572314984)); + assertEquals(2622356453.269262, x -= (tmp = -1162738661.2692618, tmp)); + assertEquals(5103676461.269262, x += (2481320008)); + assertEquals(823989684.2692623, x %= (x^(((((1048362966)*((tmp = -2423040747.6233954, tmp)>>>x))*((tmp = 2330818588.4081, tmp)>>(tmp = 103312020.98346841, tmp)))+(tmp = 2264492857.144133, tmp))>>>((tmp = 2523442834, tmp)<<x)))); + assertEquals(0, x >>>= (tmp = -2018700898.531027, tmp)); + assertEquals(NaN, x /= x); + assertEquals(0, x <<= (tmp = -2489442223, tmp)); + assertEquals(0, x >>= ((3045836220)>>>x)); + assertEquals(-1156905149, x ^= (3138062147)); + assertEquals(-0, x %= x); + assertEquals(-3118433907.512866, x -= ((tmp = 1338611238, tmp)-(-1779822669.5128663))); + assertEquals(100679693, x &= (1040565279)); + assertEquals(10136400582574248, x *= x); + assertEquals(0, x %= x); + assertEquals(2400318405, x += (2400318405)); + assertEquals(1.0036190808578471, x /= (((tmp = -2313492253.9889445, tmp)|(x-((tmp = -205459123, tmp)>>x)))+x)); + assertEquals(0, x >>>= (tmp = 882343227.1675215, tmp)); + assertEquals(0, x &= ((tmp = 2307828832.2706165, tmp)^((((((1404388047)<<((807879382)-(-2862921873)))-x)*(tmp = -1897734732, tmp))>>(tmp = 1981888881.2306776, tmp))%x))); + assertEquals(0, x <<= x); + assertEquals(0, x *= (((x*x)*((((2764801384.171454)%(x>>>x))&(384818815))+(x>>(tmp = -1481683516, tmp))))&x)); + assertEquals(0, x >>= (tmp = -2202536436, tmp)); + assertEquals(0, x ^= x); + assertEquals(0, x &= (tmp = 15161124, tmp)); + assertEquals(-1586110900, x ^= (-1586110900)); + assertEquals(-1586127952, x -= ((tmp = 560737212, tmp)%((1349529668)>>>(tmp = -1956656528, tmp)))); + assertEquals(-1174945870, x -= ((1178456190)|x)); + assertEquals(1335167624.3422346, x -= (tmp = -2510113494.3422346, tmp)); + assertEquals(1329952126.3422346, x -= (x>>x)); + assertEquals(1, x >>= x); + assertEquals(3, x |= (x<<x)); + assertEquals(3, x -= (x-x)); + assertEquals(-1938525669, x |= (tmp = 2356441625.5128202, tmp)); + assertEquals(-1938525669, x ^= ((tmp = -197149141.3622346, tmp)/(2833823156))); + assertEquals(-2.6292393147661324, x /= (737295254.2254335)); + assertEquals(2925975987.370761, x -= (-2925975990)); + assertEquals(2925975987.370761, x %= (tmp = 3041184582.8197603, tmp)); + assertEquals(-1908068660, x ^= ((tmp = -1380575181, tmp)-(2375164084.8366547))); + assertEquals(-477017165, x >>= (tmp = 2420877826.353099, tmp)); + assertEquals(-477017165, x %= ((tmp = -2919204062.3683634, tmp)-(tmp = -2263328990, tmp))); + assertEquals(-2105539936, x &= ((tmp = -1630795440, tmp)-(x&((933423833)>>(-475069901))))); + assertEquals(-4979480720, x -= (tmp = 2873940784, tmp)); + assertEquals(-4190953472, x -= (x&(tmp = -645918862.9001305, tmp))); + assertEquals(17564091004468855000, x *= x); + assertEquals(-857277134, x |= (tmp = 2363948338, tmp)); + assertEquals(1015632515, x -= (-1872909649)); + assertEquals(-1150380043, x ^= (tmp = -2014853770, tmp)); + assertEquals(1607729152, x <<= ((2194449589)+(x|(tmp = -1470075256.4605722, tmp)))); + assertEquals(1608356496, x |= ((((x|(670426524))<<((-2415862218)>>(tmp = 1572561529.9213061, tmp)))^((-1989566800.3681061)|x))&(2170270618.3401785))); + assertEquals(-1836056576, x <<= (tmp = 2906301296.540217, tmp)); + assertEquals(-2952415961567723500, x *= (tmp = 1608020145, tmp)); + assertEquals(1435500544, x <<= x); + assertEquals(700928, x >>>= (tmp = 2924829771.1804566, tmp)); + assertEquals(0, x <<= ((x^(2410009094))|(((-164334714.18698573)%(x*x))|(tmp = 2182431441.2575436, tmp)))); + assertEquals(-143321285, x ^= (tmp = -143321285, tmp)); + assertEquals(-2, x >>= x); + assertEquals(-1, x >>= (x&(1109737404))); + assertEquals(1, x >>>= x); + assertEquals(0, x ^= x); + assertEquals(-2463707358.165766, x += (-2463707358.165766)); + assertEquals(1831259938, x >>= (((((x-(tmp = 1359448920.5452857, tmp))%(tmp = -104541523, tmp))/((3133289055.9780197)*x))>>x)%x)); + assertEquals(1858895646, x ^= ((tmp = 131424376, tmp)>>(tmp = -396761023, tmp))); + assertEquals(1, x >>= x); + assertEquals(-1888369021, x |= ((tmp = -2038869285.046599, tmp)^((tmp = -1318286592.4250565, tmp)-(tmp = 2825123496, tmp)))); + assertEquals(1036458508, x <<= ((tmp = 2722401450, tmp)/((tmp = 1090712291, tmp)>>((tmp = -2155694696.9755683, tmp)*(tmp = 1661107340, tmp))))); + assertEquals(1, x /= (x%((tmp = -1716050484, tmp)+(tmp = -1683833551.797319, tmp)))); + assertEquals(0, x >>= (tmp = -2899315628, tmp)); + assertEquals(0, x |= x); + assertEquals(0, x >>>= x); + assertEquals(0, x <<= x); + assertEquals(1546062911, x |= (1546062911)); + assertEquals(1546195271, x += ((tmp = -3210667091, tmp)>>(tmp = 1323121165, tmp))); + assertEquals(3092390542, x += x); + assertEquals(-1199626354, x |= (406783756)); + assertEquals(-3650317194584908300, x *= (tmp = 3042878461.625484, tmp)); + assertEquals(-7.650495675092354e+27, x *= (2095844078)); + assertEquals(0, x >>= (tmp = 342617880.3384919, tmp)); + assertEquals(22, x ^= (((tmp = 381409558.9104688, tmp)>>((2823172888.974557)>>x))>>x)); + assertEquals(736383550, x += (736383528)); + assertEquals(0, x %= x); + assertEquals(0, x += x); + assertEquals(-1553157831, x -= (1553157831)); + assertEquals(1838556960, x <<= (3158944357.262641)); + assertEquals(5503285699.188747, x *= ((tmp = 2437440276, tmp)/(814308583.8128904))); + assertEquals(5824889900.188747, x -= (((tmp = 1171445694, tmp)-(tmp = -1584666956, tmp))^(tmp = 1217545373, tmp))); + assertEquals(747032, x >>>= (-89332085)); + assertEquals(747032, x |= (x^(x^(x>>>x)))); + assertEquals(747032, x >>>= ((-1558482440)*((tmp = -2413907480, tmp)+(3003996862.384156)))); + assertEquals(7.747761349084291e+23, x += ((tmp = 518064022.64624584, tmp)*((tmp = 2001951702, tmp)*x))); + assertEquals(0, x <<= (2769324707.5640426)); + assertEquals(NaN, x %= (((((((-2458056470.7717686)&x)>>(tmp = -361831232.42602444, tmp))*(2611108609.6727047))>>>x)/(-1713747021.8431413))*(-1143281532))); + assertEquals(NaN, x %= ((x^((-613836813)*(tmp = -3180432597.0601435, tmp)))%x)); + assertEquals(NaN, x /= ((-1607092857)^x)); + assertEquals(0, x &= (-1190719534)); + assertEquals(0, x >>>= x); + assertEquals(0, x += (x>>(642177579.1580218))); + assertEquals(-3129552333, x += (-3129552333)); + assertEquals(1165414963, x &= x); + assertEquals(2222, x >>= (((tmp = 2606317568, tmp)|x)+(tmp = 1844107136, tmp))); + assertEquals(NaN, x %= ((x^x)<<(x/(((tmp = -1362148700, tmp)&((tmp = 76371048, tmp)<<x))>>>((x^(-2605741153))>>(((tmp = -2131608159.7634726, tmp)|(((2827792229.8004875)|(((-848439251)+(-2576768890.123433))|((tmp = -2617711776, tmp)-((-199980264)&((tmp = -46967951.76266599, tmp)/(-733253537))))))*(tmp = 1820087608, tmp)))>>>(tmp = -3118359396.4298744, tmp))))))); + assertEquals(NaN, x /= ((2144871731)*x)); + assertEquals(NaN, x *= x); + assertEquals(NaN, x %= (tmp = 234811462.08692443, tmp)); + assertEquals(0, x >>>= ((1121416685)|(x^(((tmp = -2905413334, tmp)<<(tmp = -3091554324.030834, tmp))<<x)))); + assertEquals(-55938048, x |= ((tmp = -55938048, tmp)+(x*(tmp = -1518809027.2695136, tmp)))); + assertEquals(-3.3234995678333864e-10, x /= (x*(tmp = -3008876576, tmp))); + assertEquals(0, x <<= (x/((((((-2168824234.2418427)>>(((tmp = 1976810951, tmp)%x)<<(x*(x>>(x%(3146266192))))))%(tmp = 1756971968.122397, tmp))>>>(-2859440157.8352804))/(-1001406.1919288635))>>>(-1358031926)))); + assertEquals(-0, x *= (tmp = -1756000533, tmp)); + assertEquals(-0, x %= (2522761446.869926)); + assertEquals(0, x >>>= (((1087690535)>>>(2741387979))^x)); + assertEquals(0, x -= x); + assertEquals(0, x >>= (-819422694.2188396)); + assertEquals(0, x ^= x); + assertEquals(NaN, x /= x); + assertEquals(0, x &= (tmp = 86627723, tmp)); + assertEquals(0, x += x); + assertEquals(0, x %= (tmp = -2317915475, tmp)); + assertEquals(Infinity, x += (((-3072799584)^(-2487458319))/(((tmp = -3050692353, tmp)&x)>>(-777977292.8500206)))); + assertEquals(Infinity, x += x); + assertEquals(Infinity, x -= (tmp = 484428269, tmp)); + assertEquals(Infinity, x *= x); + assertEquals(Infinity, x /= (2059586218.2278104)); + assertEquals(Infinity, x *= (tmp = 415918523.8350445, tmp)); + assertEquals(-1800869091, x |= (((-1800869091)>>>(x>>>(tmp = -2832575051, tmp)))>>>x)); + assertEquals(6196126991451132000, x *= ((-1467292383.8458765)+(-1973339154.7911158))); + assertEquals(6196126992684649000, x += (1233517421)); + assertEquals(1, x /= x); + assertEquals(-7153809722216516000, x -= (((-2984550787.146106)<<(tmp = 743743974, tmp))*((3155151275)/((-1771412568.8965073)%x)))); + assertEquals(-7153809721471491000, x -= (-745024056)); + assertEquals(5.117699353102001e+37, x *= x); + assertEquals(0, x >>= x); + assertEquals(-0, x *= ((-2651785447.666973)<<(-1124902998))); + assertEquals(-0, x /= (2119202944)); + assertEquals(1042673805.5205957, x -= ((x<<x)-(tmp = 1042673805.5205957, tmp))); + assertEquals(62, x >>>= (tmp = 2769597912.977452, tmp)); + assertEquals(34, x &= ((tmp = -61541150, tmp)%(x^(-943160469)))); + assertEquals(34, x ^= ((-2625482224.4605474)<<(-2277806338.3461556))); + assertEquals(536870912, x <<= ((-2373927426.4757633)^x)); + assertEquals(536870912, x &= x); + assertEquals(512, x >>>= ((-1626769708.310139)<<((tmp = 641796314, tmp)/(721629637.3215691)))); + assertEquals(0, x <<= (-113973033)); + assertEquals(NaN, x /= x); + assertEquals(NaN, x += (-1602711788.2390788)); + assertEquals(NaN, x *= (x%x)); + assertEquals(0, x &= (x<<(x|(x>>((x>>>(x%((1182960050)^(((-220896609)-((((tmp = 1518275435.360103, tmp)/(tmp = -88234820, tmp))^x)/x))>>(3169930777.548236)))))-(tmp = -2912668817.662395, tmp)))))); + assertEquals(0, x *= ((2323969408.7524366)/(((tmp = -3089229853, tmp)>>>((((tmp = -1012580544.5631487, tmp)>>(1138049418.9023373))>>x)&x))*(tmp = 626912001, tmp)))); + assertEquals(0, x >>>= x); + assertEquals(NaN, x /= (x%(-868024322))); + assertEquals(NaN, x /= (tmp = -1749532322, tmp)); + assertEquals(1861918711, x |= (-2433048585.853014)); + assertEquals(1861918711, x >>= (((102451747)>>>((((241651917.47259736)/((((((((1759022236)^(tmp = -2592022722, tmp))+((-1748044969)>>>(704597925)))/(-1639604842))%((1349846853.7345295)<<(-729695861)))/(x>>((tmp = -2654474404.7365866, tmp)>>x)))>>>(((-480356478)|(x%((tmp = -1668269244.6979945, tmp)+(tmp = -2441424458.565183, tmp))))^((1634981212.7598324)>>>(tmp = 122455570.22000062, tmp))))<<x))*((tmp = -1058636137.5037816, tmp)+((2794083757.138838)&((x/(50081370))&x))))/x))/((tmp = -243106636, tmp)<<((x*((tmp = -648475219.5971704, tmp)>>((tmp = -1568913034, tmp)-((tmp = 911458615, tmp)|x))))>>>(tmp = 2714767933.920696, tmp))))); + assertEquals(0, x ^= x); + assertEquals(-2080484602, x |= (((1544771831.4758213)|x)^(-538113039))); + assertEquals(696451072, x <<= (tmp = -1587032689, tmp)); + assertEquals(-162595645, x += (tmp = -859046717, tmp)); + assertEquals(516546456, x >>>= x); + assertEquals(623083588, x += ((-1371850352)^(tmp = -1469933252, tmp))); + assertEquals(92342412, x %= (tmp = -132685294, tmp)); + assertEquals(500272110, x |= ((tmp = 1616032506, tmp)%((tmp = 1589569590.4269853, tmp)|(-972791738.1829333)))); + assertEquals(3247086, x %= (((tmp = 1372216208, tmp)|(-638950076.3387425))&((-2619249161.849716)&(73957896)))); + assertEquals(0, x >>>= (tmp = -1482343462.6911879, tmp)); + assertEquals(1265125662, x ^= (tmp = -3029841634, tmp)); + assertEquals(4941897, x >>>= (-2039728632)); + assertEquals(206857, x &= (tmp = 226962365.45571184, tmp)); + assertEquals(1.0925018562586405e+24, x += ((tmp = 2687424146, tmp)*(((-1998020319)%x)*(-2080331363)))); + assertEquals(-1.755270751212437e+32, x *= (-160665242)); + assertEquals(0, x <<= (3152796521.6427975)); + assertEquals(0, x ^= ((((((tmp = -855001595, tmp)<<(2007525777))-(x-(x-x)))/(3036585090.9701214))&(1827983388))*((tmp = -915604789.0515733, tmp)&(((((tmp = -806628722.7820358, tmp)%x)/(tmp = -2773117447, tmp))|x)<<(((tmp = -2902300974.7300634, tmp)|x)/(-1608133440)))))); + assertEquals(0, x |= ((((((119024954)*(((x^(tmp = 2939514414, tmp))|x)^(x-(tmp = -1597415597.6795669, tmp))))+(((tmp = -182277816.14547157, tmp)<<(((-2983451324.3908825)^(tmp = 1572568307, tmp))+(-1165604960.8619013)))/(x>>((tmp = -2127699399, tmp)>>((x^(((((tmp = -1968667383, tmp)^(tmp = 3120052415.9964113, tmp))|(((x|(((x^((tmp = 2831505153, tmp)<<((-3150506831.547093)+((x%(tmp = 383761651, tmp))%(2856803457)))))+(((tmp = -2426953997, tmp)^(tmp = -2667954801.1010714, tmp))*(tmp = -2707801631, tmp)))&(tmp = 2082935238.794707, tmp)))^((tmp = 697573323.5349133, tmp)-x))%(tmp = 661936357, tmp)))/(-1717944600.261446))>>>((2423776015.0968056)^((-1410322010)|((x<<(tmp = 2935993226, tmp))/(tmp = -1533896392, tmp))))))*(tmp = -596675330, tmp))))))>>>(((2944268153)^(x&(144579050.93126357)))/(-2123810677.2619643)))>>>(1473040195.9009588))*x)); + assertEquals(0, x /= (2877666495)); + assertEquals(2174852514, x -= (tmp = -2174852514, tmp)); + assertEquals(543713128, x >>>= x); + assertEquals(2978128878.939105, x += (tmp = 2434415750.939105, tmp)); + assertEquals(3529591145844655600, x *= (tmp = 1185170719.3753138, tmp)); + assertEquals(659, x >>>= ((((((x<<(((((-425423078)/(((tmp = 160617689.20550323, tmp)&(-1524740325.5003028))%(tmp = -1869426475, tmp)))<<(((x^(-487449247))>>>(tmp = -1962893666.7754712, tmp))%x))*x)>>((tmp = 623413085, tmp)&(x+(((((-2200726309.083274)-(x-x))+x)&(-1304849509))|((((tmp = -431896184, tmp)>>>(x>>(-1932126133)))<<((1078543321.2196498)*(-10761352)))>>(tmp = -2681391737.5003796, tmp)))))))/x)-(tmp = -1768629117, tmp))/(((((tmp = -2320718566.0664535, tmp)%x)+(-2831503351.995921))>>>(-2695416841.3578796))*(943979723)))<<x)|((652520546.7651662)>>(1045534827.6806792)))); + assertEquals(531, x &= (tmp = -293707149, tmp)); + assertEquals(0, x >>= (tmp = -678056747.5701449, tmp)); + assertEquals(1184651529.8021393, x += (tmp = 1184651529.8021393, tmp)); + assertEquals(1721719611, x |= (tmp = 1645413178, tmp)); + assertEquals(-406880257, x |= (tmp = 2268544460, tmp)); + assertEquals(-4194304, x <<= (tmp = -109701322.43455839, tmp)); + assertEquals(17592186044416, x *= x); + assertEquals(0, x ^= (x&x)); + assertEquals(0, x <<= (tmp = 1715401127, tmp)); + assertEquals(-1793087394, x |= (tmp = -1793087394.730585, tmp)); + assertEquals(-2, x >>= x); + assertEquals(263607360.10747814, x += (tmp = 263607362.10747814, tmp)); + assertEquals(1073214955, x |= (893759979.3631718)); + assertEquals(703953930, x -= ((2738450011)%(x^(tmp = 679402836, tmp)))); + assertEquals(1, x >>= (tmp = 2262515165.6670284, tmp)); + assertEquals(0, x >>= (((tmp = 747896494, tmp)^((tmp = -1005070319, tmp)+x))|x)); + assertEquals(0, x >>= ((953612771)>>>(tmp = 3066170923.3875694, tmp))); + assertEquals(-314941454, x -= (x+(((314941454)%(((tmp = 2200222912.9440064, tmp)>>>(2534128736.805429))>>>(x|((747716234)%(((tmp = -252254528, tmp)%(-1553513480.1875453))&x)))))<<x))); + assertEquals(-535686958, x &= (-522809126)); + assertEquals(0.5480312086215239, x /= (tmp = -977475278, tmp)); + assertEquals(-1199953459.6090598, x *= ((-2189571393)+((3186862741.37774)>>(tmp = -2193090564.5026345, tmp)))); + assertEquals(-1199953459.6090598, x %= ((tmp = 2986532440, tmp)*(2685122845))); + assertEquals(-1199953459.6090598, x %= (1951182743.7399902)); + assertEquals(51262285383887820, x *= (-42720228)); + assertEquals(-424776752, x |= x); + assertEquals(166221344210236600, x *= (tmp = -391314598.6158786, tmp)); + assertEquals(-1883425600, x >>= (((tmp = -1020679296, tmp)^((-1416867718)+(-1412351617)))<<(-2743753169))); + assertEquals(0, x &= (x/(-2250026610))); + assertEquals(-1111956501, x ^= (tmp = 3183010795, tmp)); + assertEquals(2012059503, x ^= (tmp = -900369276, tmp)); + assertEquals(15719214, x >>>= (tmp = -3196277049, tmp)); + assertEquals(15719214, x |= x); + assertEquals(100779035, x -= ((-1245802025)^(-2964289852))); + assertEquals(0, x >>= x); + assertEquals(0, x &= (((x<<((2361941389.708063)%x))>>((328256762.09842086)>>>((((tmp = 3094192285, tmp)-(((x>>(tmp = -2920437464, tmp))<<(tmp = -2693021467, tmp))-(x>>>((2410065554)%(x%(tmp = 2487056196.689908, tmp))))))-(tmp = -866314146, tmp))^((1754098471)-((((((-2450740191)-(tmp = 1977885539.6785035, tmp))*((tmp = -1205431332, tmp)>>>x))>>(-870601854))>>(tmp = -301859264, tmp))|((tmp = -2308971516.8301244, tmp)/x))))))&((2307007357)-((tmp = -1518812934, tmp)+(2562270162))))); + assertEquals(0, x <<= x); + assertEquals(-1802124619, x |= (-1802124619)); + assertEquals(-1802124619, x %= ((1617132364.306333)+((1678465962.079633)|((516698570)%(((569813606)*(-1800804098.6270027))%((tmp = 1976706935, tmp)-((tmp = -1830228989.5488424, tmp)>>(((x^((tmp = 1015246068.3791624, tmp)>>x))^((-2171682812.246772)-(tmp = -398330350, tmp)))&x)))))))); + assertEquals(904564673.6237984, x -= (tmp = -2706689292.6237984, tmp)); + assertEquals(818237248768128900, x *= x); + assertEquals(254842325.2585001, x %= (1550087667.9657679)); + assertEquals(-1163919360, x <<= x); + assertEquals(-3.4644526843674166, x /= ((-446801454)+(x>>>(tmp = -2025151870, tmp)))); + assertEquals(0, x &= ((((((((-1739617728)&(x&(((tmp = -2946470036.552597, tmp)/x)*x)))^(-1130501404))>>>x)/((1870230831)>>>(840301398)))%x)/x)/(-2927537567))); + assertEquals(0, x >>= x); + assertEquals(0, x >>>= (x&(x&x))); + assertEquals(0, x &= ((-579614044)-(-756012505.4048488))); + assertEquals(-2970367642, x -= (tmp = 2970367642, tmp)); + assertEquals(-415129376, x ^= (tmp = 2847041926.060355, tmp)); + assertEquals(-1505681312, x &= (tmp = -1225184902.9215767, tmp)); + assertEquals(-3174471329.5807734, x += (-1668790017.5807734)); + assertEquals(-Infinity, x /= (x>>x)); + assertEquals(NaN, x -= x); + assertEquals(0, x ^= (x^(((-1407936301.5682082)<<((x^(((tmp = 3213446217.307076, tmp)|x)|((tmp = 3219810777.3171635, tmp)/(tmp = 1561807400, tmp))))>>>((tmp = 2449910203.0949173, tmp)|((((1954662538.7453175)>>(tmp = -1711636239.9916713, tmp))>>>(tmp = 406219731.214718, tmp))<<(((-907908634.4609842)^((((((tmp = 2408712345, tmp)*(tmp = 1740346634.5154347, tmp))>>(tmp = 715783991, tmp))^(tmp = -655628853.2821262, tmp))%(tmp = 2819143280.434571, tmp))/(-1240412852)))*x)))))/x))); + assertEquals(0, x >>>= x); + assertEquals(0, x <<= x); + assertEquals(0, x >>>= (((-3198075268.8543105)>>(((((x+((tmp = -133461401.50823164, tmp)-((x&(((((tmp = 2617977319, tmp)>>((tmp = -2704719576.8734636, tmp)|((tmp = -977362542.2423751, tmp)<<(x<<(tmp = 3054487697.1441813, tmp)))))>>>((-1635655471)%x))/(-2079513672))%(tmp = 1993563806, tmp)))<<(tmp = -1310524200.6106496, tmp))))%((((-2558804500.7722936)+(tmp = -1641265491, tmp))<<((tmp = -1309608349, tmp)>>>x))/((tmp = -2306644272, tmp)<<x)))*(-2009396162.3063657))+(267343314.3720045))-(-2212612983.661479)))|x)); + assertEquals(NaN, x %= x); + assertEquals(NaN, x *= x); + assertEquals(-824822309, x |= (-824822309)); + assertEquals(-807944741, x |= (((-598067403)*((x&(tmp = 2897778389, tmp))>>>(-1322468310.3699632)))|x)); + assertEquals(90004223.44097246, x /= (((tmp = -481122620, tmp)&x)%((tmp = 1109368524, tmp)/(((-3150568522.633032)<<(tmp = 2923396776, tmp))^(x-((x/x)&(x/(-287976185.1049104)))))))); + assertEquals(0.4521931751193329, x /= (tmp = 199039323, tmp)); + assertEquals(1.8110466604491368e-10, x /= (2496860986.492693)); + assertEquals(0, x |= x); + assertEquals(-1225944576, x += ((tmp = -807700791.631221, tmp)<<((-700782615.4781106)-((((-2954619897)>>>x)<<((tmp = 997657844, tmp)>>>(1227994596)))/((-1234591654.8495834)*((tmp = -191189053.70693636, tmp)+(tmp = -3027659304, tmp))))))); + assertEquals(-1225811383, x |= (-1866233271)); + assertEquals(3069155913, x >>>= (((x/(-99524153.40911508))%(x>>>((((tmp = 2985975640, tmp)/(tmp = 2781516546.2494454, tmp))&(((2234114508)|(((x/(tmp = -1224195047, tmp))<<x)^(x>>>((537884375.5698513)+x))))^((tmp = -2144817497.5089426, tmp)|(-498079183.8178189))))>>>((x+x)&(-3086080103.6460695)))))<<(((tmp = 2151157136, tmp)*x)/(((x/x)>>>(-1149734628.4364533))-((3025445835.654089)+(tmp = 530902725.91127443, tmp)))))); + assertEquals(-1733702568, x ^= (tmp = 776361489.423534, tmp)); + assertEquals(8981504, x &= ((tmp = 2902581847, tmp)*(x-(-2697760560)))); + assertEquals(1153166.8526612986, x -= ((x/(tmp = -1375025594.5027463, tmp))+((3043576689.1538706)%(x+x)))); + assertEquals(3389855, x |= (x+x)); + assertEquals(-488458393.17759943, x += (-491848248.17759943)); + assertEquals(40982867145206920, x *= ((3132857155)|(tmp = -218356553, tmp))); + assertEquals(688, x >>= (((((tmp = 403321821, tmp)+((tmp = 2536984658, tmp)%((tmp = 2759309029.8753624, tmp)|(((tmp = 1994203554.7417293, tmp)^((704660500.434877)*(tmp = 1536292958.2691746, tmp)))+(-164139788)))))/((1205950994.1255205)+x))^((((tmp = 975272146.0133443, tmp)-(150107797))/(-1764309514))^((x>>>(x^(x^x)))+(203250124))))>>>(tmp = 1864959239.512323, tmp))); + assertEquals(10, x >>= ((tmp = 1631996431.9620514, tmp)>>x)); + assertEquals(10, x %= (tmp = 2678904916, tmp)); + assertEquals(335544320, x <<= (tmp = -2759037415.6811256, tmp)); + assertEquals(-153389967, x |= ((tmp = -2411636565, tmp)+(tmp = -2305156154, tmp))); + assertEquals(-1171, x >>= x); + assertEquals(813080576, x &= (((tmp = -65428547, tmp)&(tmp = 3163266999, tmp))<<x)); + assertEquals(4346532303, x += ((tmp = -761515569.0707853, tmp)>>>(((tmp = 143240971.0661509, tmp)<<x)*(x^((tmp = -271697192.8471005, tmp)&x))))); + assertEquals(-863299035, x ^= ((((2663001827.1492147)>>>((x/(((tmp = 482665912, tmp)-(x>>(tmp = 354425840.784659, tmp)))>>((-2012932893)>>>x)))/((tmp = -1354385830.6042836, tmp)>>>(-2149023857))))^((tmp = 585746520, tmp)+(tmp = 756104608, tmp)))^(517529841.184085))); + assertEquals(-997654012, x &= (((tmp = -404836025.15326166, tmp)+((tmp = 3035650114.0402126, tmp)<<((-1308209196)>>(tmp = 693748480, tmp))))<<(((465774671.4458921)<<x)/(1971108057)))); + assertEquals(-320581507110848260, x *= ((x-(tmp = -2266777911.7123194, tmp))^(tmp = -2810021113.304348, tmp))); + assertEquals(-320581508271196300, x += ((-1195215841.5355926)|(x-((2715907107.4276557)+(((-843426980)>>(x&(x%(tmp = -1139279208.34768, tmp))))^x))))); + assertEquals(368031616, x &= x); + assertEquals(368031616, x %= (tmp = 1211767328, tmp)); + assertEquals(-67505614939510744, x *= (tmp = -183423412.56766033, tmp)); + assertEquals(959424552, x >>= ((tmp = -171120122.5083747, tmp)/x)); + assertEquals(30949179.096774194, x /= (((x-((((x&(tmp = -180770090, tmp))<<(((tmp = -2061363045.419958, tmp)*((655711531)^((1205768703)-(tmp = 2468523718.8679857, tmp))))+(-2746704581)))+((-853685888)*(tmp = -2299124234, tmp)))|(tmp = 2429502966, tmp)))|(((-985794986.0232368)>>>(2890862426))%x))>>(tmp = 1005542138.8415397, tmp))); + assertEquals(30949179, x |= x); + assertEquals(30949179, x %= (810126097.6814196)); + assertEquals(120895, x >>= (tmp = 3065886056.1873975, tmp)); + assertEquals(1934320, x <<= (1478650660.7445493)); + assertEquals(0, x >>= (1069658046.2191329)); + assertEquals(NaN, x %= x); + assertEquals(NaN, x %= (x*x)); + assertEquals(NaN, x *= ((((2148513916)+(tmp = -210070225.85489202, tmp))>>(975470028))+((-3060642402)>>x))); + assertEquals(NaN, x *= (2888778384)); + assertEquals(NaN, x -= (294531300.16350067)); + assertEquals(-465620423, x ^= (tmp = -465620423.5891335, tmp)); + assertEquals(1613303808, x &= (-2530649850.1952305)); + assertEquals(2045458658, x |= (tmp = 432158946.5708574, tmp)); + assertEquals(0, x >>>= (2277328255.770018)); + assertEquals(0, x &= (-64904722.41319156)); + assertEquals(0, x >>= x); + assertEquals(3109394857.361766, x += (3109394857.361766)); + assertEquals(1519021650, x ^= ((tmp = -2632472653, tmp)|(tmp = 2161964921.8225584, tmp))); + assertEquals(370854, x >>>= ((1486892931.4564312)-((tmp = 3017755741.9547133, tmp)>>>x))); + assertEquals(1333145110.39802, x -= ((-1051580495.39802)-(tmp = 281193761, tmp))); + assertEquals(0, x ^= x); + assertEquals(0, x |= x); + assertEquals(0, x <<= x); + assertEquals(0, x >>>= x); + assertEquals(799202788.1455135, x -= (tmp = -799202788.1455135, tmp)); + assertEquals(1539080192, x <<= (x%(((((x-x)|(((((x%(959993901))+(tmp = -2647575570.092733, tmp))/(tmp = -2040600976.5104427, tmp))*(x*(tmp = 2785252760, tmp)))>>(-377867259)))/((x&(1549738240.013423))>>>(tmp = -1502185618, tmp)))*x)%(1159283801.0002391)))); + assertEquals(0, x >>= (-268660225)); + assertEquals(-0, x /= (-2795206270.635887)); + assertEquals(0, x >>>= (1869556260.2489955)); + assertEquals(64202212, x ^= ((((tmp = -942983515.5386059, tmp)*(((1057759788)-x)*(tmp = 2038041858, tmp)))>>x)+(tmp = 64202212, tmp))); + assertEquals(2021126977, x -= ((tmp = -2009912898, tmp)^((2240062309)%x))); + assertEquals(4332348265459724000, x *= (tmp = 2143530968, tmp)); + assertEquals(1472, x >>>= ((283380755)<<x)); + assertEquals(-1672370407872, x *= (tmp = -1136121201, tmp)); + assertEquals(338573318, x ^= (tmp = 2329579078.4832354, tmp)); + assertEquals(2377388772.1662374, x -= (tmp = -2038815454.1662374, tmp)); + assertEquals(-1.264761712403516, x /= ((((tmp = -2106209534, tmp)>>((((((tmp = 626190172, tmp)/x)>>>(-824270996.8545206))/((1258369810.9498723)-(tmp = -2947556209, tmp)))^((((366784589.24711144)|(1462064104.828938))-(1571045395.777879))<<(444685689.60103726)))>>(tmp = -2757110357.410516, tmp)))/(x>>>((tmp = 829226010, tmp)>>>(629512715))))|x)); + assertEquals(-2905481691.264762, x -= (2905481690)); + assertEquals(-1710543566.1481905, x -= (-1194938125.1165714)); + assertEquals(-3421087132.296381, x += x); + assertEquals(-884178944, x <<= ((-1820881235)|x)); + assertEquals(-884178944, x &= (x%(tmp = -2298828530, tmp))); + assertEquals(1516503040, x <<= ((tmp = -3039882653, tmp)+((tmp = 1956034508, tmp)<<(x>>(tmp = 280388051, tmp))))); + assertEquals(3033006080, x += x); + assertEquals(846431222.321887, x %= (x+(-1939718651.1609435))); + assertEquals(-846431224, x ^= ((-1742116766.54132)/x)); + assertEquals(1157918728, x &= (tmp = 1966568030, tmp)); + assertEquals(1157918728, x >>>= ((((((tmp = -2392096728.184257, tmp)*(x&(-3051259597.301086)))>>>(((tmp = 1712991918.071982, tmp)*(tmp = -714525951, tmp))-((-1784801647)>>((-1270567991)%(((214272558)/(((-3110194570)|(tmp = 2558910020, tmp))&(-1266294955.717899)))*((2654922400.609189)>>>(tmp = 370485018, tmp)))))))*(((tmp = -2621203138.1838865, tmp)%(858913517))*((tmp = -1564229442.2596471, tmp)>>((tmp = 1898557618, tmp)|(-1282356275)))))*(tmp = -1253508468, tmp))+((-361964404.75944185)|x))); + assertEquals(961668975, x += (-196249753)); + assertEquals(1, x >>= (tmp = 890453053, tmp)); + assertEquals(1, x >>= (((((tmp = 871309275, tmp)/(x>>>((tmp = 2033022083, tmp)&(tmp = -1393761939, tmp))))%((437488665.104565)^(tmp = 2808776860.4572067, tmp)))-((tmp = -359283111.49483967, tmp)<<((tmp = 2985855945, tmp)%(tmp = -596479825.9114966, tmp))))/(-1965528507))); + assertEquals(0, x >>= ((tmp = -1753776989, tmp)%(tmp = 322622654, tmp))); + assertEquals(84411424, x ^= (((x|(x|(tmp = -1617122265, tmp)))&(tmp = -313813263, tmp))&(1472888112.0258927))); + assertEquals(67633184, x &= ((1556833131.0776267)<<(x<<(1501219716.5575724)))); + assertEquals(68002293, x |= (((tmp = 188984203.0350548, tmp)>>>(tmp = 1356052777, tmp))%(x*(tmp = -2944960865, tmp)))); + assertEquals(67108864, x &= (((1046644783.9042064)<<x)+((-2796345632)>>>(((-1913290350.3687286)<<(((((tmp = -2223692353, tmp)>>x)&(x<<(x>>((((tmp = -976850020, tmp)%(tmp = 1379692507, tmp))>>>(1120103052.2077985))>>(tmp = 5592070.612784743, tmp)))))<<(x+((tmp = -3154037212.9764376, tmp)%(((x-(-1961060483.6965141))+(((1920670676)-(2852444470.7530622))/(((1445954602)>>((1353665887)>>(tmp = 111411560.64111042, tmp)))<<x)))+x))))<<((-1773130852.6651905)^((1216129132)>>(1511187313.2680469)))))|((tmp = -1107142147, tmp)|(tmp = -768165441.4956136, tmp)))))); + assertEquals(0, x -= x); + assertEquals(0, x %= (tmp = -1655707538.0778136, tmp)); + assertEquals(-184120712930843900, x += (x+((tmp = -3174410166, tmp)+((tmp = -301807453, tmp)*(tmp = 610060182.1666535, tmp))))); + assertEquals(-54598560, x >>= (-1365351357)); + assertEquals(-6763.94449950446, x /= (((-1953016847)<<((673287269.7002038)%(-558739761)))>>>(tmp = 1607754129, tmp))); + assertEquals(-1, x >>= x); + assertEquals(1, x >>>= x); + assertEquals(0, x >>>= x); + assertEquals(0, x >>= ((-384747983)+((((tmp = -949058352.381772, tmp)>>>(-1920744986))-(-882729639))^((x^((tmp = 2351364046, tmp)<<(((tmp = -3110165747, tmp)^(-1266489735))-((tmp = -371614326, tmp)>>((tmp = -2064968414, tmp)&(-2075036504.617934))))))&(((-2616501739)&(tmp = 2591437335.4029164, tmp))>>x))))); + assertEquals(0, x >>>= ((tmp = 2946468282, tmp)&((-2741453019)>>x))); + assertEquals(0, x -= ((x%(-134700915))&(-1955768279))); + assertEquals(NaN, x /= x); + assertEquals(NaN, x /= (x^(((((((tmp = 3185669685.772061, tmp)>>(tmp = -1973500738, tmp))-(tmp = -87401348.93002152, tmp))>>(tmp = -2813508730, tmp))&(tmp = -778957225, tmp))<<(x-(x&((-2821756608)+(((((tmp = 2475456548, tmp)/(tmp = 997998362, tmp))<<((tmp = -83043634, tmp)|x))%(636120329))%(tmp = -1910213427.7556462, tmp))))))%x))); + assertEquals(0, x &= x); + assertEquals(0, x <<= x); + assertEquals(0, x >>>= (x%x)); + assertEquals(0, x %= (745221113)); + assertEquals(0, x >>>= ((1467615554.7672596)|x)); + assertEquals(0, x /= (tmp = 735317995, tmp)); + assertEquals(-1513001460, x |= (2781965836)); + assertEquals(-1513001460, x |= (x%(1970577124.3780568))); + assertEquals(-0, x %= x); + assertEquals(1864972269, x ^= (-2429995027.840316)); + assertEquals(1226843341, x &= (tmp = -639621923.5135081, tmp)); + assertEquals(1226843339.3171186, x += ((1297620268.272113)/(-771070549))); + assertEquals(76677708, x >>>= (1009134980)); + assertEquals(0, x ^= x); + assertEquals(0, x ^= x); + assertEquals(NaN, x /= x); + assertEquals(716040787, x |= ((1851586229)-(1135545441.3502865))); + assertEquals(1385693184, x <<= x); + assertEquals(1321, x >>= (x^((tmp = -1576632297.0860603, tmp)>>>(405218605)))); + assertEquals(-1319012931, x |= (-1319014243)); + assertEquals(-1319012931, x >>= ((((1689898279.3580785)<<((((x^(x>>>((((tmp = 2635260332, tmp)*(tmp = 2053357650, tmp))*x)*(2856480122.339903))))>>x)&(-2382703000.077593))%(1183918594)))*(tmp = -1670081449, tmp))<<x)); + assertEquals(-528327581.7646315, x %= (tmp = -790685349.2353685, tmp)); + assertEquals(2073431790, x ^= (tmp = 2601800333, tmp)); + assertEquals(-6514722684180, x -= (((tmp = 824141806.0668694, tmp)>>>(((-1865885282.8723454)&(x&(x|((900188006.3757659)>>>(x&x)))))+(2227126244.0526423)))*x)); + assertEquals(1450593, x >>>= ((2157053647)>>(x+(-2934071355.418474)))); + assertEquals(576782336, x <<= ((1054640368.827202)&((tmp = -3182236876.434615, tmp)>>(tmp = 2129856634.0328193, tmp)))); + assertEquals(2950754326, x -= (tmp = -2373971990, tmp)); + assertEquals(738197504, x <<= (1188157369.5988827)); + assertEquals(0, x <<= (x+((tmp = -839533141, tmp)&((((((tmp = -1148768474.7306862, tmp)|(172650299))+(tmp = -2739838654, tmp))/(3132557129))%x)>>>(tmp = -1229961746.2466633, tmp))))); + assertEquals(0, x %= (tmp = -2974207636, tmp)); + assertEquals(0, x %= ((2323482163)>>>x)); + assertEquals(0, x &= (((x/(x+(x>>((tmp = 55935149, tmp)%x))))|((3109182235)>>>(tmp = 1217127738.8831062, tmp)))+((((tmp = -385114910, tmp)*((((((tmp = -2535158574.634239, tmp)&(x+x))<<(-2821692922.43476))&(-776804130.9457026))>>((-1374832535)^(tmp = 2175402162.701251, tmp)))%(-1646995095)))-(x*(tmp = -921556123, tmp)))^(79224621)))); + assertEquals(128935435, x |= ((tmp = 2279459038, tmp)%(tmp = -537630900.5271742, tmp))); + assertEquals(128935435, x /= ((((((x<<(2750024311))-((-1332480769.4784315)&(1418160003)))&(1551783357))<<(((((-2870460218.55027)|((-1958752193.7746758)&(2551525625)))>>>((((tmp = -1698256471, tmp)^(((((((((tmp = -830799466, tmp)+x)-(-111590590))+(tmp = -1105568112.3921182, tmp))/((tmp = -3058577907, tmp)|(((-1944923240.2965696)%(-2884545285))<<(tmp = -1993196044.1645615, tmp))))^(x>>(tmp = -2961488181.3795304, tmp)))&x)*x)|(((tmp = 97259132.88922262, tmp)<<((1601451019.343733)&x))*(x|x))))+((((x>>x)<<x)+(-868409202.2512136))/(((tmp = -2893170791, tmp)-((x|(-853641616))%(((tmp = 549313922, tmp)&(-768036601.6759064))%(tmp = -543862220.9338839, tmp))))-((tmp = 1639851636, tmp)+((2164412959)/(-273028039.941242))))))>>>((((-2382311775.753495)^(-2062191030.2406163))>>>(tmp = -1054563031, tmp))/(-862111938.7009578))))%x)+(-3103170117.625942)))%((tmp = -1144062234, tmp)>>x))>>>(tmp = 1216332814.00042, tmp))); + assertEquals(41.631074722901715, x /= (x&(-2542806180.962227))); + assertEquals(41.631074722901715, x %= (-14003386.556780577)); + assertEquals(8, x &= (x&((-2231622948)%(tmp = 488279963.9445952, tmp)))); + assertEquals(9.002961614252625e-9, x /= ((53802728.56204891)<<(((867697152.3709695)-(538719895.5707034))&(-631307825.4491808)))); + assertEquals(0, x >>= x); + assertEquals(-0, x *= (tmp = -785674989, tmp)); + assertEquals(-0, x += x); + assertEquals(0, x /= (-250703244)); + assertEquals(0, x <<= ((tmp = -661062581.5511999, tmp)|x)); + assertEquals(0, x &= (-1299482308)); + assertEquals(0, x &= ((-399690060)>>>(2448074202.385213))); + assertEquals(0, x &= (2574341201)); + assertEquals(0, x <<= ((x|(((tmp = 2458873162.645012, tmp)+(tmp = -1999705422.8188977, tmp))<<((x^(tmp = -392530472, tmp))>>>x)))&(((tmp = 2463000826.7781224, tmp)|(tmp = 3020656037, tmp))-x))); + assertEquals(1397603760, x += ((tmp = -1359413071, tmp)-(tmp = -2757016831, tmp))); + assertEquals(513823851, x -= (883779909)); + assertEquals(-1765712747, x ^= (2288060670.6797976)); + assertEquals(3117741504918286000, x *= x); + assertEquals(3117741506284045300, x += (1365759456)); + assertEquals(6035555595.597267, x /= (tmp = 516562470, tmp)); + assertEquals(104203275, x &= (tmp = 376835755.32434213, tmp)); + assertEquals(10858322520725624, x *= x); + assertEquals(59458951, x >>>= (153765028)); + assertEquals(49370856, x += ((tmp = -1291276092, tmp)>>x)); + assertEquals(0, x %= x); + assertEquals(0, x += x); + assertEquals(-1494589645, x -= (1494589645)); + assertEquals(-0, x %= x); + assertEquals(0, x <<= (x&((2730708043.467806)<<x))); + assertEquals(0, x /= ((tmp = -1483912394.153527, tmp)>>>((tmp = 1800568769, tmp)^((((((tmp = 1351568510, tmp)>>(tmp = -1337992543.2562337, tmp))>>>(tmp = 2602239360.40513, tmp))*x)%x)+(-2095840128.0700707))))); + assertEquals(-0, x /= ((2363946613)^(tmp = -2227868069, tmp))); + assertEquals(0, x &= ((((2634933507)<<(2798775374.140882))>>>x)>>>(((tmp = 1135200853.6396222, tmp)-(tmp = -1529829490.7007523, tmp))-(((((((((x^((x|(2135742668.591568))-(924230444.8390535)))%(tmp = -2459525610.51898, tmp))+(x&((tmp = 1177231743.809653, tmp)/(tmp = 1743270357.2735395, tmp))))|(((tmp = -1894305017, tmp)^((tmp = 1791704240, tmp)&x))%(-1569751461)))>>>(tmp = -2078321944, tmp))|x)*(((x*(tmp = -163239354, tmp))<<((tmp = 2859087562.694203, tmp)&(-657988325.9410558)))^(2508013840)))-((-243572350)+(x%((-1095206140)+((tmp = 3213566608.942816, tmp)*((2256442613)%((tmp = 1723751298, tmp)^(x-((-1145710681.2693722)|x)))))))))+(1556870627))))); + assertEquals(130883024.97423434, x -= (-130883024.97423434)); + assertEquals(0.046720352789736276, x /= (tmp = 2801413456, tmp)); + assertEquals(1806558189, x |= (tmp = 1806558189.157823, tmp)); + assertEquals(72.40475060062144, x /= (x%((1932591076.531628)>>(1982030182)))); + assertEquals(-1077558321.5975945, x += (tmp = -1077558394.002345, tmp)); + assertEquals(98187, x >>>= x); + assertEquals(97792, x &= (tmp = -1032487404, tmp)); + assertEquals(709197609, x |= (x^(709179177))); + assertEquals(11081212, x >>>= (tmp = 1412940006.169063, tmp)); + assertEquals(11081212, x &= x); + assertEquals(-1920311203, x -= ((tmp = 1931392415, tmp)<<((x%(tmp = -2873576383, tmp))%x))); + assertEquals(-1920311203, x |= (x&(-993884718.2172024))); + assertEquals(-4, x >>= (1409411613.0051966)); + assertEquals(-7947632484, x *= ((-2856731734)^((-1181032235.9132767)-((tmp = 780101930, tmp)+((tmp = -1732707132.6253016, tmp)^x))))); + assertEquals(-2016362769, x ^= (tmp = 2711125619.2455907, tmp)); + assertEquals(-61535, x >>= x); + assertEquals(-124771649, x ^= (tmp = 124726558, tmp)); + assertEquals(-1, x >>= x); + assertEquals(-0, x %= (x*x)); + assertEquals(0, x <<= x); + assertEquals(0, x /= (2444628112)); + assertEquals(0, x <<= ((-38968517.72504854)<<x)); + assertEquals(-1504619917, x |= (tmp = 2790347379, tmp)); + assertEquals(-1504619917, x &= x); + assertEquals(2790347379, x >>>= ((1825218368)<<(-1843582593.2843356))); + assertEquals(7786038495492170000, x *= x); + assertEquals(-11011696, x |= (((tmp = 2931644407.4936504, tmp)-(3077095016.001658))%(tmp = -1731851949, tmp))); + assertEquals(-107866, x %= ((-697845074.1661191)>>(772708134))); + assertEquals(356779149, x ^= (-356884949.503757)); + assertEquals(0, x %= x); + assertEquals(0, x *= ((tmp = 1542291783, tmp)^x)); + assertEquals(0, x += ((tmp = 1105314644.002441, tmp)&x)); + assertEquals(-1005882993, x ^= (-1005882993.0899806)); + assertEquals(-1301065066, x += (tmp = -295182073, tmp)); + assertEquals(-1454702592, x <<= ((-2440858737.390277)&(-1363565201.7888322))); + assertEquals(-201539012492525570, x *= ((((tmp = -1416268089, tmp)|x)-(tmp = 1669129769, tmp))&(x<<((x/(-2614041678.7423654))%x)))); + assertEquals(-2.1995276811535986e+25, x *= (x/(-1846667987.154371))); + assertEquals(0, x |= ((x*(((x>>>((tmp = 1044173034, tmp)>>>((x<<((tmp = -2906412863, tmp)%((tmp = -437401503, tmp)<<(((((x|(2167319070))<<((tmp = 2766179640.1840167, tmp)&(-2372076054)))*(tmp = -241617431.06416297, tmp))*((((((tmp = 2570465382.5574293, tmp)>>>(x/((-2851324509.354545)%x)))>>(((x+((tmp = -614687945, tmp)^x))^((((tmp = 1653437743, tmp)>>x)/(tmp = 3072995069, tmp))>>x))*(((((-290508242)>>((tmp = 2969511554, tmp)<<(tmp = 158176292.95642304, tmp)))<<(32376015))+(tmp = 2391895870.4562025, tmp))*x)))&((((x/(tmp = 365292078.53605413, tmp))>>x)/(1167322811.0008812))|(((tmp = 2487970377.365221, tmp)^x)<<((tmp = 2342607988.711308, tmp)/(((2276081555.340126)-(((tmp = -2571071930, tmp)>>(tmp = -248468735.76550984, tmp))>>>(tmp = -2862254985.608489, tmp)))^(-1312017395))))))<<x)&(2762717852.949236)))+((((-2492896493)&x)<<(-2756272781.4642315))/x)))))*(2405395452))))>>((-1433975206)/((tmp = -2064757738.6740267, tmp)<<((((tmp = -1563531255, tmp)-(-589277532.2110934))<<x)^(2249328237.0923448)))))-x))-(-225624231))); + assertEquals(0, x *= (tmp = 1657982666.2188392, tmp)); + assertEquals(86443387, x |= (tmp = 86443387.25165462, tmp)); + assertEquals(86443387, x %= (-1341731981.702294)); + assertEquals(172886774, x <<= ((-1799840391)&(1011948481.310498))); + assertEquals(-1115684864, x <<= x); + assertEquals(-2098253702059525600, x *= (1880686715.1865616)); + assertEquals(-2098253700213206300, x -= (tmp = -1846319435.0583687, tmp)); + assertEquals(570692096, x &= (((tmp = -1572055366.64332, tmp)%(tmp = 1720120910, tmp))%((x-(912386952.5959761))*(tmp = -1146251719.4027123, tmp)))); + assertEquals(603979776, x <<= ((-329752233.8144052)&(tmp = -368636559, tmp))); + assertEquals(603979776, x <<= x); + assertEquals(364791569817010200, x *= x); + assertEquals(0, x &= ((2074587775.983799)/(tmp = 438856632.76449287, tmp))); + assertEquals(0, x &= (((1509671758)*(tmp = -935801537.7325008, tmp))>>>(((tmp = -1752877566, tmp)<<x)%(tmp = -517163766, tmp)))); + assertEquals(-2031730599, x ^= ((2264285273)&(tmp = -1762662949.014101, tmp))); + assertEquals(-843578945, x %= (-1188151654)); + assertEquals(-2147483648, x <<= x); + assertEquals(-2147483648, x >>= (tmp = -3165079200.229641, tmp)); + assertEquals(-44086313.1323726, x %= ((x%(-254466243.48728585))-((x>>(-457411829.1063688))-((-2606923436.9333453)/x)))); + assertEquals(-44086313, x |= x); + assertEquals(1037812, x >>>= ((tmp = 342497258.9786743, tmp)+(1652928385.8150895))); + assertEquals(-2371695599678100, x *= (tmp = -2285284425, tmp)); + assertEquals(-2371697387004653, x += (tmp = -1787326553.0542095, tmp)); + assertEquals(0, x ^= x); + assertEquals(0, x >>= ((x^(tmp = 544039787, tmp))>>>x)); + assertEquals(0, x &= ((x%(((((((tmp = -424572417.1088555, tmp)|(-2381863189))/(tmp = -2007482475.1809125, tmp))&(((((tmp = 311016073, tmp)>>(tmp = -1548839845, tmp))+((-2557740399.7947464)<<(2399113209)))&x)>>>x))%(-297180308.7721617))-(tmp = 860906293, tmp))^x))%(-2740622304))); + assertEquals(4971841192462909000, x += ((tmp = -2723203837.572612, tmp)+((((-2909100706)+(-951999374))|(-3116735764))*(3087123539.422669)))); + assertEquals(-460, x >>= (1081807537.557404)); + assertEquals(2354165127.3906384, x += (tmp = 2354165587.3906384, tmp)); + assertEquals(357.8680960002211, x /= ((((x<<(((x&x)+(1113841407))|((x/(tmp = 384533564, tmp))>>>(-605853882))))%x)&((tmp = 2050375842, tmp)>>>x))>>(((2745147573)^x)<<(x-(900043292))))); + assertEquals(0, x *= (x>>>(-295974954.5058532))); + assertEquals(0, x *= ((-2448592125.815531)*(tmp = -94957474.8986013, tmp))); + assertEquals(0, x &= ((x>>x)^(tmp = -1335129180, tmp))); + assertEquals(395092065, x |= ((3081659156)^(tmp = -1608334475, tmp))); + assertEquals(395092065, x &= x); + assertEquals(-413337639, x += (x^(tmp = -664996071.3641524, tmp))); + assertEquals(-1604423637896759800, x *= (x>>>(tmp = 1242912352.955432, tmp))); + assertEquals(0, x &= ((((((tmp = 651293313, tmp)|(((2541604468.635497)>>>(tmp = 758815817.7145422, tmp))>>>((-1948795647)/x)))&x)/((tmp = -3161497100, tmp)+(782910972.3648237)))>>>x)%(834206255.5560443))); + assertEquals(0, x >>>= (tmp = 125945571, tmp)); + assertEquals(NaN, x -= (x%x)); + assertEquals(NaN, x %= (tmp = 282259853, tmp)); + assertEquals(NaN, x += (tmp = -2081332383, tmp)); + assertEquals(0, x >>>= (((x>>(-2298589097.7522116))|((((x>>>(x-(tmp = 755218194, tmp)))|x)%x)-(tmp = 2206031927, tmp)))>>>((((x&(x-x))^(tmp = 2836686653, tmp))*((x<<(tmp = -1624140906.4099245, tmp))>>>((2942895486)|((x>>>x)>>>(-1586571476)))))|((781668993)+(-1857786909))))); + assertEquals(0, x &= (tmp = -708084218.9248881, tmp)); + assertEquals(0, x %= (1645913394.5625715)); + assertEquals(0, x <<= ((x^((tmp = 1185413900, tmp)*((-2441179733.997965)*(tmp = 2554099020.066989, tmp))))%((1704286567.29923)/x))); + assertEquals(0, x += x); + assertEquals(0, x *= x); + assertEquals(0, x |= (x>>>(139138112.141927))); + assertEquals(0, x >>>= (tmp = 2142326564, tmp)); + assertEquals(0, x |= x); + assertEquals(-0, x /= ((((x+(2817799428))|x)%((1050079768)-(x>>>((1452893834.8981247)|((((tmp = -1737187310.889149, tmp)/(tmp = -362842139, tmp))%(1234225406))%(((x|x)*((-1055695643.739629)-((x-x)*(945954197.676585))))-(tmp = 786185315.346615, tmp)))))))<<(-173891691))); + assertEquals(0, x &= (-2842855092.319309)); + assertEquals(0, x &= ((-3188403836.570895)/x)); + assertEquals(0, x *= (x+x)); + assertEquals(NaN, x /= (x>>>(((tmp = 391037497.68871593, tmp)/((192754032)*(1382659402.5745282)))/((((-2187364928)>>>x)>>(tmp = 2563448665.7594023, tmp))^(tmp = 1500866009.7632217, tmp))))); + assertEquals(NaN, x /= ((tmp = -935036555.2500343, tmp)-(x/(((x&(x^(tmp = -3001352832.5034075, tmp)))^x)/((1122547613)>>x))))); + assertEquals(0, x >>= (tmp = -2951766379.0809536, tmp)); + assertEquals(-632945188, x ^= (-632945188.7188203)); + assertEquals(-632945188, x %= ((((((tmp = -3181527314.82724, tmp)&(2280175415))>>(x^(x|x)))^(tmp = -524233678.52970886, tmp))*x)|((tmp = 1782882786, tmp)>>>(tmp = -592607219, tmp)))); + assertEquals(404189184, x <<= ((tmp = -2761472127, tmp)^(36616299.88780403))); + assertEquals(872651572, x ^= (tmp = 739568436.6252247, tmp)); + assertEquals(13, x >>>= ((tmp = -1033843418.865577, tmp)%(x%(1247263629.0445533)))); + assertEquals(0, x >>>= x); + assertEquals(0, x >>= (3189175317)); + assertEquals(0, x &= (((2391973519.6142406)^((-2950058736.191456)|(x*x)))>>(tmp = 343822384.294345, tmp))); + assertEquals(0, x >>>= (tmp = -2306246544, tmp)); + assertEquals(-1572339598, x ^= ((tmp = 2991380083.337327, tmp)&(tmp = -1361507970, tmp))); + assertEquals(649, x >>>= ((1961407923.4950056)>>(x-(-872821523.7513013)))); + assertEquals(649, x ^= (((x&(tmp = -702931788, tmp))^(((x>>x)|(((tmp = 2710759269, tmp)/(x>>(x*((((((tmp = -2428445134.9555864, tmp)+(-1859938743))%(x<<x))*((236868604)+((tmp = -3066688385, tmp)/(787503572.8839133))))/(tmp = 3215629315, tmp))>>(-1315823020)))))%(1461368627.1293125)))>>>(tmp = -2921804417.5735087, tmp)))/(x>>>(((tmp = 2175260691.824617, tmp)/((-582958935.7628009)-((((((x>>x)|(2590503723.4810824))^(tmp = -1994324549, tmp))-(-684683327))/(tmp = -3133419531, tmp))|(tmp = -328974092.05095506, tmp))))>>(-447624639.4518213))))); + assertEquals(649, x %= ((((1854382717)|(((x+(tmp = 2568081234, tmp))-x)+((tmp = 1043086140, tmp)<<((tmp = 2979118595.0496006, tmp)+((x&(2669577199.852803))/(-2567808445.101112))))))<<((((tmp = -1471092047, tmp)&((-3099138855.21041)-((tmp = -798574377.526715, tmp)&((2255586141)<<(-1069867774)))))>>>(((x*(tmp = -2810255707.781517, tmp))/x)*(2706435744.054121)))^(394262253)))^((844325548.0612085)/(tmp = 1434691648, tmp)))); + assertEquals(823215943.1924392, x += (tmp = 823215294.1924392, tmp)); + assertEquals(536872706, x &= ((-334612686)%((1303605874)|x))); + assertEquals(-30666374.413486242, x += ((tmp = -567539080.4134862, tmp)%(tmp = -1655555936.3195171, tmp))); + assertEquals(-56438727096752984, x *= (tmp = 1840410814, tmp)); + assertEquals(-33200107.984488487, x %= (((tmp = 3007206509, tmp)-(3079337725.6659536))%(1819565202.5011497))); + assertEquals(-1214493182, x ^= (-3060193769)); + assertEquals(-1214493179.1335113, x -= ((-3218099496.595745)/(1122662554))); + assertEquals(-1214493179, x >>= ((-375364195)<<(((tmp = 619439637.8754326, tmp)>>(-1830023279.9486575))&(tmp = -1106180387.2448823, tmp)))); + assertEquals(-303623295, x >>= (-2109241374.3349872)); + assertEquals(-0, x %= x); + assertEquals(0, x |= x); + assertEquals(1917126206, x -= (-1917126206)); + assertEquals(2659779928, x -= (tmp = -742653722, tmp)); + assertEquals(-1635187368, x >>= ((tmp = -674385169, tmp)*((9848362.783326745)|(x*(55220544.00989556))))); + assertEquals(-1981113695, x ^= ((tmp = 392404985, tmp)>>(((x<<((2006207061)<<(tmp = 2558988218, tmp)))*((((tmp = 1789304307.1153054, tmp)/(2538061546))<<(tmp = 556026116, tmp))&((tmp = 1076457999.6424632, tmp)*(tmp = -1822378633.2489474, tmp))))%(((((-1117046924)&((-69013651)%(x&(((-2320327696)/(x&x))-(tmp = 2458222544, tmp)))))>>((-3092360983.0037227)/(-3171415636)))*(((tmp = 2520431213, tmp)<<(1066492762.6149663))+((tmp = 1272200889, tmp)^((1687693123.2295754)+x))))-(-1096823395))))); + assertEquals(-990556848, x >>= x); + assertEquals(981202869119695100, x *= x); + assertEquals(981202869119695100, x -= (x/x)); + assertEquals(0, x ^= (x>>x)); + assertEquals(NaN, x %= x); + assertEquals(0, x ^= x); + assertEquals(0, x *= ((((2980512718)>>>x)<<((x^(-1111233869))>>((2531466092.6036797)>>>(((tmp = -1791229364, tmp)*(-2210950307.206208))%((tmp = -806645443, tmp)<<((((((((tmp = 112334634.26187229, tmp)%(x|((((2154021796.1166573)+x)&((-1047293079.9686966)^(tmp = -1894127139, tmp)))+(tmp = 1910946653.2314827, tmp))))^(293142672.5016146))-x)<<(-1593533039.8718698))+x)>>(x<<(((46359706.50393462)&(tmp = 272146661, tmp))|(tmp = 2117690168, tmp))))%(tmp = -1784737092.4924843, tmp)))))))-(1465796246))); + assertEquals(0, x &= x); + assertEquals(NaN, x %= x); + assertEquals(0, x &= (x+(-1612418456))); + assertEquals(0, x &= ((tmp = -843964311, tmp)/x)); + assertEquals(NaN, x /= x); + assertEquals(NaN, x *= x); + assertEquals(NaN, x += (x>>>(54020240))); + assertEquals(489206868, x |= (489206868)); + assertEquals(489206868, x &= x); + assertEquals(489206848, x &= ((tmp = -1699133906.2361684, tmp)>>(tmp = 2658633814, tmp))); + assertEquals(489206848, x |= x); + assertEquals(1910559006, x -= (tmp = -1421352158, tmp)); + assertEquals(1, x >>= x); + assertEquals(0, x -= x); + assertEquals(0, x %= (x^(tmp = 2745376003.2927403, tmp))); + assertEquals(0, x %= (((tmp = 3199743302.1063356, tmp)^((-1905944176)&(x>>>(187247029.5209098))))<<((x*((-1394648387)*(1252234289)))-(3140049815)))); + assertEquals(0, x <<= (-2567872355)); + assertEquals(0, x %= (tmp = 1057707555.8604916, tmp)); + assertEquals(0, x %= ((tmp = -1877857405.0228279, tmp)>>>(((tmp = 423831184, tmp)*((tmp = -2106757468.324615, tmp)%(tmp = -1197717524.6540637, tmp)))>>(tmp = -93746263.46774769, tmp)))); + assertEquals(0, x |= x); + assertEquals(-0, x *= ((tmp = 1317609776.6323466, tmp)*(tmp = -26959885.89325118, tmp))); + assertEquals(0, x >>= (-1288116122.0091262)); + assertEquals(0, x &= ((370818172.92511404)%((tmp = -528319853.54781747, tmp)*(x/((tmp = -2839758076, tmp)^(x+(((-1258213460.041857)<<(tmp = 302017800.72064054, tmp))|((((tmp = -624254210, tmp)^((-338165065.97507)|((623392964)-x)))>>>x)%(tmp = 2767629843.0643625, tmp))))))))); + assertEquals(0, x >>>= x); + assertEquals(0, x >>>= x); + assertEquals(0, x |= ((-2001549164.1988192)*x)); + assertEquals(0, x -= x); + assertEquals(0, x *= (((((165836842.14390492)*(tmp = -3220002961, tmp))|(-2840620221.747431))%((x/(tmp = 3153915610, tmp))>>>(tmp = 2018941558, tmp)))>>>x)); + assertEquals(-0, x *= (-231994402.93764925)); + assertEquals(0, x <<= x); + assertEquals(0, x %= (tmp = 2702385056.1149964, tmp)); + assertEquals(0, x <<= (tmp = 378459323, tmp)); + assertEquals(0, x >>>= ((x&(x&(((-1014963013)<<(x&((tmp = -3110294840, tmp)|(x+(x<<(1129643420))))))+(1093795819.1853619))))+((((tmp = -2295103369.697398, tmp)&(((370501313.43019223)>>>(2465439579))/x))-x)>>x))); + assertEquals(0, x /= ((tmp = 1779625847, tmp)+(tmp = -662459654.6908865, tmp))); + assertEquals(0, x -= x); + assertEquals(0, x %= ((tmp = 2723291421, tmp)|(277246502.4027958))); + assertEquals(0, x ^= (((-2936270162)>>>((((tmp = -2019015609.1648235, tmp)|(47218153))*(-823685284))+x))&(x<<(x*(x|(((tmp = -941955398, tmp)^(tmp = -2365238993.5300865, tmp))-(778674685))))))); + assertEquals(0, x >>>= x); + assertEquals(NaN, x %= x); + assertEquals(0, x &= (-175235975.8858137)); + assertEquals(-2684493800.1062117, x += (tmp = -2684493800.1062117, tmp)); + assertEquals(-1290806265.6063132, x -= (-1393687534.4998984)); + assertEquals(-1290806265, x >>= (((x>>(tmp = -1710112056.4935386, tmp))*(586227650.2860553))<<(tmp = -2918251533.6052856, tmp))); + assertEquals(23470008, x >>>= x); + assertEquals(1668734969, x |= ((-295560682.9663689)^(x|((((tmp = -1183847364, tmp)&(3135327694))+(1679127747.1406744))-((-1895825528)%((tmp = -3180115006, tmp)+((tmp = 2373812187, tmp)|x))))))); + assertEquals(1744306169, x |= (1188503928.5009093)); + assertEquals(1744306169, x %= (tmp = -2723982401.4997177, tmp)); + assertEquals(3488612338, x += x); + assertEquals(3488612337, x += (((x/(-325849204))>>x)|(-1820624550.9149108))); + assertEquals(-1511119305, x ^= (tmp = 1778506182.2952862, tmp)); + assertEquals(-12211415, x %= (x^(tmp = -54943035, tmp))); + assertEquals(-12211415, x %= ((-1267051884)%(-643566443.0122576))); + assertEquals(-30.84976063258681, x /= (((1052047194)>>>x)&(1495698235.5117269))); + assertEquals(-61.69952126517362, x += x); + assertEquals(-244, x <<= (x^(x+(tmp = -2822258210.076373, tmp)))); + assertEquals(-6652, x &= ((tmp = 2593685093, tmp)>>((((2047688852.4609032)<<((x*(-611076291))*x))^(-2665364024.817528))>>>(165267874)))); + assertEquals(0, x -= x); + assertEquals(0, x /= (2454186758)); + assertEquals(0, x &= (tmp = -2226895206, tmp)); + assertEquals(0, x += x); + assertEquals(-21390701, x += ((-1369004846.0816503)>>(tmp = -2661552634.039692, tmp))); + assertEquals(-0.012568536912921919, x /= (1701924507.856429)); + assertEquals(7.09517966608176e-11, x /= (tmp = -177141911.8955555, tmp)); + assertEquals(0, x >>= (tmp = 231535697, tmp)); + assertEquals(1383687797, x ^= (tmp = -2911279499.568808, tmp)); + assertEquals(1383687797, x %= (tmp = -2258636646.5294995, tmp)); + assertEquals(1319, x >>= ((tmp = -2549411892.8426056, tmp)/(((((1532476676)^(153720871.82640445))+x)/(((2988190456.3206205)&(tmp = -2920873674, tmp))-(((((tmp = -1044518167.0581458, tmp)>>x)-((((tmp = -194701879.13505793, tmp)&(498352051))&((tmp = -2167339635.6529818, tmp)^(((x>>(tmp = 700159851, tmp))*(tmp = 2874921158, tmp))/x)))-((2856128689)|((-1876321441)>>>(2110732915)))))^((((tmp = -193379494.18825436, tmp)/(-3055182489.533142))<<x)+((tmp = -2286109605, tmp)>>(tmp = 698475484.3987849, tmp))))^(3182231653.500364))))|(((tmp = -194670835, tmp)>>>((786780139)%(((2114171416.2305853)^(1703145352.8143656))/x)))>>>((tmp = -3029462067, tmp)>>((67647572.02624655)&(x*(-2394283060)))))))); + assertEquals(13903855, x |= ((tmp = -2515306586, tmp)>>>x)); + assertEquals(54311, x >>>= ((-2413722658)-((tmp = -2159787584, tmp)^(tmp = 949937622.9744623, tmp)))); + assertEquals(108622, x += x); + assertEquals(1250717187, x ^= ((tmp = 842692148, tmp)+(((2649331689.694273)<<x)-(tmp = -2992181273, tmp)))); + assertEquals(4536777, x %= (tmp = 73304730, tmp)); + assertEquals(0, x -= x); + assertEquals(-580081499, x ^= ((tmp = -580081499.0170684, tmp)^(x%(tmp = -1542730817.88261, tmp)))); + assertEquals(-1382738784, x <<= x); + assertEquals(-1382738784, x <<= x); + assertEquals(2912228512, x >>>= (x*(x>>>x))); + assertEquals(-1076374105, x |= (2589443367)); + assertEquals(-0.2818750938197037, x /= (((tmp = -1559525732.9603848, tmp)|(-477068917.5483327))>>>((-688616257)*((((tmp = -1192490153.1226473, tmp)*(-502280624.0265591))<<(-442688727.4881985))%(x+(((((tmp = -2948836853.831935, tmp)-(tmp = -2850398330.910424, tmp))>>>(x>>>(-1947835558)))^x)+(x*x))))))); + assertEquals(2032826546, x |= (tmp = 2032826546.819327, tmp)); + assertEquals(3408404827.14316, x += (tmp = 1375578281.1431599, tmp)); + assertEquals(258183922.14315987, x %= (tmp = 350024545, tmp)); + assertEquals(479694848, x <<= (tmp = -481187157, tmp)); + assertEquals(-2147483648, x <<= (((tmp = -2956588045.472398, tmp)>>>(((tmp = -1838455399.1775856, tmp)&(((((tmp = -637547, tmp)/x)&(x^((-44876328.1767962)+(((-2059598286)-(1071496688))%(tmp = -1492254402, tmp)))))-(x%x))*(x|x)))>>(1226250760)))<<x)); + assertEquals(-2288163338.9020815, x -= (140679690.9020816)); + assertEquals(4954833118513997000, x *= (-2165419327.4906025)); + assertEquals(1578331238, x ^= (-2410854298.2270393)); + assertEquals(-810627292, x += (-2388958530)); + assertEquals(-810627292, x ^= ((1495296640.4087524)/(tmp = 1561790291, tmp))); + assertEquals(657116606535253200, x *= x); + assertEquals(0.675840332689047, x %= (((-1816548473)^(((tmp = -151918689.19451094, tmp)|(1819911186.535233))/((((((1514297447)+(tmp = 856485190.9684253, tmp))&(((1809369464.4363992)<<(493538496))*x))+((x*(x>>(x&(tmp = 222293461, tmp))))>>>(((784519621)|x)^((-580766922)>>(tmp = -947264116, tmp)))))>>>((((2794210354.22964)>>>(((2896952532.0183973)*((x+(tmp = -1813175940, tmp))<<(tmp = -1302618293, tmp)))&x))>>(x-(((x|((1456466890.1952953)*x))^(-169979758.19158387))-(x-x))))>>x))&(tmp = 2671604078.3026733, tmp))))/(-1701675745))); + assertEquals(0.675840332689047, x %= ((tmp = 2421871143, tmp)^x)); + assertEquals(NaN, x %= ((((tmp = 1175526323.433271, tmp)+(tmp = 2813009575.952405, tmp))%((tmp = -3112133516.3303423, tmp)&x))&((((((-424329392)^(tmp = 1430146361, tmp))+x)-(1533557337.268306))%((tmp = -3117619446, tmp)-(-3127129232)))>>>x))); + assertEquals(NaN, x += x); + assertEquals(0, x >>>= ((1710641057.7325037)%(104961723.56541145))); + assertEquals(0, x <<= (tmp = -970072906, tmp)); + assertEquals(0, x *= (87768668)); + assertEquals(-1464968122, x ^= (tmp = -1464968122, tmp)); + assertEquals(-1467983895, x ^= ((tmp = -1204896021, tmp)>>>(((91792661)&(x>>>(((-2364345606)>>>x)*x)))+x))); + assertEquals(2.991581508270506, x /= (-490704963.5591147)); + assertEquals(0, x >>>= x); + assertEquals(0, x >>= ((tmp = 639854873, tmp)%(tmp = 743486160.3597239, tmp))); + assertEquals(0, x <<= (tmp = 1045577245.3403939, tmp)); + assertEquals(0, x >>= ((tmp = -1932462290, tmp)|(tmp = 1629217987, tmp))); + assertEquals(517617438, x ^= ((tmp = 2737789043, tmp)%(tmp = -2220171604.135681, tmp))); + assertEquals(126371, x >>>= ((tmp = 205210223.69909227, tmp)-(tmp = 598118404, tmp))); + assertEquals(918548455, x |= ((918228734.8363427)+(x+x))); + assertEquals(918548455, x |= ((tmp = 599828198, tmp)>>((tmp = -851081330, tmp)|(tmp = -1152596996.8443217, tmp)))); + assertEquals(918548443.7739062, x -= ((tmp = 1497642976.2260938, tmp)%(x>>(tmp = -548469702.5849569, tmp)))); + assertEquals(0.7739062309265137, x %= (x&x)); + assertEquals(2317939163.8239403, x *= (tmp = 2995116296, tmp)); + assertEquals(1014415360, x <<= (-279972114)); + assertEquals(0, x &= ((296810932)/(x*(tmp = -2750499950, tmp)))); + assertEquals(0, x *= (x%((126285451.05086231)>>>(x*(tmp = -2789790532, tmp))))); + assertEquals(0, x >>>= ((975695102.5771483)%(x-((-1011726540)-((tmp = 2223194882, tmp)/x))))); + assertEquals(-1747794584, x |= (-1747794584.3839395)); + assertEquals(-543544679, x %= (tmp = -1204249905, tmp)); + assertEquals(-543544679, x %= (-881024001)); + assertEquals(1, x /= x); + assertEquals(-1879376393, x |= ((tmp = 161643764, tmp)|(tmp = 2281346499.9084272, tmp))); + assertEquals(1.321124264431369, x /= (-1422558379.7061746)); + assertEquals(1, x >>>= (x&(tmp = -963118950.4710281, tmp))); + assertEquals(3, x ^= ((x+x)/x)); + assertEquals(1, x /= x); + assertEquals(1, x &= (2090796073)); + assertEquals(-1284301873, x ^= (((-11041168.146357536)+(tmp = -1273260707.8134556, tmp))+x)); + assertEquals(292559045, x &= (x&((-2401110739)^((tmp = 630802904, tmp)^(((1012634447.0346229)+x)%((tmp = -1240091095, tmp)%(x/(-1483936527)))))))); + assertEquals(0, x %= x); + assertEquals(0, x /= (tmp = 613145428.3653506, tmp)); + assertEquals(0, x /= ((x-(tmp = 3116638456, tmp))*(-973300716))); + assertEquals(0, x %= (tmp = -1794741286.0464535, tmp)); + assertEquals(0, x &= x); + assertEquals(0, x >>= (-551370105.0746605)); + assertEquals(-1471996874, x ^= ((2822970422.2331414)-x)); + assertEquals(-277914313, x |= (tmp = -818980601.2544096, tmp)); + assertEquals(-34, x >>= x); + assertEquals(305422768, x -= (-305422802)); + assertEquals(-2406146240, x += (tmp = -2711569008, tmp)); + assertEquals(1073745408, x &= (tmp = -3046625618, tmp)); + assertEquals(1073745408, x <<= ((-1234108306.7646303)<<((-233519302)|x))); + assertEquals(1073745408, x %= (tmp = 1898831268, tmp)); + assertEquals(1073745408, x <<= (((tmp = 3089406038, tmp)/x)&(-2960027680))); + assertEquals(65536, x >>>= (2858188366)); + assertEquals(128, x >>>= ((-2640257239.857275)%((tmp = -3185405235.3177376, tmp)*x))); + assertEquals(128, x >>>= x); + assertEquals(128, x -= (x&(x-(tmp = -247588018, tmp)))); + assertEquals(81616906825.07776, x *= (tmp = 637632084.57092, tmp)); + assertEquals(78860097686.07776, x -= (((1507215684)^((709254783)+(((x<<x)*((-2890828152.667641)%(2537817529.2041526)))^x)))+(3114024487))); + assertEquals(-2920545695.721283, x += (((tmp = -2555437435, tmp)>>>x)-((2920546109.72129)+x))); + assertEquals(-2879412281.721283, x += ((-1662428756)>>>(tmp = -1928491386.6926208, tmp))); + assertEquals(67403845, x &= (tmp = 2921644117, tmp)); + assertEquals(16850961, x >>>= (((-1039328365)>>>(tmp = -768615112, tmp))<<((1037261855)*(tmp = -2906902831.4797926, tmp)))); + assertEquals(0, x ^= x); + assertEquals(0, x *= ((-2729056530)/((-1776175111)%(1493002300.4604707)))); + assertEquals(0, x *= (tmp = 370696035.22912216, tmp)); + assertEquals(0, x ^= x); + assertEquals(0, x |= ((((((tmp = -1541196993, tmp)^x)/(854730380.1799632))/(2879117705.492209))+((((-2892068577)^(-2460614446.1044483))>>>((743413943)<<(-1285280084.4220598)))/(tmp = -1719994579.5141463, tmp)))%(((((tmp = 2522797851.088227, tmp)<<(tmp = 2257160597.1538725, tmp))/(-680406007))&((x>>>(tmp = -260350730, tmp))^(tmp = 1920522110.852598, tmp)))>>(-697620442)))); + assertEquals(0, x &= x); + assertEquals(-591399642.958673, x += (x-(tmp = 591399642.958673, tmp))); + assertEquals(27, x >>>= (tmp = -726721317.2109983, tmp)); + assertEquals(-2043736843, x -= (2043736870)); + assertEquals(-3991674, x >>= (tmp = 1098126089, tmp)); + assertEquals(-997919, x >>= ((x%(((x*(((-1497329257.1781685)%(2334511329.2690516))/(-3072526140.6635056)))+(-1843998852))-(tmp = 240300314.34070587, tmp)))+(714080860.6032693))); + assertEquals(-0, x %= x); + assertEquals(NaN, x /= x); + assertEquals(0, x >>= (tmp = 538348328.5363884, tmp)); + assertEquals(0, x *= (800317515)); + assertEquals(0, x -= x); + assertEquals(0, x >>= (984205514)); + assertEquals(857282491, x += (tmp = 857282491, tmp)); + assertEquals(587792897, x &= (tmp = 2951307845.164059, tmp)); + assertEquals(595301269, x |= (tmp = 24285588.90314555, tmp)); + assertEquals(1190602538, x += x); + assertEquals(0, x -= x); + assertEquals(-442423060, x |= ((x^((x-(tmp = 2342497475.637024, tmp))%(-1900074414.7678084)))|((tmp = 1932380130, tmp)%(x%(2291727569.817062))))); + assertEquals(-442423060, x %= (((tmp = 703479475.545413, tmp)>>(x-x))<<(2435723056.753845))); + assertEquals(1, x /= x); + assertEquals(0, x >>= x); + assertEquals(-1265317851, x |= (tmp = -1265317851, tmp)); + assertEquals(-2, x >>= (-2015895906.8256726)); + assertEquals(-0, x %= x); + assertEquals(-0, x %= (((1219237746)+(284683029))*(((tmp = 2288119628, tmp)|(-404658161.2563329))*(-265228691.74142504)))); + assertEquals(1039509109, x -= (-1039509109)); + assertEquals(2079018218, x += x); + assertEquals(-1979.9362673719077, x /= ((3219723500)>>x)); + assertEquals(-62, x >>= ((x/(326466691))*(tmp = -607654070, tmp))); + assertEquals(-45, x |= (tmp = -2954888429.549882, tmp)); + assertEquals(-1180929712, x &= (3114037588.570232)); + assertEquals(815550480, x &= (-2302684143.3378315)); + assertEquals(815550480, x %= (-2177479570)); + assertEquals(815550480, x %= (tmp = 2895822167, tmp)); + assertEquals(815550480, x %= (-1247621230.5438688)); + assertEquals(283929811, x -= ((tmp = 251831053.17096448, tmp)|((tmp = 1140463506.004994, tmp)+(tmp = -743224673.546309, tmp)))); + assertEquals(1825767424, x <<= (((tmp = 1732353599, tmp)^(tmp = 658726044, tmp))>>>((-2827889370.932477)%(tmp = 1950139204.3291233, tmp)))); + assertEquals(1828450414, x |= (tmp = 1618538606, tmp)); + assertEquals(0, x <<= (-2411670689.045702)); + assertEquals(0, x <<= (-27744888.428537607)); + assertEquals(-0, x /= (tmp = -1597552450, tmp)); + assertEquals(0, x >>>= (((2165722776.7220936)>>>(tmp = 1233069931, tmp))>>>(-1120420811))); + assertEquals(-0, x *= ((tmp = -1505252656, tmp)>>((((3035637099.6156535)&((467761577.7669761)>>(-361034537)))^(tmp = -2347994840.6541123, tmp))*(tmp = -2191739821, tmp)))); + assertEquals(0, x &= (795727404.0738752)); + assertEquals(-0, x *= (tmp = -3125944685.3991394, tmp)); + assertEquals(-0, x *= (x&x)); + assertEquals(0, x >>= ((tmp = -2045709233, tmp)^x)); + assertEquals(NaN, x /= (x>>(x/(3102894071)))); + assertEquals(NaN, x += ((tmp = 2149079756.8941655, tmp)-(tmp = 810121645.305179, tmp))); + assertEquals(0, x >>>= (-859842989)); + assertEquals(0, x >>>= (tmp = 2530531143.9369526, tmp)); + assertEquals(0, x >>= (((-932981419.6254237)|(tmp = 1591591715, tmp))>>>(x+((3149795006)>>>(tmp = 613352154, tmp))))); + assertEquals(-4294967295, x -= ((((-2289331668)%(-282648480.0078714))>>(-1373720705.5142756))>>>((tmp = 15511563.517014384, tmp)/(360279080)))); + assertEquals(1, x &= x); + assertEquals(0, x >>= (x^(-2791872557.5190563))); + assertEquals(0, x &= ((tmp = 336466956.7847167, tmp)>>((1235728252.053619)|(x<<((1828176636.13488)%x))))); + assertEquals(-0, x *= (-364042830.8894656)); + assertEquals(0, x >>>= x); + assertEquals(-1675298680, x |= ((2323049541.321387)+(296619075))); + assertEquals(-0, x %= x); + assertEquals(-1583048579.4420977, x += (-1583048579.4420977)); + assertEquals(0, x -= x); + assertEquals(-2, x ^= ((603171992.0545617)/(((-271888695.718297)%(tmp = -400159585, tmp))^((((tmp = 1536123971, tmp)-(tmp = -2310418666.6243773, tmp))|((tmp = 2242779597.1219435, tmp)<<(tmp = 1758127684.4745512, tmp)))/x)))); + assertEquals(-2, x &= (x&x)); + assertEquals(0, x &= ((tmp = -1098806007.4049063, tmp)/(((2862384059.3229523)/((((tmp = -92960842, tmp)-(x>>(tmp = 1244068344.2269042, tmp)))&x)*(tmp = -1919148313, tmp)))<<(-2486665929)))); + assertEquals(0, x &= x); + assertEquals(-1441272634.582818, x -= (1441272634.582818)); + assertEquals(-3, x >>= (tmp = 3186393693.7727594, tmp)); + assertEquals(-1206855850, x ^= (((tmp = 607979495.303539, tmp)-(tmp = -2480131951, tmp))^(x*((tmp = 1324153477, tmp)/((1248126288)+(x|(1917331780.0741704))))))); + assertEquals(-1206855853, x ^= (x>>>(653288765.1749961))); + assertEquals(-1206857725, x &= (3149461539.6019173)); + assertEquals(3088109571, x >>>= (x*(x<<(tmp = 1543540084, tmp)))); + assertEquals(536903680, x &= (tmp = 644851760, tmp)); + assertEquals(536903674.312194, x += (((-3183290076)-((tmp = 40738191.12097299, tmp)-x))/((x>>>(3151371851.9408646))^(tmp = 472698205.22445416, tmp)))); + assertEquals(2127424750.0506563, x -= (tmp = -1590521075.7384624, tmp)); + assertEquals(2127424750.0506563, x %= (tmp = 3027273433.361373, tmp)); + assertEquals(0, x >>= (x>>(1445204441.702043))); + assertEquals(NaN, x %= (x<<x)); + assertEquals(0, x ^= ((tmp = -2903841152.136344, tmp)-(x%(2938662860)))); + assertEquals(0, x <<= (x<<x)); + assertEquals(0, x >>>= (tmp = -979481631.33442, tmp)); + assertEquals(0, x >>= x); + assertEquals(0, x &= (((x%((((((tmp = 1657446354.6820035, tmp)>>(-1916527001.2992697))/x)>>(tmp = 1450467955, tmp))&(277676820))+(x/(-945587805))))/((tmp = -690095354, tmp)^x))+(tmp = -2651195021, tmp))); + assertEquals(0, x <<= (752343428.2934296)); + assertEquals(0, x /= (tmp = 3022310299, tmp)); + assertEquals(0, x >>= (x%((388245402)>>>x))); + assertEquals(NaN, x %= x); + assertEquals(NaN, x %= ((tmp = 1205123529.8649468, tmp)>>>(-2848300932))); + assertEquals(0, x >>= ((x>>>x)<<(tmp = 487841938, tmp))); + assertEquals(0, x *= (((273436000.9463471)|(tmp = 141134074.27978027, tmp))^(tmp = 1220326800.7885802, tmp))); + assertEquals(1525600768, x |= (((x^(-2674777396))-(tmp = 1966360716.3434916, tmp))<<(794782595.9340223))); + assertEquals(761927595, x %= (tmp = -763673173, tmp)); + assertEquals(1.1353588586934338, x /= ((x&((-1897159300.4789193)*(-348338328.0939896)))&(978680905.6470605))); + assertEquals(8.631173314966319e-10, x /= (1315416592)); + assertEquals(0, x >>= ((tmp = -2581239435, tmp)-((-628818404.1122074)<<x))); + assertEquals(0, x -= x); + assertEquals(0, x *= (2925158236)); + assertEquals(0, x /= (x+(tmp = 1405531594.0181243, tmp))); + assertEquals(0, x *= (2712022631.230831)); + assertEquals(0, x >>= (tmp = 80518779.81608999, tmp)); + assertEquals(1953477932.8046472, x += (tmp = 1953477932.8046472, tmp)); + assertEquals(1953477932, x >>= (tmp = 3025539936, tmp)); + assertEquals(1953477932, x -= ((-2675119685.8812313)>>(x/(-1808264410.9754841)))); + assertEquals(1292620430, x += ((-660857502)%((((tmp = -698782819, tmp)%(tmp = 2847304199, tmp))<<(-2423443217.1315413))+x))); + assertEquals(78895, x >>>= x); + assertEquals(2, x >>= x); + assertEquals(2, x <<= (tmp = 1313641888.8301702, tmp)); + assertEquals(1857416935.2532766, x += (tmp = 1857416933.2532766, tmp)); + assertEquals(-1677721600, x <<= (tmp = -2482476902, tmp)); + assertEquals(309226853.62854385, x -= (tmp = -1986948453.6285439, tmp)); + assertEquals(33965156, x &= (2409088742)); + assertEquals(Infinity, x /= (x-(x<<((x/(tmp = -3106546671.536726, tmp))/((tmp = 2695710176, tmp)-((((-2102442864)&(857636911.7079853))/x)%(-65640292))))))); + assertEquals(1270005091, x |= (tmp = 1270005091.0081215, tmp)); + assertEquals(1270005091, x %= (tmp = -1833876598.2761571, tmp)); + assertEquals(158750636, x >>>= x); + assertEquals(-1000809106.0879555, x -= (tmp = 1159559742.0879555, tmp)); + assertEquals(72400936, x &= ((2448271389.3097963)%(tmp = 1517733861, tmp))); + assertEquals(282816, x >>= x); + assertEquals(282816, x %= (tmp = 3192677386, tmp)); + assertEquals(0.00021521351827207216, x /= (1314118194.2040696)); + assertEquals(Infinity, x /= (((tmp = 2822091386.1977024, tmp)&x)%(tmp = -3155658210, tmp))); + assertEquals(NaN, x %= (-359319199)); + assertEquals(0, x >>>= (((tmp = -2651558483, tmp)-(x<<(tmp = 2537675226.941645, tmp)))<<(tmp = 667468049.0240343, tmp))); + assertEquals(-0, x *= (tmp = -2827980482.12998, tmp)); + assertEquals(-0, x %= (((tmp = -689972329.3533998, tmp)>>>x)|(tmp = -7488144, tmp))); + assertEquals(0, x >>>= x); + assertEquals(0, x |= x); + assertEquals(-2410373675.2262926, x -= (2410373675.2262926)); + assertEquals(1840423, x >>= ((-1081642113)^x)); + assertEquals(-4829451429403412, x *= (-2624098606.35485)); + assertEquals(-94552231, x %= (tmp = -97015883, tmp)); + assertEquals(-94433287, x ^= (((tmp = -2297735280, tmp)&(((tmp = 2261074987.7072973, tmp)%((((2565078998)^(-2573247878))|x)|(((tmp = -2120919004.7239416, tmp)>>(tmp = -579224101, tmp))>>>(1905808441))))*(x|(3149383322))))>>(542664972))); + assertEquals(0, x ^= (x<<(tmp = -3112569312, tmp))); + assertEquals(0, x <<= (-2141934818.7052917)); + assertEquals(0, x >>= (tmp = -2539525922, tmp)); + assertEquals(-434467613, x ^= (tmp = -434467613, tmp)); + assertEquals(-274792709, x |= (1233452601.462551)); + assertEquals(-274726917, x |= (-2130333750)); + assertEquals(-272629761, x |= (-1516071602.5622227)); + assertEquals(-272629761, x |= ((tmp = 3012131694, tmp)&((tmp = -2595342375.8674774, tmp)-((tmp = -2710765792, tmp)>>>((x-(tmp = 2397845540, tmp))+(2496667307)))))); + assertEquals(-4194305, x |= (1343705633.165825)); + assertEquals(4190207, x >>>= ((tmp = 276587830, tmp)*((tmp = -1517753936, tmp)>>x))); + assertEquals(0, x >>= (x|((2247486919)-((-1664642412.4710495)*((((tmp = -358185292.17083216, tmp)-(tmp = -1472193444, tmp))*(tmp = 2699733752, tmp))&((x|(x<<(1137610148.1318119)))>>(((375089690.8764564)*x)&(tmp = 859788933.9560187, tmp)))))))); + assertEquals(0, x %= (3080673960)); + assertEquals(0, x >>>= (1328846190.1963305)); + assertEquals(1249447579, x |= (-3045519717.580775)); + assertEquals(-0.8743931060971377, x /= (-1428931187)); + assertEquals(1, x |= ((tmp = -1756877535.7557893, tmp)/((-142900015.93200803)<<(1414557031.347334)))); + assertEquals(759627265, x ^= (759627264.0514802)); + assertEquals(741823, x >>= (1106391210)); + assertEquals(610451, x &= ((x>>>((919849416)+((tmp = -427708986, tmp)^((x%x)|(tmp = -2853100288.932063, tmp)))))*x)); + assertEquals(372650423401, x *= x); + assertEquals(410404493, x >>>= ((((-1425086765)>>>x)>>((2813118707.914771)>>(-424850240)))^x)); + assertEquals(120511585729013, x *= ((tmp = -1889454669, tmp)>>>x)); + assertEquals(120513295294304.22, x -= (tmp = -1709565291.2115698, tmp)); + assertEquals(6164, x >>>= ((2244715719.397763)^(tmp = -741235818.6903033, tmp))); + assertEquals(937572790.468221, x -= (tmp = -937566626.468221, tmp)); + assertEquals(937572790, x |= ((2129102867.156146)*(x%x))); + assertEquals(32, x &= ((2700124055.3712993)>>>((1977241506)>>>(-2915605511)))); + assertEquals(32, x %= (tmp = -2513825862, tmp)); + assertEquals(0, x <<= (-1379604802)); + assertEquals(0, x >>>= (tmp = -1033248759, tmp)); + assertEquals(-1151517050, x ^= (3143450246)); + assertEquals(-180577, x |= ((738373819.4081701)^(-357134176))); + assertEquals(-0, x %= x); + assertEquals(-2086887759, x |= (tmp = 2208079537, tmp)); + assertEquals(-2, x >>= (1460216478.7305799)); + assertEquals(-2, x %= ((-1979700249.0593133)^(-3156454032.4790583))); + assertEquals(-256, x <<= ((1810316926)>>>(tmp = 414362256, tmp))); + assertEquals(-1, x >>= (((((((-1616428585.595561)*((tmp = 2574896242.9045777, tmp)|(86659152.37838173)))>>(((tmp = 2476869361, tmp)&((x+((tmp = -2445847462.1974697, tmp)>>(tmp = -1960643509.5255682, tmp)))+(x|(((((2231574372.778028)|(tmp = 1824767560, tmp))>>>((1108035230.2692142)|(tmp = 2354035815, tmp)))/((tmp = -2602922032, tmp)>>(-925080304.7681987)))-x))))-(x>>x)))>>>((tmp = 751425805.8402164, tmp)|(tmp = 1165240270.3437088, tmp)))-x)*(2870745939))-(x>>>((tmp = 2986532631.405425, tmp)>>>(((tmp = 2547448699, tmp)+(((((x<<(((((-2756908638.4197435)>>>(3134770084))-(-1147872642.3756688))%(x*(tmp = -282198341.6600039, tmp)))+(-770969864.2055655)))+((-2725270341)^x))/(-3093925722))>>(x&x))>>((tmp = -2705768192, tmp)>>>(((tmp = 577253091.6042917, tmp)/(((x&(((((x+x)>>>(-1000588972))/(x&(717414336)))^(tmp = 428782104.21504414, tmp))>>>(1084724288.953223)))%(tmp = -2130932217.4562194, tmp))&x))-(-286367389)))))+((x>>(tmp = 2001277117, tmp))>>((tmp = 1028512592, tmp)^((tmp = 2055148650, tmp)+((tmp = 1490798399, tmp)/(tmp = -2077566434.2678986, tmp)))))))))); + assertEquals(-1, x |= (tmp = 1542129482, tmp)); + assertEquals(-671816743, x &= (tmp = -671816743.9111726, tmp)); + assertEquals(-1840333080, x -= (1168516337)); + assertEquals(-1755382023, x |= ((((tmp = 2625163636.0142937, tmp)>>>((tmp = 1534304735, tmp)^x))-(tmp = -1959666777.9995313, tmp))%x)); + assertEquals(-1750421896, x += (x>>>(tmp = -1364828055.1003118, tmp))); + assertEquals(-72864007, x %= (tmp = 239651127, tmp)); + assertEquals(-72863956, x -= (((tmp = -1103261657.626319, tmp)*((tmp = 2789506613, tmp)+((tmp = 2294239314, tmp)>>>(2588428607.5454817))))>>x)); + assertEquals(-170337477, x -= (tmp = 97473521, tmp)); + assertEquals(-170337477, x |= (((tmp = 246292300.58998203, tmp)/(((tmp = -2664407492, tmp)|((-2416228818)^(tmp = 909802077, tmp)))%(tmp = 532643021.68109465, tmp)))/(tmp = 1015597843.8295637, tmp))); + assertEquals(1, x >>>= (((tmp = -2247554641.7422867, tmp)/(1186555294))%(tmp = -785511772.3124621, tmp))); + assertEquals(1188939891.668705, x -= (tmp = -1188939890.668705, tmp)); + assertEquals(1188939891, x &= x); + assertEquals(1188413555, x &= (((tmp = -372965330.5709038, tmp)%(((tmp = 3108909487, tmp)|(x^(-1056955571.9951684)))^(-1549217484.009048)))/(x>>>(1403428437.9368362)))); + assertEquals(-0.7343692094664643, x /= (-1618278026.4758227)); + assertEquals(0, x -= x); + assertEquals(0, x &= (-2701762139.7500515)); + assertEquals(0, x >>>= (((-1692761485.2299166)^x)+(tmp = -1221349575.938864, tmp))); + assertEquals(0, x <<= ((2148160230)<<x)); + assertEquals(0, x <<= (((x<<(-740907931.38363))&(tmp = -930960051.6095045, tmp))>>(x/((tmp = -1921545150.1239789, tmp)/(-3015379806))))); + assertEquals(0, x <<= x); + assertEquals(NaN, x /= (x|x)); + assertEquals(0, x >>= (tmp = -2265988773, tmp)); + assertEquals(-0, x *= (((x<<(-928153614))<<(-989694208))^(2544757713.481016))); + assertEquals(0, x >>= ((tmp = 578009959.5299993, tmp)>>x)); + assertEquals(0, x /= ((((tmp = 412689800.0431709, tmp)&(1630886276))*(tmp = 2028783080.7296097, tmp))/x)); + assertEquals(0, x |= ((((x*(-2197198786))>>((2719887264.761987)<<(tmp = 2253246512, tmp)))-(tmp = -150703768.07045603, tmp))/(((-3160098146)%(((((1486098047.843547)>>(((tmp = -593773744.1144242, tmp)&(x<<(2651087978)))|((-680492758.930413)>>(tmp = 88363052.13662052, tmp))))<<x)<<(tmp = 2232672341, tmp))/((x<<x)&(((((348589117.64135563)<<(-1010050456.3097556))^(x/(tmp = -2282328795, tmp)))-(tmp = 1653716293, tmp))-((3157124731)/((tmp = 3007369535.341745, tmp)%(tmp = -2246556917, tmp)))))))+x))); + assertEquals(0, x >>= ((1935211663.5568764)>>(x-(tmp = 2116580032, tmp)))); + assertEquals(-1725272693, x ^= (tmp = -1725272693, tmp)); + assertEquals(313683, x >>>= (-1782632531.2877684)); + assertEquals(0.009772287443565642, x /= (tmp = 32099240, tmp)); + assertEquals(-647945916.9902277, x += (-647945917)); + assertEquals(3647021380, x >>>= ((((((((2470411371.688199)<<x)>>x)-(x>>>((tmp = 1750747780, tmp)/x)))-x)<<(tmp = -2666186351.695101, tmp))^(((tmp = 2749205312.6666174, tmp)%x)&(2069802830.360536)))<<(tmp = 6051917.9244532585, tmp))); + assertEquals(-647939220, x |= ((x>>>((tmp = -2980404582.794245, tmp)>>>(-996846982)))^x)); + assertEquals(-572178450, x |= ((-800571300.3277931)+(tmp = 2084365671, tmp))); + assertEquals(1172311208, x &= (x&((tmp = -1207487657.8953774, tmp)^x))); + assertEquals(12176516458994, x += ((((tmp = -1534997221, tmp)%(412142731))*((tmp = 2958726303, tmp)>>(1489169839)))+(((-574726407.2051775)>>>(((1772885017)<<(947804536.9958035))>>(-2406844737)))>>x))); + assertEquals(-1480065024, x <<= x); + assertEquals(-1736999042.227129, x += (tmp = -256934018.22712898, tmp)); + assertEquals(-1338699394, x ^= ((((((x%(((tmp = -2551168455.222048, tmp)|(3213507293.930222))/((-1559278033)>>((tmp = 3107774495.3698573, tmp)-(2456375180.8660913)))))*((x*(tmp = 1088820004.8562922, tmp))+((tmp = 1850986704.9836102, tmp)%(tmp = -1226590364, tmp))))*(1786192008))&(((2193303940.310299)%(tmp = 1041726867.0602217, tmp))|((2210722848)/((-1293401295.6714435)&((tmp = 3052430315, tmp)|x)))))>>>(tmp = -2028014470.1524236, tmp))+(((1695818039.0383925)<<((1669068145)*(-2746592133.899276)))<<(tmp = 519092169, tmp)))); + assertEquals(-334674849, x >>= (1170377794)); + assertEquals(-10214, x >>= ((tmp = 1074704264.3712895, tmp)>>>((tmp = -1200860192, tmp)^((tmp = 539325023.4101218, tmp)*((tmp = -588989295, tmp)|x))))); + assertEquals(1384169472, x &= (1384171140)); + assertEquals(1384169472, x >>>= ((tmp = -2161405973.830981, tmp)*(tmp = 2054628644, tmp))); + assertEquals(1610140972, x |= (527961388)); + assertEquals(1073273198, x += ((tmp = -259650225.71344328, tmp)&(tmp = -344359694, tmp))); + assertEquals(65507, x >>= ((x<<((tmp = 2925070713.5245204, tmp)%(x+((tmp = -1229447799, tmp)/(((x/(x|(((-2337139694)|((((((2996268529.7965417)&x)%(((tmp = -1088587413, tmp)>>(-1384104418.90339))>>((tmp = -1643984822.3946526, tmp)+x)))%(((1118125268.4540217)-((((-1975051668.6652594)-(-704573232))+((tmp = 1674952373, tmp)/(tmp = 1321895696.0062659, tmp)))*(tmp = 1820002533.2021284, tmp)))>>>(tmp = -583960746.9993203, tmp)))|((tmp = -2577675508.550925, tmp)&x))/(tmp = 1459790066, tmp)))/(((((1051712301.7804044)&(tmp = -2726396354, tmp))^(tmp = 263937254.18934345, tmp))+(((x^x)*(((tmp = -2289491571, tmp)+x)%(-2239181148)))&x))>>(tmp = -1743418186.3030887, tmp)))))/(tmp = 1475718622, tmp))<<x)))))|(x&((((tmp = -2934707420, tmp)<<x)/x)^(1022527598.7386684))))); + assertEquals(2047, x >>= (x-(tmp = 2300626270, tmp))); + assertEquals(8384512, x <<= (tmp = -1917680820, tmp)); + assertEquals(0, x <<= (2393691134)); + assertEquals(0, x >>= x); + assertEquals(649995936.5853252, x -= (tmp = -649995936.5853252, tmp)); + assertEquals(649995936, x &= x); + assertEquals(-0.33672017582945424, x /= (tmp = -1930374188, tmp)); + assertEquals(-0.33672017582945424, x += (x&((1208055031)^(-2761287670.968586)))); + assertEquals(0, x |= x); + assertEquals(0, x <<= ((-2038368978)/x)); + assertEquals(0, x >>= (x&((tmp = 2481378057.738218, tmp)&(x+(1172701643))))); + assertEquals(0, x <<= ((x*(((((((tmp = 70690601.3046323, tmp)&(((((((((((x+(x+(x^(3118107461))))<<(264682213.41888392))&(tmp = -709415381.8623683, tmp))%(((((-1840054964)>>>(tmp = -405893120.89603686, tmp))|((-625507229)^(3128979265)))>>(x>>((tmp = -2480442390, tmp)*((x>>(tmp = -421414980.88330936, tmp))>>>((tmp = 1850868592, tmp)&(-2948543832.879225))))))|((2986545185)&((tmp = -1947550706, tmp)%(((tmp = 2590238422.1414256, tmp)/(((tmp = -361038812, tmp)>>x)|(((tmp = 1798444068, tmp)|((x&((tmp = -3104542069, tmp)-x))*((tmp = -1158658918, tmp)+((tmp = 2777031040.5552707, tmp)<<(-2816019335.9008327)))))<<x)))/(((2287795988.231702)/x)/(((-2588712925)>>>(2521189250))*((tmp = -2533527920, tmp)+(tmp = 1762281307.2162101, tmp)))))))))/x)/(tmp = 1047121955.5357032, tmp))|(((-121292251)<<(x^(x-(tmp = 1420006180, tmp))))%((-2278606219)>>>(((tmp = -1412487726, tmp)&(((((tmp = 253596554.16016424, tmp)/(tmp = 2083376247.0079951, tmp))^(x^((1549116789.8449988)>>>((((-1844170084)^(tmp = 1886066422, tmp))&x)<<(34918329)))))^(tmp = -440805555.3369155, tmp))-x))%(-1936512969)))))+(2911511178.4035435))|(1012059391))|(x>>>(tmp = -2551794626.158037, tmp)))+((2926596072.210515)/(tmp = -280299595.0450909, tmp))))&((tmp = 1501086971, tmp)^(tmp = 2114076983, tmp)))-((-1679390574.1466925)-(941349044)))-((x>>x)>>((-2600539474.2033434)+(tmp = 2567056503.9079475, tmp))))*(tmp = 1285896052, tmp))%(((tmp = 1191465410.7595167, tmp)>>((tmp = -2857472754, tmp)%x))>>>(((tmp = 1960819627.6552541, tmp)&(-2651207221.127376))*((((-687312743)+((x>>x)<<x))|((((((1549588195)*((tmp = 2733091019, tmp)^((527322540)<<(x>>x))))%(tmp = -2063962943, tmp))*x)*(734060600))&(-3049417708)))+(((((1084267726)+((x|x)^((tmp = -1917070472.4858549, tmp)%((690016078.9375831)*x))))%((((((tmp = -2091172769, tmp)%(2532365378))>>>(-871354260))/(tmp = 254167019.07825458, tmp))&(1330216175.9871218))>>(tmp = 1931099207, tmp)))^(-1116448185.2618852))>>((961660080.8135855)/x)))))))>>>(-1486048007.7053368))); + assertEquals(0, x >>= x); + assertEquals(0, x %= (tmp = -1202200444.6506357, tmp)); + assertEquals(-0, x *= (-527500796.4145117)); + assertEquals(0, x >>= (tmp = -2082822707, tmp)); + assertEquals(0, x *= ((-1882398459.290778)>>>x)); + assertEquals(0, x &= (x/(tmp = -1569332286.392817, tmp))); + assertEquals(-390169607, x |= (-390169607.11600184)); + assertEquals(-780339214, x += x); + assertEquals(-780339214, x %= (2765959073)); + assertEquals(-5954, x >>= (tmp = -1900007055, tmp)); + assertEquals(743563420, x &= ((((-1520146483.5367205)|(-2075330284.3762321))-(tmp = -2263151872, tmp))%(-1264641939.957402))); + assertEquals(1487126840, x += (x>>>(((x+((tmp = -1263274491, tmp)>>>x))&(470419048.0490037))%(tmp = -2642587112, tmp)))); + assertEquals(Infinity, x /= (x^x)); + assertEquals(0, x ^= ((tmp = -1436368543, tmp)+(x/(tmp = -1125415374.3297129, tmp)))); + assertEquals(0, x += x); + assertEquals(0, x <<= x); + assertEquals(0, x &= (tmp = 3101147204.2905564, tmp)); + assertEquals(0, x &= (tmp = 2914487586.606511, tmp)); + assertEquals(0, x += x); + assertEquals(0, x -= (((-1738542908.6138556)&(((x+x)-(tmp = -2801153969, tmp))%(tmp = -1206684064.1477358, tmp)))>>((-2575546469.271897)|(tmp = -2573119106, tmp)))); + assertEquals(-1468808707, x ^= (tmp = -1468808707, tmp)); + assertEquals(1357349882, x <<= (tmp = -2808501087.7003627, tmp)); + assertEquals(-572025862, x |= ((((tmp = -2415486246.573399, tmp)/((tmp = -707895732.4593301, tmp)&x))%((-1960091005.0425267)*(972618070.9166157)))-(1649962343))); + assertEquals(327213586796843100, x *= (x%(1337884626))); + assertEquals(42991616, x &= (-2905576654.1280055)); + assertEquals(-26049289585042860, x *= (-605915571.6557121)); + assertEquals(597809748, x >>= ((362850791.077795)/(tmp = 1222777657.4401796, tmp))); + assertEquals(597809748, x |= x); + assertEquals(770065246, x -= ((-711227660)|(tmp = -508554506, tmp))); + assertEquals(593000483097040500, x *= x); + assertEquals(0, x %= x); + assertEquals(0, x <<= (317862995.456813)); + assertEquals(0, x >>= ((tmp = 2518385735, tmp)+((-2973864605.267604)/(-930953312.718833)))); + assertEquals(1227822411, x ^= (x^(1227822411.8553264))); + assertEquals(1090520320, x &= (x+((((-2100097959)>>(x/(tmp = -2002285068, tmp)))/(-364207954.9242482))-((tmp = 2771293106.7927113, tmp)-(tmp = -847237774, tmp))))); + assertEquals(1090520320, x >>= (((((2439492849)<<((-2932672756.2578926)*((743648426.7224461)+((2942284935)<<((x/(((tmp = 886289462.6565771, tmp)+(-459458622.7475352))>>(tmp = -785521448.4979162, tmp)))|(tmp = -11630282.877367258, tmp))))))-(tmp = -647511106.9602091, tmp))^x)&x)); + assertEquals(115944291.48829031, x %= (243644007.12792742)); + assertEquals(1, x /= x); + assertEquals(0, x >>>= ((tmp = -819782567, tmp)%(tmp = 2774793208.1994505, tmp))); + assertEquals(0, x >>= (tmp = 721096000.2409859, tmp)); + assertEquals(0, x &= ((x%x)%x)); + assertEquals(-0, x *= ((-1670466344)<<x)); + assertEquals(0, x >>= (-677240844.904707)); + assertEquals(NaN, x %= (((((-1575993236.6126876)/(-2846264078.9581823))^((((-2220459664)-(((-1809496020)>>>(tmp = -3015964803.4566207, tmp))&x))/(tmp = -3081895596.0486784, tmp))>>>(x&x)))%(x^(-1338943139)))^(x-((((2074140963.2841332)^(tmp = 1878485274, tmp))%(((x/(-2568856967.6491556))^x)<<((x+x)^((((2139002721)|(x<<(-1356174045.840464)))>>x)-(tmp = 2305062176, tmp)))))>>>(((((x<<(tmp = -1663280319.078543, tmp))-((1498355849.4158854)-((-1321681257)>>>(tmp = -1321415088.6152222, tmp))))^(-2266278142.1584673))+(858538943))&((((x-((x|(((tmp = -1576599651, tmp)+((tmp = 1595319586, tmp)&(-2736785205.9203863)))>>((x+((-1856237826)+x))<<(tmp = -1590561854.3540869, tmp))))^(((-41283672.55606127)&(tmp = 2971132248, tmp))+x)))/(-849371349.1667476))%(x*((-1705070934.6892798)>>>x)))<<((2418200640)*x))))))); + assertEquals(0, x >>>= (tmp = 664214199.5283061, tmp)); + assertEquals(0, x <<= ((-2827299151)<<(1815817649))); + assertEquals(1405772596, x |= (tmp = 1405772596, tmp)); + assertEquals(-1483422104, x <<= (-2791499935.6822596)); + assertEquals(-45271, x >>= (1740128943.4254808)); + assertEquals(-45271, x <<= ((2072269957)-((tmp = -2553664811.4472017, tmp)*(tmp = -2502730352, tmp)))); + assertEquals(1192951471.6745887, x -= (-1192996742.6745887)); + assertEquals(-353370112, x <<= (tmp = -1410280844, tmp)); + assertEquals(0, x ^= (x%((2754092728)*(-1017564599.1094015)))); + assertEquals(-2662096003.2397957, x -= (tmp = 2662096003.2397957, tmp)); + assertEquals(-2587094028.50764, x -= (tmp = -75001974.7321558, tmp)); + assertEquals(6693055512339889000, x *= x); + assertEquals(897526784, x %= (x-((tmp = 897526813, tmp)%(-1525574090)))); + assertEquals(7011928, x >>= ((-440899641.344357)%x)); + assertEquals(8382047686388683, x += (x*(1195398423.8538609))); + assertEquals(16764095372777366, x += x); + assertEquals(16764096859576696, x -= (tmp = -1486799329.7207344, tmp)); + assertEquals(16764099774187724, x += (2914611029)); + assertEquals(16764102926624664, x -= (-3152436939.724612)); + assertEquals(-538220648, x |= x); + assertEquals(269110324, x /= (((-2114698894.6014318)/(tmp = 767687453, tmp))>>(623601568.1558858))); + assertEquals(256, x >>= x); + assertEquals(-293446891, x += (x+(-293447403))); + assertEquals(119, x >>>= ((1759400753)>>(2481263470.4489403))); + assertEquals(14, x >>= (762849027.89693)); + assertEquals(16, x += (x&(x>>(1104537666.1510491)))); + assertEquals(-12499808227.980995, x *= (tmp = -781238014.2488122, tmp)); + assertEquals(1, x /= x); + assertEquals(1, x &= x); + assertEquals(0, x >>>= ((tmp = 1513381008, tmp)|(tmp = 1593208075.7259543, tmp))); + assertEquals(0, x &= (-788154636.2843091)); + assertEquals(-0, x /= (tmp = -2124830879, tmp)); + assertEquals(0, x &= (934237436)); + assertEquals(0, x |= x); + assertEquals(-79370942.97651315, x += (-79370942.97651315)); + assertEquals(-79370942.97651315, x %= ((tmp = -2683255523, tmp)<<(tmp = 2323123280.287587, tmp))); + assertEquals(-79370942, x |= x); + assertEquals(0.05861647801688159, x /= (-1354072177.061561)); + assertEquals(0, x <<= (((((((tmp = 1989257036, tmp)&(tmp = 1565496213.6578887, tmp))&x)&(tmp = -2798643735.905287, tmp))&(2354854813.43784))%(tmp = 1118124748, tmp))<<((tmp = 2453617740, tmp)*(((tmp = 1762604500.492329, tmp)<<(-2865619363))%(((2474193854.640994)|((tmp = 1425847419.6256948, tmp)|(((-1271669386)%((x|((tmp = -2059795445.3607287, tmp)+x))*(x*x)))>>>(tmp = -2997360849.0750895, tmp))))/(tmp = 2326894252, tmp)))))); + assertEquals(0, x >>>= ((-671325215)/((-727408755.8793397)>>(tmp = 315457854, tmp)))); + assertEquals(0, x >>= (x&x)); + assertEquals(0, x <<= ((x/x)>>>(((((x&x)-((x*(((tmp = -2689062497.0087833, tmp)^x)/((-1465906334.9701924)<<(tmp = -349000262, tmp))))*x))%(1630399442.5429945))*x)+((tmp = 605234630, tmp)%(tmp = 2325750892.5065155, tmp))))); + assertEquals(0, x |= (x%((x>>(((((tmp = 1622100459, tmp)<<x)&((((((tmp = 2411490075, tmp)<<x)|x)>>((x<<x)-(-2133780459)))/x)&(x+x)))%(x/((((tmp = 580125125.5035453, tmp)>>>(-470336002.1246581))|((tmp = 871348531, tmp)*x))>>(2866448831.23781))))-((2352334552)-(-562797641.6467373))))-(x^(tmp = -681731388, tmp))))); + assertEquals(0, x <<= (tmp = -1358347010.3729038, tmp)); + assertEquals(-260967814, x |= ((tmp = -260967814.45976686, tmp)%(tmp = 1126020255.1772437, tmp))); + assertEquals(NaN, x %= ((((tmp = 3176388281, tmp)<<(tmp = 611228283.2600244, tmp))>>>((tmp = 3068009824, tmp)+(tmp = 2482705111, tmp)))>>>((tmp = -750778285.2580311, tmp)>>>x))); + assertEquals(0, x <<= (x>>>x)); + assertEquals(0, x /= (1238919162)); + assertEquals(0, x >>= (x^x)); + assertEquals(0, x &= (-2137844801)); + assertEquals(0, x >>>= (x^(x*(-1774217252)))); + assertEquals(0, x >>= x); + assertEquals(0, x |= x); + assertEquals(0, x &= (x<<(tmp = 2791377560, tmp))); + assertEquals(-1330674638.8117397, x += (tmp = -1330674638.8117397, tmp)); + assertEquals(353, x >>>= (-212202857.4320326)); + assertEquals(353, x ^= ((((x+(tmp = 1448262278, tmp))-(-3141272537))>>(tmp = 1116596587.7832575, tmp))>>>((x-(((tmp = 303953098, tmp)>>>((tmp = 691514425, tmp)/((176223098)*(((2876180016)%(-1805235275.892374))|x))))<<(((tmp = 528736141.838547, tmp)^(2556817082))*(2898381286.2846575))))|((-1445518239)&(tmp = 389789481.9604758, tmp))))); + assertEquals(0, x >>>= (-227376461.14343977)); + assertEquals(0, x <<= (tmp = -2575967504, tmp)); + assertEquals(0, x <<= (x^((-2668391896)>>((x+(tmp = 598697235.9205595, tmp))+((((-2105306785)|((-1174912319.794015)>>>(x-((148979923)%((((tmp = -2459140558.4436393, tmp)|(1265905916.494016))^(tmp = 1213922357.2230597, tmp))|(1028030636))))))%x)+(((tmp = 1393280827.0135512, tmp)^((tmp = 1210906638, tmp)+(-1572777641.1396031)))<<x)))))); + assertEquals(0, x *= (tmp = 2134187165, tmp)); + assertEquals(-1084549964, x -= (tmp = 1084549964, tmp)); + assertEquals(-2045706240, x &= ((tmp = -1250758905.7889671, tmp)*(x+(((x<<(x/(tmp = -738983664.845448, tmp)))>>>x)&(tmp = 2197525295, tmp))))); + assertEquals(-2045706240, x ^= (((522049712.14743733)>>(tmp = -2695628092, tmp))>>>(tmp = -2603972068, tmp))); + assertEquals(2249261056, x >>>= x); + assertEquals(-33291, x |= ((((1891467762)<<(184547486.213719))-((458875403.50689447)^(((x&(x*x))|x)%(-3127945140))))|(-100765232))); + assertEquals(-33291, x %= (1460486884.1367688)); + assertEquals(-1, x >>= (tmp = -2667341441, tmp)); + assertEquals(-3.6289151568259606e-10, x /= (tmp = 2755644474.4072013, tmp)); + assertEquals(-3.6289151568259606e-10, x %= (tmp = 1186700893.0751028, tmp)); + assertEquals(0, x <<= (tmp = -1199872107.9612694, tmp)); + assertEquals(371216449, x ^= ((tmp = 371324611.1357789, tmp)&(x-(x|((tmp = -518410357, tmp)>>((tmp = 687379733, tmp)/x)))))); + assertEquals(0.3561383159088311, x /= (((((x%(((((-2293101242)%((((495316779)/x)-((-3198854939.8857965)>>>((tmp = -288916023, tmp)-(x^(tmp = -2504080119.431858, tmp)))))^(-1201674989)))-((2965433901)*(405932927)))/((1974547923)|(tmp = 534069372, tmp)))-(x-((x+(-1258297330))%x))))<<(((-2648166176.4947824)^(-3043930615))&(1550481610)))<<(tmp = -3118264986.743822, tmp))<<x)|x)); + assertEquals(-46272499.15029934, x -= (tmp = 46272499.50643766, tmp)); + assertEquals(-6, x >>= ((tmp = -731454087.0621192, tmp)>>>x)); + assertEquals(-2.7207928474520667e-9, x /= (((x<<(x|((tmp = -1650731700.9540024, tmp)/(tmp = -677823292, tmp))))^((((((1972576122.928667)>>x)%(2952412902.115453))<<((-2888879343)+(tmp = -425663504, tmp)))>>>(((((tmp = 1089969932, tmp)>>>(x|((-2088509661)/(1131470551))))>>>x)+x)|(tmp = 955695979.7982506, tmp)))|(((((tmp = 826954002.6188571, tmp)^(2016485728))|((x/(((x<<(tmp = 2493217141, tmp))/(-2259979800.997408))-(tmp = -427592173.41389966, tmp)))%(((-471172918)/x)>>>((383234436.16425097)&(tmp = 1664411146.5308032, tmp)))))*(tmp = 1863669754.7545495, tmp))*(x>>(2062197604)))))>>>((x-(2624545856))*(tmp = 1025803102, tmp)))); + assertEquals(0, x >>= ((tmp = 1068702028, tmp)*(296106770))); + assertEquals(0, x ^= (x/x)); + assertEquals(85359536, x ^= (((x|(((tmp = 740629227, tmp)<<(-1107397366))%((tmp = 2315368172, tmp)>>(((-2269513683)|(-2698795048))+(-396757976)))))*(929482738.803125))^(((-1415213955.4198723)-(tmp = -2885808324, tmp))>>>((tmp = -472842353.85736656, tmp)&(tmp = 1684231312.4497018, tmp))))); + assertEquals(2075131904, x <<= x); + assertEquals(123, x >>>= (x>>>(tmp = 754093009, tmp))); + assertEquals(0, x >>= ((-2690948145)/((1988638799)+x))); + assertEquals(0, x >>>= (tmp = -798849903.2467625, tmp)); + assertEquals(NaN, x %= x); + assertEquals(NaN, x *= (2431863540.4609756)); + assertEquals(484934656, x |= ((-2322193663)*(tmp = -2754666771, tmp))); + assertEquals(-82505091404694530, x *= (tmp = -170136513, tmp)); + assertEquals(-82505090515370620, x += ((-148762237)&(tmp = 889417717, tmp))); + assertEquals(-908221124, x %= (tmp = -2346393300, tmp)); + assertEquals(-1242515799, x ^= (2083328917)); + assertEquals(-1126056310271520600, x *= ((((tmp = -3065605442, tmp)<<(-3012703413))|x)^(-2081329316.4781387))); + assertEquals(-1126056309941068000, x += ((((tmp = 1886925157, tmp)&((tmp = -163003119.31722307, tmp)/((tmp = 2094816076, tmp)>>((tmp = -706947027, tmp)^x))))^((1819889650.5261197)<<(-1641091933)))>>x)); + assertEquals(-1864360191, x |= (((x/x)|x)|x)); + assertEquals(-1864360191, x &= x); + assertEquals(-3728720382, x += x); + assertEquals(1042663165, x ^= (535165183.4230335)); + assertEquals(2644530017.8833704, x += (1601866852.8833704)); + assertEquals(-574949401, x |= ((tmp = 943193254.5210983, tmp)^((x%(tmp = -2645213497, tmp))*(-1904818769)))); + assertEquals(1763223578, x ^= ((x^(tmp = -2244359016, tmp))^(tmp = 320955522, tmp))); + assertEquals(-1.9640961474334235, x /= (tmp = -897727731.0502782, tmp)); + assertEquals(1, x >>>= (x-(-3183031393.8967886))); + assertEquals(1, x &= (tmp = 1732572051.4196641, tmp)); + assertEquals(1, x >>= (-1642797568)); + assertEquals(-2339115203.3140306, x += (-2339115204.3140306)); + assertEquals(1955852093, x ^= (((((-1469402389)/(-2648643333.1454573))>>>x)<<(x/x))>>x)); + assertEquals(-965322519, x ^= (3001399252)); + assertEquals(-2139727840, x &= (tmp = 2298411812.964484, tmp)); + assertEquals(2103328, x &= (tmp = -2488723009, tmp)); + assertEquals(1799011007, x |= (tmp = -2498057537.226923, tmp)); + assertEquals(1799011007, x |= ((-308193085)>>>x)); + assertEquals(1799011007, x |= x); + assertEquals(818879107, x ^= (1542823996.423564)); + assertEquals(-2601416919234843600, x *= ((-2357923057.076759)-x)); + assertEquals(-2601416920481796600, x -= (x|(tmp = -3048039765, tmp))); + assertEquals(-33690112, x <<= x); + assertEquals(1039491072, x &= (tmp = 1039491474.3389125, tmp)); + assertEquals(126891, x >>= (-3079837011.6151257)); + assertEquals(-163191923097543, x *= (((tmp = -2847221258.4048786, tmp)*(x-(tmp = 1527622853.5925639, tmp)))^x)); + assertEquals(753616551, x ^= (-946895202)); + assertEquals(-347691264, x <<= (tmp = -433184408.33790135, tmp)); + assertEquals(0, x <<= (x|(tmp = -1911731462.6835637, tmp))); + assertEquals(-0, x *= (tmp = -2616154415.1662617, tmp)); + assertEquals(0, x >>= x); + assertEquals(0, x -= x); + assertEquals(0, x *= (2272504250.501526)); + assertEquals(0, x ^= x); + assertEquals(NaN, x %= x); + assertEquals(0, x >>>= (2475346113)); + assertEquals(NaN, x /= (((x+(-2646140897))&(((tmp = 1039073714.142481, tmp)-x)*x))|(x*(((-1277822905.773948)>>(tmp = 2035512354.2400663, tmp))*(77938193.80013895))))); + assertEquals(0, x ^= (x<<(tmp = 2491934268, tmp))); + assertEquals(0, x &= (tmp = 569878335.4607931, tmp)); + assertEquals(-88575883, x ^= ((453890820.8012209)-((1569189876)%((-1280613677.7083852)^(-1902514249.29567))))); + assertEquals(-88575883, x %= (tmp = 257947563.19206762, tmp)); + assertEquals(-88575881.7863678, x -= ((tmp = 1257547359.029678, tmp)/(x^(tmp = 948265672.821815, tmp)))); + assertEquals(-169, x >>= (tmp = -2530523309.6703596, tmp)); + assertEquals(-1, x >>= x); + assertEquals(-1, x |= x); + assertEquals(131071, x >>>= (-673590289)); +} +f(); diff --git a/src/3rdparty/v8/test/mjsunit/numops-fuzz-part3.js b/src/3rdparty/v8/test/mjsunit/numops-fuzz-part3.js new file mode 100644 index 0000000..7813f91 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/numops-fuzz-part3.js @@ -0,0 +1,1178 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +function f() { + var x = 131071; + var tmp = 0; + assertEquals(1117196836, x -= (-1117065765)); + assertEquals(3092236000.7125187, x -= (-1975039164.7125185)); + assertEquals(1, x /= x); + assertEquals(-1599945863, x ^= (tmp = 2695021432.453696, tmp)); + assertEquals(940543782, x ^= (tmp = 2561494111, tmp)); + assertEquals(891400321673221800, x *= (tmp = 947749949.2662871, tmp)); + assertEquals(-1509927296, x >>= ((tmp = 1113290009, tmp)-x)); + assertEquals(-23, x >>= (tmp = 3216989626.7370152, tmp)); + assertEquals(-0, x %= x); + assertEquals(0, x <<= (431687857.15246475)); + assertEquals(-0, x /= (tmp = -1924652745.081665, tmp)); + assertEquals(0, x <<= (1312950547.2179976)); + assertEquals(0, x %= ((tmp = 2110842937.8580878, tmp)|(x<<x))); + assertEquals(0, x >>>= ((((-386879000)-((tmp = -2334036143.9396124, tmp)/((tmp = 965101904.2841234, tmp)<<(((3029227182.8426695)<<((tmp = -464466927, tmp)>>((((((tmp = 849594477.4111787, tmp)^(x&((513950657.6663146)%(x>>>x))))-((2898589263)|x))+(tmp = 2842171258.621288, tmp))>>>(tmp = -3158746843, tmp))<<(tmp = -2891369879, tmp))))-(x-(x&(tmp = -1707413686.2706504, tmp)))))))-(-2860419051))*(-1708418923))); + assertEquals(-328055783, x += ((((2857010474.8010874)|((tmp = -1415997622.320347, tmp)-(-1706423374)))%(tmp = 824357977.1339042, tmp))^(x>>(x|x)))); + assertEquals(-168539902503779140, x *= ((tmp = -1057687018, tmp)<<((1408752963)-(2030056734)))); + assertEquals(-Infinity, x /= ((x-(2232683614.320658))*(((tmp = 195551174, tmp)*((((739595970)>>>(tmp = -2218890946.8788786, tmp))>>>(((tmp = -240716255.22407627, tmp)&(((((1598029916.3478878)|((tmp = -881749732, tmp)+(x>>x)))^(4443059))<<(((tmp = 2453020763, tmp)+((x>>>(tmp = -1904203813, tmp))&(-355424604.49235344)))<<(tmp = 2814696070, tmp)))%((tmp = -250266444, tmp)>>>(((((2710614972)&(((tmp = 910572052.6994087, tmp)^(tmp = -1028443184.3220406, tmp))/((-2718010521)^(tmp = 676361106, tmp))))|x)^(-1326539884))>>(-1573782639.7129154)))))/(tmp = 1923172768, tmp)))>>>(tmp = -2858780232.4886074, tmp)))/((((((-2060319376.353397)%x)>>(tmp = -3122570085.9065285, tmp))/(tmp = -1499018723.8064275, tmp))*((-655257391)<<x))>>x)))); + assertEquals(NaN, x += ((3059633304)%((((tmp = 2538190083, tmp)*((tmp = -2386800763.356364, tmp)/x))&(1341370996))%(-2929765076.078223)))); + assertEquals(NaN, x %= ((x&(347774821))>>>(462318570.2578629))); + assertEquals(NaN, x *= ((2829810152.071517)*(tmp = 768565684.6892327, tmp))); + assertEquals(NaN, x -= x); + assertEquals(0, x >>>= (x&(tmp = 1786182552, tmp))); + assertEquals(973967377, x ^= ((tmp = 2115869489.836838, tmp)&(994956497))); + assertEquals(985246427.4230617, x += (11279050.423061728)); + assertEquals(985246427, x &= x); + assertEquals(0, x >>= ((tmp = 1090502660.1867907, tmp)>>((-1599370623.5747645)-(tmp = -1321550958, tmp)))); + assertEquals(0, x %= (tmp = -2386531950.018572, tmp)); + assertEquals(0, x >>>= x); + assertEquals(NaN, x /= x); + assertEquals(0, x >>>= (tmp = -1535987507.682257, tmp)); + assertEquals(-0, x /= (-2570639987)); + assertEquals(-542895632, x |= (tmp = -542895632, tmp)); + assertEquals(-33930977, x >>= (tmp = -861198108.1147206, tmp)); + assertEquals(-0, x %= x); + assertEquals(0, x ^= (x*(-608154714.1872904))); + assertEquals(-140011520, x |= ((tmp = 377418995, tmp)<<((1989575902)>>(tmp = -2558458031.066773, tmp)))); + assertEquals(-140026048, x -= ((((tmp = 1465272774.7540011, tmp)<<((2164701398)<<(tmp = -818119264, tmp)))>>((tmp = -1490486001, tmp)>>(664410099.6412607)))>>(x>>>(((tmp = -2438272073.2205153, tmp)%(tmp = 2142162105.4572072, tmp))-(tmp = 2259040711.6543813, tmp))))); + assertEquals(39214588236996610, x *= (x<<(-401696127.06632423))); + assertEquals(1, x /= x); + assertEquals(0, x %= x); + assertEquals(0, x *= ((tmp = -1709874807.176726, tmp)&(-2786424611))); + assertEquals(-1320474063.3408537, x += (tmp = -1320474063.3408537, tmp)); + assertEquals(88, x >>>= (tmp = -3179247911.7094674, tmp)); + assertEquals(1606348131, x += ((tmp = 1555621121.5726175, tmp)|(-3026277110.9493155))); + assertEquals(200793516, x >>>= x); + assertEquals(-2952688672.1074514, x -= (tmp = 3153482188.1074514, tmp)); + assertEquals(1342278624, x >>>= ((x>>>((tmp = 1264475713, tmp)-(-913041544)))>>>((tmp = 2008379930, tmp)%(tmp = 3105129336, tmp)))); + assertEquals(0, x ^= x); + assertEquals(0, x /= (tmp = 788363717, tmp)); + assertEquals(430466213, x -= (tmp = -430466213, tmp)); + assertEquals(164757385222499550, x *= (tmp = 382741735, tmp)); + assertEquals(164757385222499550, x %= (((tmp = 1974063648, tmp)%((806015603)>>>x))*((tmp = 2836795324, tmp)<<(tmp = -1785878767, tmp)))); + assertEquals(-190957725.86956096, x /= (x^((-2939333300.066044)-(x|(-2085991826))))); + assertEquals(-190957725.86956096, x %= (tmp = -948386352, tmp)); + assertEquals(0.6457336106922105, x /= (-295722141)); + assertEquals(0, x |= ((415991250)&((x>>(tmp = -3188277823, tmp))<<(511898664.1008285)))); + assertEquals(0, x &= ((793238922)|x)); + assertEquals(-1576701979, x ^= (2718265317)); + assertEquals(-49271937, x >>= x); + assertEquals(-49271937, x |= x); + assertEquals(-49271937, x &= x); + assertEquals(775316382, x -= (-824588319)); + assertEquals(912498176, x <<= (tmp = -2223542776.836312, tmp)); + assertEquals(0, x -= (x&((tmp = 1999412385.1074471, tmp)/(-1628205254)))); + assertEquals(0, x -= x); + assertEquals(0, x >>= (-768730139.7749677)); + assertEquals(-1861304245, x |= (((5128483)^(((tmp = -1768372004, tmp)/(x^(tmp = 1310002444.757094, tmp)))*((tmp = 188242683.09898067, tmp)^(tmp = -2263757432, tmp))))^((tmp = 2223246327, tmp)*((tmp = -2360528979, tmp)-((tmp = 2442334308, tmp)>>(458302081)))))); + assertEquals(1, x /= x); + assertEquals(2, x += x); + assertEquals(1, x /= x); + assertEquals(0, x ^= x); + assertEquals(-0, x *= (-1852374359.3930533)); + assertEquals(0, x <<= (tmp = 1223645195.148961, tmp)); + assertEquals(1789655087, x |= ((-2505312209.770559)>>x)); + assertEquals(-65568768, x <<= x); + assertEquals(4229398528, x >>>= x); + assertEquals(-8408187, x |= (-3029781627)); + assertEquals(-8408187, x |= (((2322165037)-((tmp = -1424506897.362995, tmp)%x))&x)); + assertEquals(-7884926, x += (x>>>(x|(2738095820)))); + assertEquals(-7884926, x %= (576507013)); + assertEquals(751801768, x ^= (tmp = -750241238, tmp)); + assertEquals(-1986010067668600800, x *= (tmp = -2641667195, tmp)); + assertEquals(1921196240, x ^= (x%(-1954178308))); + assertEquals(847388880, x ^= ((tmp = 1632856124, tmp)&((tmp = -1536309755, tmp)<<(tmp = -3158362800, tmp)))); + assertEquals(-469662000.6651099, x += (tmp = -1317050880.6651099, tmp)); + assertEquals(-812358332, x ^= ((-2832480471)>>>(2016495937))); + assertEquals(21, x ^= (((tmp = 1815603134.2513008, tmp)/((tmp = 147415927, tmp)%(-1059701742)))+x)); + assertEquals(-2844409139.792712, x += (tmp = -2844409160.792712, tmp)); + assertEquals(177070, x >>>= x); + assertEquals(0, x %= x); + assertEquals(0, x >>= x); + assertEquals(1459126376, x ^= (tmp = -2835840920, tmp)); + assertEquals(1459126376, x %= (-1462864282)); + assertEquals(0, x >>>= (tmp = 2922724319, tmp)); + assertEquals(338995506, x ^= (338995506.6411549)); + assertEquals(336896258, x &= (2635904967)); + assertEquals(336634112, x -= (x&(tmp = 1659656287, tmp))); + assertEquals(NaN, x %= (x-x)); + assertEquals(NaN, x /= (tmp = -674606200, tmp)); + assertEquals(NaN, x %= ((x|(2788108542))/(x+(tmp = 600941473, tmp)))); + assertEquals(0, x >>>= ((-1858251597.3970242)>>>x)); + assertEquals(1951294747, x |= (tmp = 1951294747, tmp)); + assertEquals(1951294747, x &= x); + assertEquals(-153190625, x |= (-1500095737)); + assertEquals(23467367587890624, x *= x); + assertEquals(346531290.1813514, x /= (((((-513617734.11148167)|x)/((tmp = -2042982150.1170752, tmp)%((x%((x%x)>>>(((-1369980151)&(((922678983)%(x&(tmp = -855337708, tmp)))-((tmp = -2717183760, tmp)>>>((1939904985.4701347)%(((tmp = -2473316858, tmp)&((tmp = -599556221.9046664, tmp)>>((tmp = -6352213, tmp)/x)))&x)))))%x)))/((tmp = -1842773812.8648412, tmp)>>>(((x>>>(tmp = 499774063, tmp))<<(((tmp = -1353532660.5755146, tmp)*(-3070956509))>>(((-905883994.0188017)>>(tmp = -16637173, tmp))<<((tmp = 471668537, tmp)*((tmp = -232036004.26637793, tmp)/x)))))&(tmp = 85227224, tmp))))))>>>(x|(-2528471983)))-((tmp = 1531574803, tmp)+((x>>>x)-(2889291290.158888))))); + assertEquals(-94.42225749399837, x /= (((tmp = 2381634642.1432824, tmp)>>(tmp = -2637618935, tmp))|(2307200473))); + assertEquals(-47, x >>= (1524333345.141235)); + assertEquals(-2.8699253616435082e-8, x /= (1637673252)); + assertEquals(0, x |= x); + assertEquals(1083427040, x += ((-2012055268)<<(tmp = -2192382589.6911573, tmp))); + assertEquals(1083427040, x %= (x*x)); + assertEquals(2694039776, x += ((((-1740065704.9004602)<<(-736392934))%(2781638048.424092))>>>(x&x))); + assertEquals(-1600927520, x |= ((tmp = 2904430054.869525, tmp)*(((1054051883.4751332)*x)*((-939020743)-(tmp = 1636935481.1834455, tmp))))); + assertEquals(-1600927520, x -= (x%x)); + assertEquals(3037584978216498700, x *= (tmp = -1897390694, tmp)); + assertEquals(372598954.1823988, x %= (tmp = 1553763703.5082102, tmp)); + assertEquals(-1476395008, x <<= ((x>>((tmp = 282496335.49494267, tmp)^((-1948623419.6947453)|((((((tmp = -1203306995, tmp)-(-5554612.355098486))>>>(1867254951.4836824))>>x)|(-695777865))/((-59122652.19377303)<<(-609999229.7448442))))))>>(x/(tmp = -1207010654.9993455, tmp)))); + assertEquals(-2.2540185787941605, x /= (((tmp = 1364159859.9199843, tmp)*x)>>x)); + assertEquals(-2, x |= x); + assertEquals(2241824008, x *= ((3174055292.962967)>>(((-2379151623.602476)>>(tmp = -1423760236, tmp))>>(tmp = -522536019.2225733, tmp)))); + assertEquals(-2138158385, x ^= ((x>>((((1316131966.9180691)-((x*x)>>x))>>>x)>>((-2712430284)|(((((x<<(-616185937.6090865))-(((x-(tmp = 2957048661, tmp))<<(tmp = 617564839.888214, tmp))/(x%((tmp = -447175647.9393475, tmp)<<(2203298493.460617)))))-((x&((x<<(914944265))^(((-1294901094)*((tmp = 2512344795, tmp)+((((tmp = -1227572518, tmp)%(1831277766.4920158))*((x|x)^(tmp = 2515415182.6718826, tmp)))*x)))-(961485129))))>>>(tmp = 2079018304, tmp)))>>(tmp = 734028202, tmp))^(554858721.6149715)))))-((tmp = 1312985279.5114603, tmp)^(tmp = 2450817476.179955, tmp)))); + assertEquals(2.759030298237921, x /= (x|(tmp = -775901745.3688724, tmp))); + assertEquals(8, x <<= x); + assertEquals(NaN, x %= (((x&((1792031228.831834)>>(-1174912501)))%(((-2351757750)+(tmp = -2610099430, tmp))*(-2811655968)))*(x&(tmp = -1881632878, tmp)))); + assertEquals(0, x &= ((x*(616116645.7508612))^(2789436828.536846))); + assertEquals(0, x *= x); + assertEquals(35097452, x ^= ((tmp = 1023684579, tmp)%(((x|((tmp = -757953041, tmp)+(772988909)))+(tmp = -2934577578, tmp))>>>((tmp = -1973224283, tmp)>>>((x*(2244818063.270375))|(x-(-716709285))))))); + assertEquals(0.015207441433418992, x /= (2307913014.4056892)); + assertEquals(-5865042.942076175, x -= (5865042.957283616)); + assertEquals(-67719.94207617454, x %= (((1464126615.2493973)+(398302030.0108756))>>>x)); + assertEquals(4294899577, x >>>= (x<<x)); + assertEquals(-1, x >>= (tmp = 607447902, tmp)); + assertEquals(-1, x >>= (3081219749.9119744)); + assertEquals(6.53694303504065e-10, x /= (tmp = -1529767040.4034374, tmp)); + assertEquals(6.53694303504065e-10, x %= ((tmp = 899070650.7190754, tmp)&(tmp = -1101166301, tmp))); + assertEquals(6.53694303504065e-10, x %= (tmp = -2207346460, tmp)); + assertEquals(NaN, x %= (((x&x)>>x)%(((-10980184)+x)&(tmp = -1473044870.4729445, tmp)))); + assertEquals(NaN, x -= x); + assertEquals(-1755985426, x ^= (tmp = 2538981870, tmp)); + assertEquals(-13842, x %= ((((-2258237411.3816605)+(-1325704332.0531585))<<((tmp = -877665450.1877053, tmp)>>(((((2420989037)+(2084279990.6278818))*(-327869571.9348242))+x)^x)))>>>x)); + assertEquals(1, x /= x); + assertEquals(1, x >>= ((2241312290)^(2859250114))); + assertEquals(0, x >>= x); + assertEquals(-1615631756, x |= (-1615631756.1469975)); + assertEquals(-1615631756, x |= x); + assertEquals(-627245056, x <<= ((x*(tmp = -1308330685.5971081, tmp))|(tmp = 1479586158, tmp))); + assertEquals(-627245056, x |= x); + assertEquals(1786953888, x ^= (-1340096352.1839824)); + assertEquals(1668014353, x -= (tmp = 118939535, tmp)); + assertEquals(1, x /= x); + assertEquals(-645681, x ^= ((-1322356629)>>(tmp = 1829870283, tmp))); + assertEquals(-1322354688, x <<= (-794779253)); + assertEquals(-4310084378.672725, x += (-2987729690.6727247)); + assertEquals(-8620168757.34545, x += x); + assertEquals(-8720421, x |= (tmp = -748107877.6417065, tmp)); + assertEquals(-1508858270, x ^= (1500137913)); + assertEquals(-0.825735756765112, x /= (1827289490.1767085)); + assertEquals(1253449509.1742642, x += (((tmp = 1253449509.9576545, tmp)-(((tmp = 2860243975, tmp)+(367947569.85976696))>>(((((530960315)>>>((((x%(tmp = -2203199228, tmp))<<(x*(((tmp = -117302283, tmp)/(x-((2579576936)%(-1225024012))))&(tmp = -2857767500.1967726, tmp))))/((x/((tmp = -166066119, tmp)<<x))|x))>>>x))|(((2771852372)>>(((tmp = -3103692094.1463976, tmp)-(tmp = 2867208546.069278, tmp))>>>(702718610.1963737)))|(tmp = 2680447361, tmp)))>>x)>>(-2006613979.051014))))^((-1665626277.9339101)/(x<<(tmp = 342268763, tmp))))); + assertEquals(1693336701.1742642, x += (tmp = 439887192, tmp)); + assertEquals(0.8479581831275719, x /= ((1171383583)+(((x&x)>>>(51482548.618915915))-(tmp = -825572595.1031849, tmp)))); + assertEquals(28, x |= ((tmp = -2355932919.6737213, tmp)>>(tmp = -2395605638, tmp))); + assertEquals(0, x %= x); + assertEquals(0, x -= x); + assertEquals(0, x <<= (x^((tmp = 2793423893.484949, tmp)*(1585074754.3250475)))); + assertEquals(0, x >>= (x/(x-((957719861.9175875)&(1288527195))))); + assertEquals(0, x >>>= ((-1429196921.4432657)/x)); + assertEquals(-852424225.734199, x -= (tmp = 852424225.734199, tmp)); + assertEquals(-46674433, x |= ((tmp = -2335242963, tmp)*((2135206646.2614377)>>(tmp = 505649511.8292929, tmp)))); + assertEquals(2944662357, x += (tmp = 2991336790, tmp)); + assertEquals(1404, x >>>= (849155189.1503456)); + assertEquals(-846755170, x ^= (tmp = -846753822.4471285, tmp)); + assertEquals(52615, x >>>= ((-517068110)+x)); + assertEquals(1475021859.9916897, x += (tmp = 1474969244.9916897, tmp)); + assertEquals(0, x %= x); + assertEquals(0, x %= ((539583595.8244679)*(tmp = 1469751690.9193692, tmp))); + assertEquals(0, x &= (807524227.2057163)); + assertEquals(NaN, x %= x); + assertEquals(NaN, x -= (x^((tmp = -362481588, tmp)%(2611296227)))); + assertEquals(NaN, x *= x); + assertEquals(0, x >>= ((-2519875630.999908)<<x)); + assertEquals(NaN, x %= x); + assertEquals(NaN, x += (((tmp = 2485209575, tmp)>>(tmp = 2326979823, tmp))%(x-(((-1296334640.7476478)&x)<<x)))); + assertEquals(0, x >>= (((tmp = 1370704131, tmp)^((((tmp = 793217372.7587746, tmp)>>(((-1455696484.109328)|(((((-2186284424.5379324)<<(tmp = 3052914152.254852, tmp))-(x>>(tmp = 3121403408, tmp)))+((778194280)-(((((tmp = 2398957652, tmp)-(x+(((-2592019996.937958)>>((tmp = 1648537981, tmp)>>x))<<(-677436594))))<<(39366669.09012544))|((tmp = 3133808408.9582872, tmp)-(-2987527245.010673)))*x)))|((tmp = -2178662629, tmp)<<x)))^(((tmp = 909652440.3570575, tmp)%(-2572839902.6852217))%(-1879408081))))*(tmp = -2910988598, tmp))&(((x^x)>>(2822040993))|((x*x)^(((1072489842.6785052)|(x-(((464054192.7390214)^x)<<(tmp = -2754448095, tmp))))*((tmp = -1544182396, tmp)/(tmp = -3198554481, tmp)))))))^(tmp = 1946162396.9841106, tmp))); + assertEquals(371272192, x |= (((x^((x-(x/x))&(tmp = 2370429394, tmp)))-(tmp = -403692829, tmp))*(tmp = 2808636109, tmp))); + assertEquals(929786482, x |= ((729966239.8987448)^(x-((tmp = 120127779, tmp)^((tmp = -3088531385, tmp)>>>((x+((tmp = 2364833601, tmp)>>>(((599149090.6666714)>>(tmp = 2838821032, tmp))%(tmp = -662846011, tmp))))-(tmp = 1168491221.1813436, tmp))))))); + assertEquals(-681121542, x += ((-1610909505.998718)^((tmp = -957338882, tmp)>>>(tmp = 1935594133.6531684, tmp)))); + assertEquals(-2147483648, x <<= ((tmp = 15161708, tmp)|(2453975670))); + assertEquals(-2147483648, x >>= x); + assertEquals(0, x <<= (2080486058)); + assertEquals(0, x &= (((x&(tmp = -767821326, tmp))/((tmp = 1877040536, tmp)>>>(tmp = 2378603217.75597, tmp)))*(-1601799835))); + assertEquals(0, x %= (-1820240383)); + assertEquals(1621233920, x ^= ((tmp = 820230232, tmp)*(1727283900))); + assertEquals(1621233920, x |= (x>>>x)); + assertEquals(1621233931, x += ((tmp = 794966194.9011587, tmp)>>(tmp = -597737830.5450518, tmp))); + assertEquals(1621276543, x |= (((x^((2354444886)+(tmp = 685142845.4708651, tmp)))-(tmp = 790204976.9120214, tmp))>>>((((tmp = -2792921939, tmp)/(((((tmp = -80705524, tmp)<<x)-(((((((tmp = 1951577216.379527, tmp)>>>x)%((-529882150)>>>(tmp = -1682409624, tmp)))<<((-42043756.29025769)-(-1803729173.6855814)))/(2937202170.118023))*(tmp = -1998098798.5722106, tmp))*(tmp = -2996229463.904228, tmp)))&x)>>>(-301330643)))/(-2858859382.0050273))-(tmp = 1571854256.0740635, tmp)))); + assertEquals(810638271, x >>>= (x/(1553632833))); + assertEquals(810638271, x <<= (tmp = -1467397440, tmp)); + assertEquals(-2147483648, x <<= x); + assertEquals(871068871, x ^= (tmp = 3018552519, tmp)); + assertEquals(-1073743881, x |= ((tmp = 2294122324.020989, tmp)|(tmp = -1799706842.4493146, tmp))); + assertEquals(-77816868, x += (((-2225296403)&x)>>(tmp = -2667103424.445239, tmp))); + assertEquals(-1215889, x >>= (tmp = 1876107590.8391647, tmp)); + assertEquals(-2431778, x += x); + assertEquals(4292535518, x >>>= (((x>>(-1825580683))/x)%x)); + assertEquals(4292802560, x -= (x|(1492864090))); + assertEquals(0, x -= x); + assertEquals(0, x >>= x); + assertEquals(0, x %= (tmp = 2173121205, tmp)); + assertEquals(0, x *= (x>>x)); + assertEquals(1565261471, x |= ((1565261471.323931)>>>x)); + assertEquals(0, x -= x); + assertEquals(-86980804, x |= (-86980804)); + assertEquals(-698956484, x -= (((((2754713793.1746016)*(((((-1514587465.0698888)>>(tmp = -1307050817, tmp))/(tmp = 2368054667.438519, tmp))*(-1908125943.5714772))<<(x>>>(-357164827.4932244))))+(1257487617))<<(2954979945))&(612330472))); + assertEquals(-1073741824, x <<= x); + assertEquals(54497747, x ^= (-1019244077.098908)); + assertEquals(54501375, x |= (((tmp = 1944912427, tmp)>>>x)%x)); + assertEquals(0, x -= x); + assertEquals(0, x -= x); + assertEquals(-0, x *= (-1748215388)); + assertEquals(0, x >>= x); + assertEquals(0, x >>>= (((tmp = 988769112, tmp)%(tmp = -3133658477, tmp))<<x)); + assertEquals(0, x %= (1685221089.2950323)); + assertEquals(0, x >>>= (x+((793467168)-(tmp = 135877882, tmp)))); + assertEquals(0, x %= ((tmp = -2406801984, tmp)%(tmp = -987618172, tmp))); + assertEquals(0, x *= ((-2943444887.953456)|(tmp = -2327469738.4544783, tmp))); + assertEquals(0, x >>= x); + assertEquals(-145484729.70167828, x += (tmp = -145484729.70167828, tmp)); + assertEquals(1140855872, x &= (x^(tmp = 3151437967.965556, tmp))); + assertEquals(1486808408, x += (tmp = 345952536, tmp)); + assertEquals(107846582.36594129, x %= (-1378961825.6340587)); + assertEquals(-642031616, x <<= (x+x)); + assertEquals(151747770.95108718, x *= (x/(tmp = 2716379907, tmp))); + assertEquals(192723456, x <<= (tmp = -1731167384, tmp)); + assertEquals(2151208003, x -= ((-2151208003)+x)); + assertEquals(1, x /= x); + assertEquals(1, x |= x); + assertEquals(1996766603, x |= (1996766602)); + assertEquals(895606123, x ^= (tmp = 1113972960.966081, tmp)); + assertEquals(-1500036886, x ^= (tmp = 2482412929, tmp)); + assertEquals(-1542644247, x ^= (x>>>((tmp = 51449105, tmp)>>>(((-2057313176)*x)/(-1768119916))))); + assertEquals(-1496074063273093600, x *= ((tmp = 786152274, tmp)^(387292498))); + assertEquals(-794329073, x %= (((tmp = -2314637675.617696, tmp)*((((x*(411053423.29070306))-(2889448433.4240828))/((-970630131)/(tmp = -2886607600.7423067, tmp)))<<(tmp = 1263617112.9362245, tmp)))|(2816980223.8209996))); + assertEquals(2468008436047106600, x *= (tmp = -3107035257.725115, tmp)); + assertEquals(3040956928, x >>>= ((tmp = 1514372119.1787262, tmp)*(3169809008))); + assertEquals(-19, x >>= (tmp = -266966022.10604453, tmp)); + assertEquals(-1.6505580654964654e-8, x /= ((-3143841480)>>(x-x))); + assertEquals(-2.2420284729165577e-7, x *= (x*((((703414102.2523813)%(tmp = 2989948152, tmp))-((-1583401827.2949386)^((tmp = -1916731338, tmp)%((331500653.3566053)|(((tmp = 29865940, tmp)+((tmp = -2294889418.6764183, tmp)<<(tmp = -1558629267.255229, tmp)))>>>(x*(x+x)))))))|((988977957)&(-2986790281))))); + assertEquals(0, x ^= (x/(tmp = 781117823.345541, tmp))); + assertEquals(NaN, x *= (((x^((((tmp = -2969290335, tmp)+(((((tmp = -175387021, tmp)&(tmp = -1080807973, tmp))<<(tmp = -2395571076.6876855, tmp))|((tmp = -1775289899.4106793, tmp)^x))|(-2963463918)))*(tmp = -1761443911, tmp))^(tmp = 847135725, tmp)))<<((146689636)<<x))%x)); + assertEquals(0, x ^= x); + assertEquals(1720182184, x -= (((tmp = 3184020508, tmp)|((-489485703)+(tmp = -2644503573, tmp)))&(tmp = 2575055579.6375213, tmp))); + assertEquals(1720182184, x >>= (x<<(-45408034))); + assertEquals(5.759243187540471e+27, x *= (((x&(1456298805))+(x<<(106573181)))*((566861317.2877743)+(2262937360.3733215)))); + assertEquals(5.759243187540471e+27, x -= (tmp = -1365873935, tmp)); + assertEquals(0, x <<= x); + assertEquals(0, x >>= (1960073319.3465362)); + assertEquals(0, x <<= x); + assertEquals(560463904, x += ((tmp = 1844076589.9286406, tmp)&((((((-691675777.5800121)|(-745631201))|x)+(tmp = 1504458593.2843904, tmp))-x)<<x))); + assertEquals(-513210271, x -= (x|(1052702623.7761713))); + assertEquals(3781757025, x >>>= ((-1346666404.362477)*(tmp = 2798191459, tmp))); + assertEquals(1080100929, x &= (1122097879.882534)); + assertEquals(1276833905.8093092, x *= ((1276833905.8093092)/x)); + assertEquals(1276833905.8093092, x %= (1796226525.7152414)); + assertEquals(1276833905, x <<= (((tmp = -491205007.83412814, tmp)*(tmp = 1496201476.496839, tmp))>>(x+((tmp = -854043282.114594, tmp)-((x|(tmp = -807842056, tmp))*x))))); + assertEquals(1276833905, x %= (((-1870099318)>>>(((tmp = -2689717222, tmp)/(248095232))/(tmp = 1036728800.5566598, tmp)))&(((((857866837)>>(tmp = 3034825801.740485, tmp))|(-1676371984))>>>(x<<x))%((-3035366571.0221004)*(1578324367.8819473))))); + assertEquals(1, x /= x); + assertEquals(2819223656.189109, x += (2819223655.189109)); + assertEquals(-1475743640, x >>= (((tmp = 2586723314.38089, tmp)/(x&(tmp = -697978283.9961061, tmp)))<<(x%((-1167534676)>>(x^((tmp = -284763535, tmp)*((x%x)&((((tmp = 2916973220.726839, tmp)%x)/(tmp = -1338421209.0621986, tmp))|((tmp = -834710536.803335, tmp)%x))))))))); + assertEquals(-3267683406, x -= (tmp = 1791939766, tmp)); + assertEquals(-2090420900700614100, x *= (639725653)); + assertEquals(-1540353536, x %= ((-1800269105)<<((((x&(((tmp = 1135087416.3945065, tmp)^(613708290))>>x))>>(tmp = -1234604858.7683473, tmp))^(2404822882.7666225))>>>((tmp = -287205516, tmp)-((1648853730.1462333)^((x+(x%((tmp = 359176339, tmp)%((2856479172)<<(tmp = -1995209313, tmp)))))^(((tmp = 2857919171.839304, tmp)>>>(tmp = 2779498870, tmp))>>x))))))); + assertEquals(-2093767030, x ^= (654554250.498078)); + assertEquals(1, x >>>= ((tmp = -166296226.12181997, tmp)^(x/x))); + assertEquals(-1487427474, x -= ((x<<x)|(1487427475.4063978))); + assertEquals(-1487427470.562726, x += ((-1226399959.8267038)/((tmp = 2172365551, tmp)<<x))); + assertEquals(-3457859227618939400, x *= (tmp = 2324724597.3686075, tmp)); + assertEquals(396221312, x >>= (-1354035390)); + assertEquals(0, x %= x); + assertEquals(0, x &= (tmp = 2733387603, tmp)); + assertEquals(1485905453, x |= ((((tmp = -1321532329.304437, tmp)&((((tmp = 1817382709.4180388, tmp)%(((tmp = 2089156555.7749293, tmp)-(-1555460267))|(tmp = 717392475.9986715, tmp)))%(tmp = 1976713214, tmp))^x))>>>x)+(tmp = -2812404197.002721, tmp))); + assertEquals(1485905453, x |= x); + assertEquals(-997658264, x <<= (-1409757949.6038744)); + assertEquals(-997657290, x -= ((-2041106361)>>(tmp = -2014750507, tmp))); + assertEquals(-2138512124, x &= (tmp = 2565597060, tmp)); + assertEquals(8422400, x &= ((-2819342693.5172367)*(tmp = 1441722560, tmp))); + assertEquals(111816531.81703067, x -= (-103394131.81703067)); + assertEquals(59606682.673836395, x *= ((tmp = -1451690098, tmp)/(x-(2835050651.717734)))); + assertEquals(-119213365.34767279, x *= (x|((-2656365050)/((-66180492)+(tmp = 284225706.32323086, tmp))))); + assertEquals(-232839, x >>= (1694344809.435083)); + assertEquals(-1, x >>= x); + assertEquals(1, x *= x); + assertEquals(1, x |= x); + assertEquals(0, x >>= (tmp = 397239268, tmp)); + assertEquals(-1525784563, x -= (tmp = 1525784563, tmp)); + assertEquals(-153.62740888512675, x /= (((tmp = -2040622579.5354173, tmp)*(tmp = -1149025861.549324, tmp))%(((tmp = 2981701364.0073133, tmp)*(tmp = 2993366361, tmp))|(x|(tmp = 1800299979, tmp))))); + assertEquals(-1671795135, x &= (-1671795135.6173766)); + assertEquals(-4253, x |= ((((x*((1533721762.8796673)<<((tmp = 1026164775.0081646, tmp)<<x)))<<(((x-((((x>>((((((tmp = -481536070.7067797, tmp)&(tmp = 1663121016, tmp))>>>(-2974733313.5449667))+(tmp = -493019653, tmp))>>x)&(tmp = 879307404.8600142, tmp)))>>>x)%(x-(tmp = -1806412445.788453, tmp)))%x))<<(x<<(x+x)))+x))>>((tmp = -332473688.28477216, tmp)<<((tmp = 1701065928, tmp)+(((((tmp = -2407330783, tmp)+x)-((tmp = 584100783, tmp)%(tmp = -3077106506, tmp)))^x)>>x))))<<x)); + assertEquals(-0, x %= x); + assertEquals(0, x >>>= x); + assertEquals(0, x >>>= (1578470476.6074834)); + assertEquals(0, x >>>= (974609751)); + assertEquals(-120, x += (x-((tmp = -245718438.0842378, tmp)>>>(tmp = -1870354951, tmp)))); + assertEquals(-6.134465505515781e-8, x /= (1956160645)); + assertEquals(-0, x %= x); + assertEquals(0, x *= (tmp = -399718472.70049024, tmp)); + assertEquals(-1803198769.8413258, x += (-1803198769.8413258)); + assertEquals(988624943, x ^= ((((tmp = 320776739.5608537, tmp)*(((tmp = -983452570.3150327, tmp)^x)&(tmp = -3181597938, tmp)))-(tmp = -1367913740.9036021, tmp))/(((tmp = -535854933.2943456, tmp)-(717666905.8122432))>>>(((((x^(tmp = 380453258.60062766, tmp))^(tmp = -1242333929, tmp))/((tmp = 1072416261, tmp)+(((2090466933)*(x*(tmp = -386283072, tmp)))|((tmp = 789259942, tmp)<<(tmp = -1475723636.1901488, tmp)))))>>>x)%((x>>(tmp = -1243048658.3818703, tmp))|((((((tmp = -619553509, tmp)|x)/(878117279.285609))|((x<<(x>>>(tmp = -749568437.7390883, tmp)))*x))/(tmp = 1674804407, tmp))-(x*(tmp = 1528620873, tmp)))))))); + assertEquals(988625135, x |= (x>>>(tmp = 2402222006, tmp))); + assertEquals(988625135, x %= (-2691094165.990094)); + assertEquals(0, x %= x); + assertEquals(-0, x *= (tmp = -1409904262, tmp)); + assertEquals(-0, x /= ((1176483512.8626208)<<x)); + assertEquals(0, x &= ((((1677892713.6240005)^(tmp = 2575724881, tmp))^(tmp = -2935655281.208194, tmp))*(216675668))); + assertEquals(0, x >>= (tmp = -1296960457, tmp)); + assertEquals(0, x |= x); + assertEquals(NaN, x /= x); + assertEquals(0, x <<= (x>>(-3127984289.9112387))); + assertEquals(0, x %= ((tmp = 190018725.45957255, tmp)<<((x>>>x)/x))); + assertEquals(0, x /= (1185681972)); + assertEquals(0, x &= ((tmp = -1285574617, tmp)>>x)); + assertEquals(0, x >>>= ((tmp = 2498246277.2054763, tmp)+(((tmp = 924534435, tmp)&x)>>(tmp = 1379755429, tmp)))); + assertEquals(0, x -= x); + assertEquals(0, x /= (3093439341)); + assertEquals(0, x *= (x>>>x)); + assertEquals(0, x &= (tmp = 551328367, tmp)); + assertEquals(-0, x /= (-3153411714.834353)); + assertEquals(1217585288, x ^= (tmp = -3077382008.637764, tmp)); + assertEquals(-639702017, x |= ((tmp = -640922633, tmp)%(tmp = -879654762, tmp))); + assertEquals(-1645297680, x <<= (tmp = 1418982820.8182912, tmp)); + assertEquals(-1.4059558868398736, x /= (1170234212.4674253)); + assertEquals(-2650856935.66554, x *= (1885448157)); + assertEquals(1326259953.26931, x *= (((x>>(x|(-496195134.78045774)))+((2029515886)%(tmp = 1148955580, tmp)))/(tmp = -1760016519, tmp))); + assertEquals(0, x &= (((((-273334205)+(tmp = 797224093.682485, tmp))/x)>>>((((tmp = -887577414, tmp)/x)+x)%(tmp = 720417467, tmp)))^(((x-(tmp = -309071035, tmp))>>(-3123114729.33889))/x))); + assertEquals(0, x ^= x); + assertEquals(0, x %= ((tmp = -2243857462, tmp)/((((((2642220700.6673346)&x)*(tmp = 1454878837, tmp))|((-25825087.30002737)%(851535616.3479034)))<<(tmp = -697581582, tmp))%(tmp = 2248990486, tmp)))); + assertEquals(0, x >>= (((x|(((tmp = -220437911, tmp)&((((255690498)*(((2993252642)>>>(tmp = 300426048.0338713, tmp))>>x))&((-364232989)+(x<<(-1824069275))))%(x+(tmp = 2696406059.026349, tmp))))+((tmp = 2911683270, tmp)/(tmp = 2718991915, tmp))))*(x/(((tmp = -982851060.0744538, tmp)^((-2903383954)<<((-85365803.80553412)^x)))%(1489258330.5730634))))>>>x)); + assertEquals(0.7805921633088815, x += (((-1886920875)/(-2417294156.5304217))%(tmp = -1176793645.8923106, tmp))); + assertEquals(0, x <<= x); + assertEquals(-2215008905, x -= (2215008905)); + assertEquals(1931542900, x &= (-215923724.72133207)); + assertEquals(907191462, x ^= (-3133954606.357727)); + assertEquals(453595731, x >>>= (((tmp = 2726241550, tmp)/(tmp = -332682163, tmp))*((((tmp = 2500467531, tmp)>>>(((x<<(tmp = -1847200310.4863105, tmp))/x)^x))+x)<<(191688342.22953415)))); + assertEquals(-0.21671182880645923, x /= ((((-1169180683.1316955)%x)>>>(1650525418))^((2198033206.797462)&((-6913973.910871983)%(1758398541.8440342))))); + assertEquals(-375102237.1603561, x += (tmp = -375102236.9436443, tmp)); + assertEquals(1, x &= (((84374105.89811504)|((tmp = -2480295008.926951, tmp)>>((605043461)>>(tmp = -2495122811, tmp))))>>(-2129266088))); + assertEquals(1, x |= x); + assertEquals(0.0000024171579540208214, x /= (((-2600416098)>>(-2076954196))^x)); + assertEquals(0.0000024171579540208214, x %= (tmp = -2632420148.815531, tmp)); + assertEquals(1809220936.0126908, x -= (-1809220936.0126884)); + assertEquals(1682452118.2686126, x += (((2358977542)<<(x/(tmp = -2862107929, tmp)))+(x+(x%((-3101674407)/(((x*((x>>(tmp = 630458691.3736696, tmp))>>>(tmp = -852137742, tmp)))/x)-((-1875892391.1022017)&(tmp = -1027359748.9533749, tmp)))))))); + assertEquals(1682452118, x <<= (((tmp = -80832958.07816291, tmp)>>x)%(x-((x^(x<<(tmp = -156565345, tmp)))|((tmp = -1208807363.727137, tmp)/(tmp = 2614737513.304538, tmp)))))); + assertEquals(6572078, x >>= (-1573364824)); + assertEquals(13144156, x += x); + assertEquals(1731678184, x ^= ((tmp = 593370804.9985657, tmp)|(-3124896848.53273))); + assertEquals(845545, x >>>= (tmp = -605637621.2299933, tmp)); + assertEquals(-1383361088, x ^= (tmp = -1383632087, tmp)); + assertEquals(-82545896480031520, x += ((x+(1023183845.7316296))*((((tmp = 576673669, tmp)>>(((-584800080.1625061)/(2388147521.9174623))+((((x>>>(-905032341.5830328))^(tmp = -2170356357, tmp))-x)+((136459319)+(-1799824119.689473)))))|x)&(tmp = -2688743506.0257063, tmp)))); + assertEquals(-895206176, x |= x); + assertEquals(-0, x %= x); + assertEquals(1791306023, x ^= ((tmp = -3219480856, tmp)+(tmp = 715819582.0181161, tmp))); + assertEquals(1791306023, x &= x); + assertEquals(2725167636753240600, x *= (1521330025)); + assertEquals(-281190679, x |= (tmp = -1422045975.798171, tmp)); + assertEquals(-281190679, x += (x%x)); + assertEquals(-2342097426.906673, x -= (tmp = 2060906747.906673, tmp)); + assertEquals(-4651462701.906673, x -= (2309365275)); + assertEquals(1878, x >>>= (2544974549.345834)); + assertEquals(1964, x += (x&((1067649861)>>(182139255.7513579)))); + assertEquals(2209, x += (x>>(tmp = -1775039165, tmp))); + assertEquals(0, x -= x); + assertEquals(-0, x /= (tmp = -1634697185, tmp)); + assertEquals(NaN, x /= x); + assertEquals(0, x >>>= ((tmp = 3075747652, tmp)&(tmp = 819236484, tmp))); + assertEquals(0, x /= ((1276203810.476657)%(-2434960500.784484))); + assertEquals(0, x >>>= (tmp = -503633649, tmp)); + assertEquals(-982731931, x |= (-982731931)); + assertEquals(-1965463862, x += x); + assertEquals(-0.221469672913716, x %= ((tmp = -1742292120, tmp)/x)); + assertEquals(-0.221469672913716, x %= (-2021391941.1839576)); + assertEquals(0, x <<= (((((tmp = -2802447851, tmp)>>((2534456072.6518855)&x))%(tmp = 2841162496.610816, tmp))<<((89341820)/(2565367990.0552235)))>>(tmp = 2700250984.4830647, tmp))); + assertEquals(0, x >>= x); + assertEquals(0, x >>= ((tmp = -636189745, tmp)>>>(x/(((tmp = 2634252476, tmp)%(2026595795))>>(tmp = -2048078394.743723, tmp))))); + assertEquals(NaN, x %= ((x%((((x%((tmp = -2583207106, tmp)&x))|(190357769))<<(tmp = 595856931.2599536, tmp))%x))*((-2433186614.6715775)<<((2856869562.1088696)^(tmp = 1112328003, tmp))))); + assertEquals(1621713910, x |= (tmp = 1621713910.0282416, tmp)); + assertEquals(3243427820, x += x); + assertEquals(0, x *= (x&(x-x))); + assertEquals(0, x >>>= (((2871235439)<<((x+((tmp = -1319445828.9659343, tmp)+(tmp = 1595655077.959171, tmp)))>>(tmp = -86333903, tmp)))-(x/(2907174373.268768)))); + assertEquals(0, x >>= (-1091774077.2173789)); + assertEquals(NaN, x /= x); + assertEquals(NaN, x *= (tmp = 1976023677.7015994, tmp)); + assertEquals(NaN, x -= (-3013707698)); + assertEquals(NaN, x += ((x+(((tmp = -3119865782.9691515, tmp)<<(1327383504.0158405))^(((-143382411.7239611)>>>((-2157016781)+(((-335815848)/x)<<(tmp = 1953515427, tmp))))&(-2715729178))))/(413738158.2334299))); + assertEquals(NaN, x %= x); + assertEquals(NaN, x += (-845480493)); + assertEquals(-789816013, x |= (tmp = -789816013.129916, tmp)); + assertEquals(0, x ^= x); + assertEquals(0, x <<= (3032573320)); + assertEquals(47630, x ^= ((1086705488)%((x^(tmp = -1610832418, tmp))>>>(tmp = 1136352558, tmp)))); + assertEquals(47630, x >>= (tmp = 1035320352.4269229, tmp)); + assertEquals(47630, x >>= ((((x^x)<<(x*((((x&((-1657468419)*((tmp = -674435523, tmp)&((tmp = 2992300334, tmp)|x))))*((tmp = -489509378.31950426, tmp)*(tmp = 2276316053, tmp)))>>>x)<<x)))%(tmp = -1209988989, tmp))/(tmp = -2080515253.3541622, tmp))); + assertEquals(3192518951.8129544, x += (3192471321.8129544)); + assertEquals(648116457.8129544, x %= (-2544402494)); + assertEquals(0, x -= x); + assertEquals(NaN, x /= x); + assertEquals(NaN, x /= x); + assertEquals(0, x <<= x); + assertEquals(0, x >>= x); + assertEquals(0, x *= (tmp = 30051865, tmp)); + assertEquals(0, x ^= ((x&(((x&x)>>>(((((((x+(2319551861.0414495))>>>(tmp = -3099624461, tmp))^((((tmp = 1574312763, tmp)|x)>>>((-2723797246)&(tmp = -1993956152, tmp)))|(-1830179045)))|(((((((-2545698704.3662167)>>>x)-(((-79478653)|x)%(x+(x>>((tmp = 2386405508.2180576, tmp)/x)))))>>((((-1947911815.2808042)*((x+(368522081.2884482))-(tmp = 2452991210, tmp)))>>(343556643.1123545))>>((((tmp = 1869261547.537739, tmp)>>(3193214755))|x)&(x*(2027025120)))))<<((-1149196187)>>>(814378291.8374172)))+((((((((-160721403)/(2079201480.2186408))+((x|((((tmp = -299595483.16805863, tmp)>>>((x|((x+x)/(-2359032023.9366207)))<<(tmp = -3095108545, tmp)))>>((tmp = -1547963617.9087071, tmp)*(x>>x)))&((tmp = -1568186648.7499216, tmp)+(((2646528453)^(-2004832723.0506048))>>>(tmp = -3188715603.921877, tmp)))))+(tmp = 1578824724, tmp)))^x)^x)/(tmp = -985331362, tmp))|(tmp = 445135036, tmp))<<(tmp = -73386074.43413758, tmp)))+(((-1674995105.9837937)-(tmp = 1392915573, tmp))>>x)))%(tmp = 1215953864, tmp))&((tmp = -439264643.5238693, tmp)>>>x))+(((tmp = 2311895902, tmp)|(1604405793.6399229))&(tmp = -565192829, tmp))))-x))>>(-2455985321))); + assertEquals(0, x %= ((1177798817)>>(tmp = 2081394163.5420477, tmp))); + assertEquals(0, x >>>= ((x^(tmp = -41947528.33954811, tmp))>>(x>>>((tmp = 1367644771, tmp)+x)))); + assertEquals(0, x %= ((x+((tmp = 163275724, tmp)<<((tmp = -514460883.3040788, tmp)+x)))|(tmp = -287112073.2482593, tmp))); + assertEquals(0, x &= (3067975906)); + assertEquals(201342051, x |= (tmp = 201342051, tmp)); + assertEquals(0, x %= (((((-2580351108.8990865)<<(tmp = 2675329316, tmp))&((1338398946)%((-1548041558)+((x>>(-1568233868.7366815))|((x>>((tmp = -1064582207, tmp)/(-1062237014)))>>(tmp = 854123209, tmp))))))<<(((989032887)*(1842748656))%(tmp = -1566983130, tmp)))-x)); + assertEquals(-0, x /= (tmp = -828519512.617768, tmp)); + assertEquals(0, x &= ((((1449608518)+(-1829731972))*(1828894311))*(((tmp = -1121326205.614264, tmp)^(-2057547855))<<(tmp = -2758835896, tmp)))); + assertEquals(NaN, x %= ((tmp = -2138671333, tmp)%x)); + assertEquals(0, x &= x); + assertEquals(665568613.0328879, x += (665568613.0328879)); + assertEquals(317, x >>= (2627267349.735873)); + assertEquals(0, x -= x); + assertEquals(0, x &= (((tmp = 3030611035, tmp)*(((tmp = 476143340.933007, tmp)>>(x-(2238302130.2331467)))|(x|x)))%(tmp = 320526262, tmp))); + assertEquals(0, x <<= (tmp = 729401206, tmp)); + assertEquals(0, x >>>= (1721412276)); + assertEquals(217629949.3530736, x += ((tmp = 217629949.3530736, tmp)%((-931931100.601475)%(x^(tmp = -2149340123.548764, tmp))))); + assertEquals(217629949.3530736, x %= (tmp = 2275384959.4243402, tmp)); + assertEquals(0, x >>>= (1112677437.5524077)); + assertEquals(0, x *= (500256656.7476063)); + assertEquals(0, x >>>= x); + assertEquals(0, x -= x); + assertEquals(0, x -= x); + assertEquals(0, x &= (-1076968794)); + assertEquals(0, x /= (tmp = 1774420931.0082943, tmp)); + assertEquals(0, x |= x); + assertEquals(0, x >>= x); + assertEquals(0, x %= (-2978890122.943079)); + assertEquals(-0, x /= (tmp = -2954608787, tmp)); + assertEquals(-800048201, x ^= ((tmp = -800048201.7227018, tmp)>>>((-2016227566.1480863)/(tmp = -2263395521, tmp)))); + assertEquals(3333, x >>>= (-2038839052)); + assertEquals(487957736.625432, x += (487954403.625432)); + assertEquals(-1650983426, x |= (2643918270)); + assertEquals(-1861867448, x &= (tmp = -251254199.12813115, tmp)); + assertEquals(-7.934314690172143e-18, x %= ((((x^(-703896560.6519544))>>(tmp = -1853262409, tmp))/(tmp = -1168012152.177894, tmp))/(tmp = 837616075.1097361, tmp))); + assertEquals(0, x ^= x); + assertEquals(0, x &= (tmp = -2328150260.5399947, tmp)); + assertEquals(-1954860020, x |= (tmp = 2340107276, tmp)); + assertEquals(-1954860020, x >>= ((tmp = 159177341, tmp)*(x&(-705832619)))); + assertEquals(-1954895727, x -= (x>>>((-1443742544.7183702)^((((tmp = 869581714.0137681, tmp)+x)^((x%(tmp = -1036566362.5189383, tmp))^(x%x)))>>x)))); + assertEquals(1.0241361338078498, x /= (tmp = -1908824093.2692068, tmp)); + assertEquals(16777216, x <<= (x*(((-1925197281)^(tmp = -1392300089.4750946, tmp))|x))); + assertEquals(-225882765524992, x *= (tmp = -13463662, tmp)); + assertEquals(-1845493760, x |= x); + assertEquals(-1845493760, x %= (tmp = 3181618519.786825, tmp)); + assertEquals(0, x ^= x); + assertEquals(0, x <<= x); + assertEquals(0, x >>>= x); + assertEquals(NaN, x /= (x>>>x)); + assertEquals(NaN, x %= (((((tmp = -521176477, tmp)>>(((tmp = 370693623, tmp)/(((tmp = -1181033022.4136918, tmp)>>(x|(x*(2601660441))))+(tmp = -1696992780, tmp)))|(x|(-1197454193.198036))))>>>(((2512453418.3855605)+((((((tmp = 799501914, tmp)&(((1788580469.7069902)*(((((1476778529.5109258)<<(tmp = -1873387738.3541565, tmp))-((tmp = -521988584.7945764, tmp)*(-1598785351.3914914)))&(-1899161721.8061454))&((x/x)*(690506460))))>>>((tmp = 2255896398.840741, tmp)>>((tmp = -1331486014.6180065, tmp)+(-1159698058.534132)))))*((1112115365.2633948)&((x>>((x>>(-784426389.4693215))&(-492064338.97227573)))>>x)))^((x-((tmp = 2986028023, tmp)>>(tmp = 2347380320.00517, tmp)))*(tmp = -1463851121, tmp)))*(tmp = -1059437133, tmp))%(x-(tmp = 1238739493.7636225, tmp))))^(2029235174)))*(-1923899530))>>>x)); + assertEquals(0, x >>>= (2848792983.510682)); + assertEquals(0, x >>= (((tmp = 3042817032.705198, tmp)>>>x)&((((tmp = -829389221, tmp)-((2669682285.8576303)+(tmp = 1812236814.3082042, tmp)))^x)%((tmp = -2401726554, tmp)^((tmp = 2464685683, tmp)|(-2685039620.224061)))))); + assertEquals(2069649722, x |= (2069649722.311271)); + assertEquals(NaN, x %= (((((-68757739.39282179)&(-1382816369))/(3122326124))<<(x-(-507995800.3369653)))<<(((-1962768567.343907)+((tmp = 1357057125, tmp)/x))^(tmp = 1997617124, tmp)))); + assertEquals(NaN, x += x); + assertEquals(0, x >>= (26895919)); + assertEquals(0, x >>>= x); + assertEquals(0, x %= (tmp = 1092448030, tmp)); + assertEquals(0, x <<= (tmp = -477672441.46258235, tmp)); + assertEquals(0, x /= (2113701907)); + assertEquals(0, x >>>= x); + assertEquals(NaN, x /= x); + assertEquals(1341078673, x |= (-2953888623)); + assertEquals(1341078673, x &= x); + assertEquals(0, x %= x); + assertEquals(414817852.151006, x -= (-414817852.151006)); + assertEquals(1006632960, x <<= ((((((126465614.8316778)+(x-(2511803375)))+(tmp = 1620717148.352402, tmp))*x)/(tmp = -3013745105.5275207, tmp))-((tmp = -418034061.6865432, tmp)/(-300492911)))); + assertEquals(1055624813, x |= (tmp = 921407085, tmp)); + assertEquals(-3, x |= ((((tmp = 1382397819.7507677, tmp)+(tmp = -111851147.7289567, tmp))+x)/((tmp = 247980405.7238742, tmp)^(tmp = -592156399.8577058, tmp)))); + assertEquals(35161, x &= (((((((-2973570544.725141)*(tmp = -1244715638, tmp))+x)<<(x/((x>>>(-2143371615.073137))/(226072236))))%((x-(tmp = 1971392936, tmp))^(tmp = 2653103658, tmp)))%((tmp = 2828319571.7066674, tmp)>>((1528970502)^((tmp = -55869558, tmp)%x))))>>(889380585.6738582))); + assertEquals(0, x ^= x); + assertEquals(0, x *= (2749718750)); + assertEquals(0, x >>>= ((((-1633495402.6252813)*(tmp = 2943656739.1108646, tmp))+(tmp = 977432165, tmp))&((tmp = -2338132019, tmp)*(408176349.8061733)))); + assertEquals(-1778794752, x -= (((tmp = -1391412154.5199084, tmp)-((-3172342474)|x))&(1854366052))); + assertEquals(-1778794752, x %= (tmp = 2024807296.6901965, tmp)); + assertEquals(-1114410.466337204, x %= ((tmp = -240344444.24487805, tmp)%(-47661164))); + assertEquals(-0, x %= x); + assertEquals(0, x >>= (x>>x)); + assertEquals(0, x *= x); + assertEquals(0, x /= ((-3134902611)|(tmp = -3131158951, tmp))); + assertEquals(-0, x /= (((tmp = 1430247610.634234, tmp)&x)+((tmp = -2047191110.8623483, tmp)-((((x%((((x/(tmp = -2599234213, tmp))|(tmp = 2650380060, tmp))|x)+x))>>>x)&(-1961373866))<<x)))); + assertEquals(-718394682, x -= ((x|(tmp = 1764417670.8577194, tmp))%(1046022988))); + assertEquals(3576572614, x >>>= (((tmp = 2480472883.078992, tmp)<<x)>>((2035208402.8039393)&(tmp = 492980449, tmp)))); + assertEquals(434034142, x %= (x&((x>>>(311110449.48751545))|(-243530647)))); + assertEquals(524703439.3065736, x += (((tmp = 1392771723.3065736, tmp)%(x&x))%(tmp = -2199704930, tmp))); + assertEquals(373686272, x &= (x<<((tmp = 2103372351.9456532, tmp)%(tmp = -1367109519, tmp)))); + assertEquals(373686272, x >>= x); + assertEquals(-0.12245430020241108, x /= (tmp = -3051638622.5907507, tmp)); + assertEquals(1, x /= x); + assertEquals(1, x %= (3095983855)); + assertEquals(-1454736871, x ^= (x*(tmp = -1454736872, tmp))); + assertEquals(-1454736866, x ^= (((724989405.7338341)|(tmp = -2834298786.384371, tmp))>>>(tmp = -2029602148.1758833, tmp))); + assertEquals(-1454736866, x &= x); + assertEquals(-197394432, x <<= (tmp = -1562128975, tmp)); + assertEquals(251658240, x <<= (tmp = 2126510950, tmp)); + assertEquals(3295700610.703306, x -= (tmp = -3044042370.703306, tmp)); + assertEquals(-51152917, x |= ((949179883.1784958)|(((tmp = -2046168220, tmp)>>(x/x))/(((835064313)*(tmp = 2197600689, tmp))^(((tmp = 2717104216, tmp)&x)<<(-1402661995.3845913)))))); + assertEquals(-1549204421, x ^= ((((tmp = -481013711, tmp)>>>((tmp = 119589341.80209589, tmp)%(-995489985.2905662)))-(635717011))^(x+(x*x)))); + assertEquals(-1078356672.3999934, x += (470847748.6000067)); + assertEquals(1484987268.4638166, x += (tmp = 2563343940.86381, tmp)); + assertEquals(277020804, x &= (tmp = 2532819117, tmp)); + assertEquals(-2097118208, x <<= (x>>>x)); + assertEquals(-2147483648, x <<= (tmp = 761285045, tmp)); + assertEquals(2147483648, x >>>= x); + assertEquals(-935909870282997800, x *= ((-2583300643)|x)); + assertEquals(-370753566.54721737, x %= (-1084543510.4524941)); + assertEquals(-177, x >>= (-946264747.6588805)); + assertEquals(-416077682, x ^= (tmp = 416077761, tmp)); + assertEquals(NaN, x %= ((((tmp = 779607408, tmp)*(((tmp = -3007128117, tmp)*(851442866.6153773))+x))&(1283388806))/(-876363553))); + assertEquals(NaN, x %= (x/(tmp = -1668413939.652408, tmp))); + assertEquals(-1726405921, x ^= (tmp = -1726405921, tmp)); + assertEquals(-1, x >>= ((3031008213.807012)>>x)); + assertEquals(4294967295, x >>>= ((x>>>x)&(tmp = 2788082290, tmp))); + assertEquals(8544111670008449000, x *= (tmp = 1989331020.0417833, tmp)); + assertEquals(268435456, x <<= (tmp = 3121736017.2098465, tmp)); + assertEquals(-2.1011176170964474e+26, x -= (((tmp = 1392503299, tmp)*(tmp = 1446108825.1572113, tmp))*(x^(tmp = 372776014.213725, tmp)))); + assertEquals(0, x |= x); + assertEquals(0, x >>= ((-112413907.70074797)*(-702798603))); + assertEquals(1829518838, x |= (tmp = -2465448458, tmp)); + assertEquals(57172463, x >>= ((tmp = 2979642955.241792, tmp)%(tmp = -2464398693.291434, tmp))); + assertEquals(114344926, x += x); + assertEquals(113279134, x &= (2397742238.6877637)); + assertEquals(54, x >>= (1908522709.6377516)); + assertEquals(-2.966982919573829e-7, x /= (tmp = -182003070, tmp)); + assertEquals(0, x <<= (-1078417156)); + assertEquals(-147831390, x ^= (((-147831390)>>>x)+x)); + assertEquals(0, x -= x); + assertEquals(-242221450.44696307, x -= (tmp = 242221450.44696307, tmp)); + assertEquals(-484442900, x <<= (((tmp = -2033947265.088614, tmp)&x)/(x^(tmp = -2893953848, tmp)))); + assertEquals(-3227648, x <<= (x<<((tmp = -193993010, tmp)*((983187830)|(3146465242.2783365))))); + assertEquals(-6455296, x += x); + assertEquals(-1771542585, x -= (x^(tmp = -1767335879, tmp))); + assertEquals(-0, x %= x); + assertEquals(0, x >>>= ((((tmp = -1612864670.4532743, tmp)*(tmp = 786265765.210487, tmp))*((((tmp = -893735877.3250401, tmp)*((x^(tmp = -2804782464.233885, tmp))<<x))&(x-x))^x))<<x)); + assertEquals(0, x -= (x>>>(-1648118674.380736))); + assertEquals(0, x >>= ((tmp = -2706058813.0028524, tmp)>>(2745047169))); + assertEquals(0, x += x); + assertEquals(0, x %= (-898267735.137356)); + assertEquals(0, x >>>= x); + assertEquals(0, x >>= ((265527509)/((tmp = 2190845136.7048635, tmp)+((x>>x)>>>((x%(x-x))&((((-2080184609.8989801)&((-327231633)>>>((tmp = 864849136, tmp)%(((-524363239)*(((((tmp = 2245852565.3713694, tmp)&(1918365.8978698254))>>>(tmp = -2463081769, tmp))-(((2438244059.471446)|((((-135303645.38470244)*(-861663832.2253196))%(tmp = 1273185196.0261836, tmp))|((2261539338.832875)%((320267076.2363237)+x))))>>(tmp = -2731398821, tmp)))/(tmp = -1947938611, tmp)))^x))))>>(tmp = 833666235, tmp))|x)))))); + assertEquals(-1116704570, x ^= (-1116704570)); + assertEquals(1379561710, x ^= (tmp = -280362968.19654894, tmp)); + assertEquals(-1673822208, x <<= x); + assertEquals(-1673822208, x |= (x<<(tmp = 1389479193.9038138, tmp))); + assertEquals(2559712, x >>>= (-2703763734.0354066)); + assertEquals(2593499, x ^= (x>>>((tmp = 148668150.03291285, tmp)^(tmp = -1580360304, tmp)))); + assertEquals(2070393855, x |= (tmp = -2227002907, tmp)); + assertEquals(304197770, x &= (tmp = 2453257354, tmp)); + assertEquals(304197770, x <<= ((-669331453.8814087)-(x^(x^(tmp = 33804899.98928583, tmp))))); + assertEquals(297068, x >>= x); + assertEquals(Infinity, x /= (x-x)); + assertEquals(NaN, x %= x); + assertEquals(0, x ^= x); + assertEquals(0, x %= ((tmp = 1723087085, tmp)%(2859382131.304421))); + assertEquals(0, x %= (((tmp = 2935439763, tmp)<<(-3163992768.637094))%(tmp = 67176733, tmp))); + assertEquals(0, x &= (tmp = 2480771277, tmp)); + assertEquals(0, x >>>= (x+(tmp = -3168690063, tmp))); + assertEquals(0, x *= ((tmp = -1915275449.1806245, tmp)>>>((tmp = -1644482094.1822858, tmp)/(tmp = -432927173, tmp)))); + assertEquals(0, x += (((2766509428.071809)/(x/((942453848.5423365)/(((tmp = -1284574492, tmp)&((tmp = 760186450.7301528, tmp)-(2464974117.358138)))/((x/(x|(672536969)))*(x>>(-1272232579)))))))>>(x*(-3175565978)))); + assertEquals(-1277710521, x -= (1277710521)); + assertEquals(-1277710521, x >>= (((tmp = -2349135858, tmp)-x)-x)); + assertEquals(-1277710521, x >>= ((tmp = 2135645051, tmp)*(tmp = -2468555366, tmp))); + assertEquals(-155971, x >>= (-1294859507)); + assertEquals(-0, x %= x); + assertEquals(0, x >>>= (((861078292.6597499)|(-268063679))-(((((-221864206.9494424)-(-3186868203.2201176))&(tmp = 1287132927, tmp))<<(((tmp = 1964887915, tmp)<<((25908382)^(tmp = -688293519.875164, tmp)))*(2075946055)))&(x-((x>>x)&(1395338223.7954774)))))); + assertEquals(788002218, x -= (-788002218)); + assertEquals(716399906, x &= (-1145868506)); + assertEquals(145776674, x &= (-1661931477.360386)); + assertEquals(145776674, x |= x); + assertEquals(-0.05255700469257692, x /= (tmp = -2773686873, tmp)); + assertEquals(-660918434, x |= (-660918434.2915542)); + assertEquals(1223537346, x ^= (tmp = -1871274596, tmp)); + assertEquals(305884336, x >>= (x&x)); + assertEquals(-1.1123775647978218e-8, x *= ((tmp = -793393031.4229445, tmp)/((tmp = -503919284, tmp)*(((((tmp = 429810625, tmp)>>>x)-((2091544148.870375)<<(((((x^x)%x)|x)/(-260773261))<<((tmp = -1323834653, tmp)&x))))*((-1231800099.3724015)+x))*((x+((-559726167)^x))>>>((-549148877)<<((((tmp = 1196115201, tmp)/((tmp = -2654658968.390111, tmp)%(tmp = -1044419580, tmp)))*(((((x>>>(733571228))+(2919762692.511447))/(-2718451983.570547))^x)+((2891533060.1804514)^((tmp = -2514488663, tmp)&x))))<<(tmp = -2526139641.6733007, tmp)))))))); + assertEquals(0, x >>>= x); + assertEquals(0, x *= x); + assertEquals(0, x |= x); + assertEquals(3076984066.336236, x -= ((tmp = -3076984066.336236, tmp)+((tmp = -446575828.5155368, tmp)&x))); + assertEquals(1, x /= x); + assertEquals(1513281647.839972, x *= (1513281647.839972)); + assertEquals(1251138155, x ^= ((tmp = 2124481052, tmp)&(2431937351.4392214))); + assertEquals(1, x /= x); + assertEquals(0, x &= (tmp = 627050040, tmp)); + assertEquals(497153016, x ^= (497153016)); + assertEquals(-1112801283, x |= (tmp = 2752196557, tmp)); + assertEquals(0.5735447276296568, x /= ((((tmp = -500878794, tmp)%(tmp = -2559962372.2930336, tmp))%(2661010102))+(tmp = -1439338297, tmp))); + assertEquals(1.0244795995097235e-9, x /= (559840067)); + assertEquals(0.43468811912309857, x *= (424301391)); + assertEquals(-1972757928, x ^= (tmp = -1972757928.9227014, tmp)); + assertEquals(-606757265, x ^= (tmp = -2923461577.264596, tmp)); + assertEquals(-37, x >>= (((-2736561559.7474318)%(tmp = -27668972.662741184, tmp))*(2774711606))); + assertEquals(-1923785671, x += ((-1923785597)+x)); + assertEquals(-3877639176, x += (tmp = -1953853505, tmp)); + assertEquals(-4688259242, x -= ((810620066.4394455)>>(((-1474285107.459875)>>x)/(((((-570672326.4007359)>>(tmp = -3086802075, tmp))%x)>>>(((tmp = 286938819.28193486, tmp)>>>((1712478502)>>(tmp = 3045149117.796816, tmp)))<<(tmp = 750463263.292952, tmp)))&(tmp = 2055350255.5669963, tmp))))); + assertEquals(-0, x %= x); + assertEquals(0, x <<= (1037856162.5105649)); + assertEquals(0, x *= x); + assertEquals(0, x &= (997845077.4917375)); + assertEquals(0, x *= x); + assertEquals(0, x *= x); + assertEquals(0, x <<= (((x<<x)&(57691805))>>(786927663))); + assertEquals(0, x ^= x); + assertEquals(0, x += x); + assertEquals(0, x &= (-2131910624.1429484)); + assertEquals(0, x >>>= (-43787814)); + assertEquals(-2415062021, x += (tmp = -2415062021, tmp)); + assertEquals(-4830124042, x += x); + assertEquals(-186683401, x |= (tmp = 1960135383, tmp)); + assertEquals(NaN, x *= ((tmp = -1674740173.9864025, tmp)%(((((((-432895485.7261934)-x)^x)>>>(((-1627743078.3383338)>>(179992151))<<((tmp = 911484278.0555259, tmp)|(((tmp = -3042492703, tmp)>>(((-663866035.302746)>>(((x-((440661929.50030375)>>>(tmp = 263692082, tmp)))*x)+x))/((1546004407)^(((tmp = 2023662889.1594632, tmp)*(tmp = -2456602312, tmp))+(tmp = 755602286.1810379, tmp)))))%((tmp = -336449961, tmp)|(tmp = 206780145, tmp))))))/(1068005219.1508512))<<(tmp = -474008862.6864624, tmp))/(((((((1518711056.5437899)>>>(tmp = 287418286.63085747, tmp))<<(tmp = 2823048707, tmp))^(((x<<(x^(-1600970311)))&(x>>(((tmp = 157300110.7636031, tmp)*(tmp = -3047000529, tmp))&(1743024951.3535223))))>>x))-(tmp = -2895435807, tmp))*((tmp = -314120704, tmp)&(tmp = 1759205369, tmp)))>>(tmp = 1833555960.046526, tmp))))); + assertEquals(NaN, x -= (tmp = 694955369, tmp)); + assertEquals(NaN, x *= (x%x)); + assertEquals(0, x |= x); + assertEquals(0, x ^= x); + assertEquals(0, x &= x); + assertEquals(NaN, x /= (x+x)); + assertEquals(NaN, x %= ((tmp = -1595988845, tmp)*((1754043345)>>>(-601631332)))); + assertEquals(0, x >>>= (tmp = 862768754.5445609, tmp)); + assertEquals(NaN, x /= x); + assertEquals(NaN, x %= x); + assertEquals(NaN, x *= (tmp = -1774545519, tmp)); + assertEquals(0, x >>>= (tmp = -2492937784, tmp)); + assertEquals(0, x %= ((((x<<(-1657262788.2028513))&((x^(tmp = -671811451, tmp))<<(-2984124996)))^(1455422699.7504625))-((-340550620)>>x))); + assertEquals(918278025, x ^= ((tmp = -918278027, tmp)^((tmp = 2889422870, tmp)/(tmp = -657306935.7725658, tmp)))); + assertEquals(918278025, x %= (2603186571.0582614)); + assertEquals(107034679.32509923, x %= (tmp = -811243345.6749008, tmp)); + assertEquals(53517339, x >>= (x%((((x*((tmp = -983766424, tmp)^(-1881545357.8686862)))|(tmp = -1429937087, tmp))>>((x<<x)>>((((tmp = -2347470476, tmp)&x)+((x&x)<<(396061331.6476157)))*(tmp = -3136296453.209073, tmp))))>>>(((tmp = 908427836, tmp)|(tmp = 207737064, tmp))|(((1253036041)-(tmp = 2705074182, tmp))+(-431215157.82083917)))))); + assertEquals(53477378, x &= ((((-1128036654.165636)*x)+x)>>(x>>(3080099059)))); + assertEquals(0, x >>= (-590692293)); + assertEquals(0, x %= (-2395850570.9700127)); + assertEquals(0, x *= ((tmp = 1377485272, tmp)&(1129370608))); + assertEquals(0, x += (x>>>(x%(((((tmp = -1746827236, tmp)+((tmp = -326913490, tmp)&((-58256967)&x)))*(tmp = -1176487022.001651, tmp))>>>(-2089147643))-x)))); + assertEquals(0, x <<= (tmp = 1073298160.2914447, tmp)); + assertEquals(-837811832, x ^= (-837811832)); + assertEquals(102760448, x <<= (tmp = 2833582450.4544373, tmp)); + assertEquals(0, x &= (((((((tmp = 2595641175, tmp)*x)+(tmp = -2049260172.1025927, tmp))%((2986747823)>>(tmp = -2120598518, tmp)))&((tmp = -2742408622, tmp)&x))>>x)*((1043474247.9601482)&(tmp = 1686365779.9885998, tmp)))); + assertEquals(0, x >>= ((tmp = 1717862848, tmp)-(tmp = 1077024446.4160957, tmp))); + assertEquals(NaN, x /= x); + assertEquals(NaN, x /= (-1669429787.975099)); + assertEquals(NaN, x -= (-2299895633.4807186)); + assertEquals(138173970, x ^= (138173970.56627905)); + assertEquals(-2084183776, x <<= (3073345316)); + assertEquals(-0, x %= x); + assertEquals(0, x >>= (-3080556066.068573)); + assertEquals(0, x &= ((tmp = -2587514820, tmp)*(x-((x^(1995672257))*(1125326747.2339358))))); + assertEquals(NaN, x %= x); + assertEquals(0, x >>= (tmp = 2139186585, tmp)); + assertEquals(-1904096640, x |= ((-602301360.1919911)*(-1270444810))); + assertEquals(1073741824, x <<= (tmp = -1069467849, tmp)); + assertEquals(1073741824, x ^= (x-x)); + assertEquals(536870912, x >>>= (-1579466367.160293)); + assertEquals(512, x >>= (972402804.3890183)); + assertEquals(512, x &= (tmp = 2664796831, tmp)); + assertEquals(16777216, x <<= (-2738292561)); + assertEquals(0, x >>>= ((((1397663615.3889246)|(1117420260.6730964))-(-1173734560))<<((tmp = 1007006104.0172879, tmp)<<((tmp = -623002097, tmp)%(tmp = -35829654.379403114, tmp))))); + assertEquals(1200191544, x ^= (tmp = -3094775752, tmp)); + assertEquals(71, x >>>= x); + assertEquals(71, x |= x); + assertEquals(1394763772, x += (1394763701)); + assertEquals(-1.492717171027427, x /= ((x&(tmp = 1243787435, tmp))-(2043911970.26752))); + assertEquals(-1.1002448961224718e-8, x /= ((((835185744)*(((tmp = 2165818437, tmp)^(tmp = 2567417009.1166553, tmp))/x))/x)/(((63485842.39971793)^(2668248282.597389))/x))); + assertEquals(0, x <<= (tmp = 1598238578.637568, tmp)); + assertEquals(0, x |= (x&((tmp = -1812945547.5373957, tmp)>>>x))); + assertEquals(0, x >>>= (x+(-1969679729.7299538))); + assertEquals(1582033662, x += (tmp = 1582033662, tmp)); + assertEquals(1, x >>>= x); + assertEquals(-550748739, x += ((tmp = -550748740, tmp)/(x&((2537822642.235506)^((-2167656297)%(tmp = 1161201210, tmp)))))); + assertEquals(-268921, x >>= (tmp = 1916069547.7381654, tmp)); + assertEquals(-0.00021776939364231114, x /= (tmp = 1234888868, tmp)); + assertEquals(0, x <<= (-1036375023)); + assertEquals(0, x &= ((((x/(2398886792.27443))&(x|((-1813057854.1797302)-x)))&(x/(((tmp = 3091133731.4967556, tmp)|(3013139691.823039))<<x)))>>>(2542784636.963599))); + assertEquals(0, x += ((x*x)/(tmp = 347079383, tmp))); + assertEquals(788347904, x |= ((1462257124.6374629)*((3180592147.4065146)-(x&(1922244678))))); + assertEquals(2130672735, x |= (tmp = -2846986145, tmp)); + assertEquals(-1331327970, x ^= ((656251304)-(tmp = 1489152359, tmp))); + assertEquals(-0.14377179742889856, x %= (((2889747597.813753)-(1730428996))/(((tmp = -1378710998, tmp)&x)|x))); + assertEquals(-1754612583.143772, x += ((-1754725729)^((-2285838408)>>>(1434074349)))); + assertEquals(-0, x %= x); + assertEquals(0, x &= (tmp = -1031961332, tmp)); + assertEquals(NaN, x /= x); + assertEquals(NaN, x /= (3059476325)); + assertEquals(NaN, x *= ((x*((((tmp = 13529540.462185979, tmp)&x)^((x<<(-1312696238.1628869))&(-2029766712.3852897)))>>x))/x)); + assertEquals(1657339940, x ^= ((tmp = -488956817.1491232, tmp)&(tmp = -2352413900.1983714, tmp))); + assertEquals(-530683621952432200, x *= (tmp = -320202035.2882054, tmp)); + assertEquals(229226258, x ^= ((tmp = -1263410990.026416, tmp)+(((-808046349)&(tmp = -1294442506, tmp))&((tmp = 1147437219, tmp)<<((tmp = -820299900, tmp)-(tmp = -1947748943.3443851, tmp)))))); + assertEquals(7163320, x >>= (-2631307131)); + assertEquals(-68, x |= (((-1271721343)>>x)%x)); + assertEquals(-39956523818.38862, x *= (587595938.505715)); + assertEquals(0, x -= x); + assertEquals(0, x >>>= ((x^(x+x))<<(tmp = 265212367, tmp))); + assertEquals(0, x |= (((x>>((tmp = 2294761023, tmp)/(x>>(2125624288))))&((-2125650113)|(tmp = 1014409884, tmp)))%(tmp = -527324757, tmp))); + assertEquals(0, x >>= ((tmp = 2267075595, tmp)*(-1681569641.8304193))); + assertEquals(0, x >>>= x); + assertEquals(0.5738410949707031, x -= ((tmp = -1846572645.573841, tmp)%((((((x^(((-156613905.64173532)/x)<<x))+((x|((2405109060)>>>x))^x))/(570585894.8542807))+(x&(-2544708558)))^((((tmp = -2539082152.490635, tmp)+((((-657138283)/(2204743293))-((tmp = -1422552246.565012, tmp)+x))<<(x-x)))>>(x/(x>>>(tmp = -3027022305.484394, tmp))))<<x))&((-2066650303.3258202)/(tmp = -1666842593.0050385, tmp))))); + assertEquals(0, x >>>= ((((tmp = 2473451837.613817, tmp)>>((2526373359.1434193)>>(x<<x)))+((tmp = -579162065, tmp)+((tmp = -3115798169.551487, tmp)-(tmp = 933004398.9618305, tmp))))&(tmp = 131167062, tmp))); + assertEquals(-2067675316, x ^= (-2067675316.6300585)); + assertEquals(543772, x >>>= x); + assertEquals(-1073741824, x <<= x); + assertEquals(3221225472, x >>>= ((x*(1478586441.081221))&(tmp = -3050416829.2279186, tmp))); + assertEquals(0, x ^= x); + assertEquals(0, x *= x); + assertEquals(-1017771903.0298333, x -= (1017771903.0298333)); + assertEquals(0.6404112721149928, x /= ((tmp = -144667370, tmp)^(-2849599562))); + assertEquals(-2410517638773644000, x -= (((tmp = 1759631550, tmp)*x)*((((tmp = -2949481475, tmp)>>>x)*x)|(tmp = -2977983804, tmp)))); + assertEquals(-0, x %= (x+((((tmp = -1307866327.7569134, tmp)<<((x&((tmp = -2380043169.8405933, tmp)|x))>>(472992789.7639668)))|(((((x<<(tmp = -1416427232.7298179, tmp))%(-1404989679.409946))*((x/(tmp = -992416608, tmp))/(tmp = 524646495, tmp)))-(tmp = 734405570, tmp))>>x))/(1079256317.7325506)))); + assertEquals(0, x <<= (tmp = 2459834668, tmp)); + assertEquals(-0, x /= (tmp = -1892164840.5719755, tmp)); + assertEquals(0, x >>= (x|(((1299844244)>>>(((tmp = -2422924469.9824634, tmp)|x)-((((1914590293.2194016)+(-3033885853.8243046))-((tmp = -1720088308, tmp)%x))<<(tmp = 2210817619, tmp))))<<x))); + assertEquals(0, x <<= (((tmp = 3192483902.841396, tmp)>>>(((x^(2944537154))|(tmp = -1334426566, tmp))*(((((((-2705218389)&x)+(1987320749))+(tmp = -111851605, tmp))|(2894234323))-(265580345))&x)))%(((tmp = 1431928204.6987057, tmp)&(tmp = 914901046, tmp))&(x>>>x)))); + assertEquals(0, x >>>= (tmp = 1941940941, tmp)); + assertEquals(0, x %= (3089014384)); + assertEquals(0, x += ((tmp = 2948646615, tmp)*x)); + assertEquals(-0, x /= (tmp = -1480146895, tmp)); + assertEquals(NaN, x /= x); + assertEquals(NaN, x %= (-2995257724.158043)); + assertEquals(NaN, x %= (tmp = 2714835455, tmp)); + assertEquals(NaN, x /= (tmp = -311440765.98078775, tmp)); + assertEquals(NaN, x -= (-1600234513.697098)); + assertEquals(0, x <<= x); + assertEquals(0, x <<= (-1499045929)); + assertEquals(-0, x *= (-2491783113)); + assertEquals(0, x ^= (x%((x>>(((1234398704.3681123)>>>x)%(x+x)))>>(402257223.4673699)))); + assertEquals(-643225204, x ^= (((-55960194.698637486)+((((721411198)-(((tmp = 1308676208.7953796, tmp)%(2242904895))-x))>>((((tmp = 332791012, tmp)&((tmp = -2094787948, tmp)/((x/(2427791092))^(2444944499.6414557))))%(((x+(1253986263.5049214))+(((((3135584075.248715)+((tmp = -2569819028.5414333, tmp)%(440908176.1619092)))>>>(x<<((3061615025)-x)))%x)%(x+((2369612016)*((((tmp = 1173615806, tmp)*(-1910894327))&(2428053015.077821))*(-55668334.70082307))))))<<(tmp = -2129259989.0307562, tmp)))+(1579400360)))%((-3053590451.8996153)>>x)))+(x>>(x%(x^((-1772493876)^x)))))); + assertEquals(413738663060841600, x *= x); + assertEquals(1581062538.4501781, x %= ((tmp = -1298397672.0300272, tmp)-((2237197923)+(tmp = -1385478459, tmp)))); + assertEquals(755644566.8709538, x %= (tmp = -825417971.5792243, tmp)); + assertEquals(1, x /= x); + assertEquals(0, x >>>= ((89330582)%(-1012731642.4855506))); + assertEquals(0, x >>>= x); + assertEquals(NaN, x %= ((x>>>((x/(tmp = -1848848941.2352903, tmp))>>>(tmp = -71862893, tmp)))&(-2385996598.2015553))); + assertEquals(NaN, x += (-2292484503.318904)); + assertEquals(NaN, x *= (2961064461)); + assertEquals(NaN, x += (x<<((2076798243.6442)/((tmp = -81541044.75366282, tmp)^((3041366498.551101)+((2126874365)/(tmp = -177610359, tmp))))))); + assertEquals(NaN, x %= ((x/((x/x)+x))>>>x)); + assertEquals(NaN, x /= x); + assertEquals(NaN, x += (1171761980.678)); + assertEquals(NaN, x += ((2355675823)<<(-390497521))); + assertEquals(NaN, x %= x); + assertEquals(0, x &= (tmp = -658428225.56619, tmp)); + assertEquals(0, x ^= x); + assertEquals(0, x <<= (1643310725.5713737)); + assertEquals(0, x <<= x); + assertEquals(0, x <<= (-397005335.3712895)); + assertEquals(0, x >>>= (tmp = -2804713458.166788, tmp)); + assertEquals(0, x <<= (((((((tmp = 1879988501, tmp)%(1528081313.9360204))+(1376936736))*((((x>>>((1736268617.339198)>>>(-2598735297.4277673)))<<((((((((-2742982036)/(231867353.4549594))-(875335564))<<x)|((2241386341.742653)<<((-22024910.828409433)&(x<<x))))*(-756987803.5693252))+x)^(tmp = 1084498737, tmp)))<<(1920373881.8464394))&(2370827451.82652)))&(x^(tmp = -891503574, tmp)))<<x)>>>((-1519588625.2332087)^(483024636.2600144)))); + assertEquals(52193878.40997505, x -= ((tmp = -341753803.40997505, tmp)%(tmp = -96519975, tmp))); + assertEquals(-1665844168.938803, x -= (1718038047.348778)); + assertEquals(3.6962232549405003e-19, x /= (((((-809583468.5507183)>>>((tmp = 286797763, tmp)%((1579183142.7321532)/(1853824036.001172))))<<x)>>(((x|x)^((tmp = -2641304815, tmp)<<(x<<x)))>>(((((268338128.8300134)&(-1778318362.8509881))*(751081373.346478))<<(((525066612)>>(-1139761212))*(2949167563.299916)))<<x)))+((tmp = 664905121, tmp)*((-2208280205)*(3069462420))))); + assertEquals(4710721795.110161, x += (((217604832)+((1307891481.781326)-x))+(tmp = 3185225481.328835, tmp))); + assertEquals(0, x %= x); + assertEquals(0, x -= (((x>>>(x/(tmp = 46977522.46204984, tmp)))>>(-2466993199.615269))&(tmp = 14524430.287991166, tmp))); + assertEquals(0, x >>= x); + assertEquals(0, x /= (tmp = 578120637, tmp)); + assertEquals(-17267104, x -= (((tmp = 1515285919.495792, tmp)+(((tmp = -1364790286.7057304, tmp)+((954599071)>>((897770243.1509961)*x)))^x))>>>(566027942.1732262))); + assertEquals(-17267104, x &= x); + assertEquals(189138241, x ^= ((tmp = 1565742675.9503145, tmp)-((tmp = 1737806643, tmp)|((x*(tmp = -1382435297.5955122, tmp))*(-2820516692.153056))))); + assertEquals(189138241, x %= (x*(tmp = -1670678493, tmp))); + assertEquals(1693, x %= ((-2328713314)>>>(1623637325))); + assertEquals(1693, x %= ((-1019394014)*(x|x))); + assertEquals(3386, x += x); + assertEquals(9268970871604, x *= (2737439714)); + assertEquals(-4720.120483643183, x /= (tmp = -1963714889, tmp)); + assertEquals(-1, x >>= ((x^(((-2404688047.455056)|((1439590234.6203847)<<(tmp = -2496557617, tmp)))/((x<<((tmp = 1865549512.282249, tmp)/(((360384191.55661833)>>(tmp = -1225297117.344188, tmp))>>>(2703264010.4122753))))*(1521960888.0071676))))%(tmp = 2834001448.0508294, tmp))); + assertEquals(63, x >>>= (x&(-3079339174.6490154))); + assertEquals(0, x >>>= (1039770956.6196513)); + assertEquals(0, x >>>= (-1074820214)); + assertEquals(0, x >>>= (x/x)); + assertEquals(0, x >>= ((tmp = -449117604.2811785, tmp)&x)); + assertEquals(-0, x /= (tmp = -118266935.1241343, tmp)); + assertEquals(2226140134, x += (tmp = 2226140134, tmp)); + assertEquals(2068827161, x ^= ((tmp = -1950744808.846384, tmp)>>((2258661151)^((tmp = -1118176421.8650177, tmp)<<(2828634014))))); + assertEquals(123, x >>>= (-1779624840.0515127)); + assertEquals(0, x >>>= (x|((tmp = -239082904, tmp)<<(tmp = 1404827607, tmp)))); + assertEquals(0, x >>>= x); + assertEquals(1793109749, x ^= (tmp = -2501857547.710491, tmp)); + assertEquals(855, x >>>= x); + assertEquals(0, x >>>= (-847289833)); + assertEquals(0, x %= (-2271241045)); + assertEquals(169648072, x ^= (((tmp = 169648072.66759944, tmp)^x)|x)); + assertEquals(176025927479164930, x *= ((tmp = 1111997198.8803885, tmp)<<(tmp = 2913623691, tmp))); + assertEquals(176025926613281700, x += ((tmp = -865883245, tmp)<<(x+(-2624661650)))); + assertEquals(3406506912, x >>>= ((x|(tmp = 2436016535, tmp))*(((tmp = -1222337225, tmp)<<((1765930268)&x))*(tmp = 1600702938, tmp)))); + assertEquals(1.694694170868292, x %= (x/(-1597121830.794548))); + assertEquals(0, x >>= (tmp = -2443203089, tmp)); + assertEquals(0, x >>>= (1323174858.2229874)); + assertEquals(0, x &= ((tmp = 846556929.2764134, tmp)|(((1483000635.0020065)|(-3151225553))|(tmp = -229028309, tmp)))); + assertEquals(0, x >>= x); + assertEquals(0, x >>= ((((((-2677334787)>>>x)>>((tmp = 496077992, tmp)&((((x<<(x*(tmp = 1095163344.2352686, tmp)))+(-952017952))%((x<<((x*x)/(tmp = 2983152477, tmp)))^((tmp = -939521852.1514642, tmp)^(tmp = 143967625.83755958, tmp))))*((tmp = 551827709.8366535, tmp)>>>x))))^((-1552681253.69869)-(-1874069995)))>>>(x>>(x%(tmp = -2554673215, tmp))))|(tmp = -190693051.77664518, tmp))); + assertEquals(0, x /= (tmp = 427402761.37668264, tmp)); + assertEquals(0, x <<= x); + assertEquals(0, x |= (x>>>(((((-543326164.0673618)>>>(-2344090136.707964))>>>((((-563350246.6026886)/x)/(1525481037.3332934))&(tmp = -2917983401.88958, tmp)))^(-1094667845.1208413))^x))); + assertEquals(0, x &= (1080322749.897747)); + assertEquals(0, x %= (tmp = -1572157280, tmp)); + assertEquals(0, x >>>= x); + assertEquals(0, x %= ((377280936)|x)); + assertEquals(708335912, x -= (tmp = -708335912, tmp)); + assertEquals(2766937, x >>>= x); + assertEquals(547342779, x += (tmp = 544575842, tmp)); + assertEquals(546273751, x -= ((x>>>(472833385.9560914))|((tmp = -1164832103.9970903, tmp)/(3147856452.1699758)))); + assertEquals(546273751, x &= x); + assertEquals(0, x ^= x); + assertEquals(0, x >>>= (tmp = -3181805175, tmp)); + assertEquals(-375546685, x |= (-375546685.08261824)); + assertEquals(1089992785780217200, x *= (tmp = -2902416209, tmp)); + assertEquals(0, x %= x); + assertEquals(-1854981526, x -= ((x-x)-(-1854981526))); + assertEquals(-3709963052, x += x); + assertEquals(-316772482, x %= (tmp = -1696595285, tmp)); + assertEquals(-316772482, x |= x); + assertEquals(1, x /= x); + assertEquals(0, x -= x); + assertEquals(-1418375842, x ^= (-1418375842)); + assertEquals(-2, x >>= x); + assertEquals(-4, x += x); + assertEquals(-8388608, x &= (x<<(-350555339.30086184))); + assertEquals(-16777216, x += x); + assertEquals(-0, x %= x); + assertEquals(1083355129, x += (tmp = 1083355129, tmp)); + assertEquals(0, x &= (((tmp = 389729053, tmp)-(tmp = 2944192190.0939536, tmp))/(x-(2081712461.2657034)))); + assertEquals(0, x += x); + assertEquals(-3, x += ((3147270119.5831738)>>((2455837253.1801558)%((-2100649096)>>(((290236808.01408327)|(x&((2661741230.3235292)|((tmp = 1686874589.4690177, tmp)<<x))))*(x+(tmp = 2327674670, tmp))))))); + assertEquals(-3, x %= ((x>>(((-2962686431)%x)>>((((2438370783)-(tmp = 2667305770.4839745, tmp))>>>x)>>>x)))<<((x&(tmp = 1428498616, tmp))|((tmp = 2621728539.102742, tmp)/(-204559901))))); + assertEquals(2, x ^= (x|((((tmp = 1751230118.6865973, tmp)/(-867465831.207304))>>((-808143600.0912395)+(-2882191493.0506454)))^x))); + assertEquals(2, x %= (-2015954220.2250996)); + assertEquals(0, x >>>= (tmp = 401373999, tmp)); + assertEquals(0, x >>= (2371830723)); + assertEquals(0, x >>>= ((((tmp = 2765919396, tmp)-x)-(530310269.7131671))|(tmp = -615761207.9006102, tmp))); + assertEquals(-145389011, x ^= (tmp = -145389011, tmp)); + assertEquals(-145389011, x |= x); + assertEquals(1632929832, x &= (-2518898392)); + assertEquals(4190540017.751949, x += (tmp = 2557610185.751949, tmp)); + assertEquals(4980024282.153588, x += ((1841304364.1177452)%(tmp = 1051820099.7161053, tmp))); + assertEquals(0, x >>>= (((((1379314342.4233718)>>((-2782805860)^((x%(tmp = 1328845288, tmp))>>>(tmp = 901403219.858733, tmp))))+(x/((tmp = -3078904299, tmp)/x)))/x)|(x|(1399702815)))); + assertEquals(-1820494882, x ^= (tmp = -1820494882.407127, tmp)); + assertEquals(-305870376, x %= (tmp = -757312253, tmp)); + assertEquals(-577530443, x += (x|(tmp = -1958083619.6653333, tmp))); + assertEquals(333541412591776260, x *= x); + assertEquals(-949341696, x >>= ((((1550069663)<<((x>>>(tmp = 2406565178.902887, tmp))>>>((1844746612.632984)/((tmp = 2233757197, tmp)*((-1524891464.1028347)>>(tmp = 2498623474.5616803, tmp))))))&x)<<(x&(tmp = -370379833.3884752, tmp)))); + assertEquals(-277202090, x |= ((-762200848.8405354)-(tmp = 1749136282, tmp))); + assertEquals(0.13704539927239265, x /= (tmp = -2022702633.373563, tmp)); + assertEquals(0, x -= x); + assertEquals(0, x %= ((132951580.19304836)-((427623236.27544415)-(1212242858)))); + assertEquals(0, x &= ((449148576)&(-1609588210.249217))); + assertEquals(0, x >>= x); + assertEquals(0, x -= x); + assertEquals(-0, x /= (tmp = -1640777090.9694843, tmp)); + assertEquals(0, x &= (((tmp = -1923412153, tmp)>>>((x>>(tmp = 3027958119.0651507, tmp))+(60243350)))>>(tmp = -2610106062, tmp))); + assertEquals(0, x ^= (((-186998676)/(tmp = 2697937056, tmp))-x)); + assertEquals(-1147950080, x |= ((2425449461)*(tmp = -2525854833, tmp))); + assertEquals(457688198, x ^= (2698274950.660941)); + assertEquals(8724, x %= ((1174351031)>>>((371599047.36048746)+(3025292010)))); + assertEquals(0, x <<= (tmp = -710011617, tmp)); + assertEquals(0, x >>>= (1693410026)); + assertEquals(1443005362, x ^= ((tmp = -2851961934, tmp)+((((x%x)-(tmp = 547622400, tmp))<<(((tmp = 722396486.5553623, tmp)|x)>>>((((tmp = -542268973.5080287, tmp)<<(tmp = 1347854903.771954, tmp))>>>(tmp = -889664427.7115686, tmp))&((tmp = 1549560114, tmp)*(tmp = 964918035, tmp)))))&(-2422502602.920377)))); + assertEquals(3986573462, x -= (-2543568100)); + assertEquals(7973146924, x += x); + assertEquals(-1, x >>= (-75987297)); + assertEquals(-12, x += ((2940824338.64834)>>(tmp = 3061467355, tmp))); + assertEquals(-3.8229398525977614e-8, x /= (313894554)); + assertEquals(-2.890709270374084e-17, x /= (tmp = 1322491989, tmp)); + assertEquals(0, x |= (x-x)); + assertEquals(0, x >>>= (tmp = -1205300664, tmp)); + assertEquals(-0, x /= (((2869505187.6914144)>>(tmp = 1541407065, tmp))/(((-571132581)>>>(x>>x))/((x^(170373762.8793683))>>>((((tmp = -363073421.05897164, tmp)|(((tmp = -1591421637, tmp)>>(1095719702.8838692))&(636687681.9145031)))^x)^(x|x)))))); + assertEquals(-1487828433, x ^= (-1487828433.3462324)); + assertEquals(-0, x %= x); + assertEquals(1716342498, x -= ((tmp = 2578624798, tmp)^x)); + assertEquals(1636, x >>= ((264194540)>>>(-801900756))); + assertEquals(0, x >>>= ((tmp = 2502688876, tmp)+((x<<(x|((-628272226.0338528)|((x<<(-2083074091))>>>(tmp = 1692123246.8418589, tmp)))))>>(1594759826.990993)))); + assertEquals(0, x <<= (tmp = -904399643, tmp)); + assertEquals(NaN, x /= ((x^(x-x))%((tmp = 1744962024.4882128, tmp)%x))); + assertEquals(NaN, x /= (-1013142883.1845908)); + assertEquals(NaN, x /= ((tmp = 793633198, tmp)^(-2993598490.8659954))); + assertEquals(0, x &= (x>>((tmp = 1200937851, tmp)<<(((tmp = -2807378465, tmp)&(tmp = -143778237, tmp))|(tmp = -1200772223, tmp))))); + assertEquals(0, x <<= x); + assertEquals(88144, x |= (((((tmp = 3002723937.8560686, tmp)*(tmp = -3171720774.2612267, tmp))%(((tmp = -2586705978.7271833, tmp)%((x+(-1553704278))&(2405085526.501994)))>>((-240842053)>>>(((((tmp = -1886367228.4794896, tmp)>>>x)^(tmp = 2604098316, tmp))^(tmp = 1362808529, tmp))<<((tmp = -1062263918, tmp)|((-172718753)%(tmp = -1910172365.4882073, tmp)))))))^((1444153362)>>((x&((-1205465523.2604182)^(tmp = -2062463383, tmp)))>>(tmp = 956712476, tmp))))>>((((-1004215312)^((((-1707378612.5424936)^(tmp = 2372161553, tmp))/((tmp = 1802586581, tmp)*((2082257.1896460056)&((tmp = -1270773477, tmp)^(tmp = 942517360.3447798, tmp)))))+x))%((((666494127)^(x^x))>>>(tmp = -2592829775, tmp))+((-1601528223)+((x+(tmp = -2417034771.7409983, tmp))>>>((tmp = -730673817, tmp)*x)))))>>x))); + assertEquals(-2603179111.7557006, x -= ((2603267255.755627)+(x/(1200979191.2823262)))); + assertEquals(1691788185, x >>= (tmp = 3088840032, tmp)); + assertEquals(-168382533, x |= (tmp = -780750941.4590135, tmp)); + assertEquals(-168382533, x >>= (60741120.48285198)); + assertEquals(-134287365, x |= (x*(tmp = 834637940.7151251, tmp))); + assertEquals(-1481917089, x -= (tmp = 1347629724, tmp)); + assertEquals(1, x >>>= x); + assertEquals(262144, x <<= (2680216914)); + assertEquals(1075132032, x ^= (x-((tmp = 3220359552.3398685, tmp)^(((-434474746.6039338)|((((((((tmp = 1945689314.9683735, tmp)>>(1300022273))>>>(333705550))&x)%(588357521))-(x+(x^(((tmp = -134560382, tmp)+x)-((((994246147.7195556)-(-1506599689.7383268))%(x<<x))>>((1256426985.5269494)+(tmp = 1860295952.8232574, tmp)))))))^(((tmp = 917333220.2226384, tmp)>>x)>>>(tmp = 865898066, tmp)))%((x|(x%((tmp = -2660580370, tmp)&(tmp = 2966426022, tmp))))*x)))/(((tmp = 682585452, tmp)&(-3219368609))+((tmp = -1330253964, tmp)+((x&(2857161427))/x))))))); + assertEquals(274944, x &= ((2606953028.1319966)-(-1707165702))); + assertEquals(266752, x &= ((x<<((x+(x+(x^(-1570175484))))^x))^(x+(x<<(tmp = 90330700.84649956, tmp))))); + assertEquals(266752, x &= ((((x*(tmp = 2033225408, tmp))-(x-((tmp = 1507658653, tmp)/(-3016036094))))>>>((1497480588)>>(2784070758)))|(tmp = -3025904401.93921, tmp))); + assertEquals(-1680442631, x |= ((x/(445284843))|((tmp = 2614520057.2723284, tmp)<<x))); + assertEquals(40851947, x >>>= (tmp = -1577031386.938616, tmp)); + assertEquals(2493, x >>= ((3044630989.3662357)-(-2670572992.8580284))); + assertEquals(-0.0000017317105653562252, x /= (-1439617017.9207587)); + assertEquals(0, x &= (2359806567)); + assertEquals(623768541, x ^= (623768541)); + assertEquals(1028567149.0716183, x += (((tmp = 1307794561, tmp)%(x>>x))-(-404798608.0716183))); + assertEquals(-1.2971762489811298, x /= (tmp = -792927830.6471529, tmp)); + assertEquals(-1.2971762489811298, x %= ((-2426421701.2490773)/(-689566815.3393874))); + assertEquals(-2147483648, x <<= x); + assertEquals(-2147483648, x &= (tmp = -869991477, tmp)); + assertEquals(-268435456, x >>= (1383186659)); + assertEquals(0, x -= x); + assertEquals(-2009742037, x |= (-2009742037.5389993)); + assertEquals(-1386630820, x ^= (627864695)); + assertEquals(-1033479103975173600, x *= (tmp = 745316697.9046186, tmp)); + assertEquals(-1628048487, x |= (2662654361)); + assertEquals(325551, x >>>= (340874477)); + assertEquals(-1235730537, x ^= (tmp = 3059533880.0725217, tmp)); + assertEquals(-1235730537, x %= (2247137328)); + assertEquals(-220200960, x <<= ((x>>x)-x)); + assertEquals(0, x <<= ((tmp = 337220439.90653336, tmp)|(tmp = 2901619168.375105, tmp))); + assertEquals(0, x >>>= ((-2114406183)/x)); + assertEquals(0, x %= ((1425828626.3896675)/x)); + assertEquals(0, x >>>= ((3213757494)>>>(2595550834.3436537))); + assertEquals(0, x <<= x); + assertEquals(-0, x /= ((1544519069.5634403)/((tmp = -1332146306, tmp)&(-762835430.0022461)))); + assertEquals(0, x ^= x); + assertEquals(0, x >>= (x|((((x*((-786272700)+x))<<x)+((tmp = -1868484904, tmp)-(tmp = -1692200376, tmp)))+(-1010450257.6674457)))); + assertEquals(0, x -= x); + assertEquals(0, x ^= (x>>>(706010741))); + assertEquals(-964928697, x |= (-964928697)); + assertEquals(1, x /= x); + assertEquals(0, x >>= ((((tmp = 1778003555.3780043, tmp)>>(x%((tmp = -766158535, tmp)^((-2681449292.8257303)%((x-(x|(tmp = 1966478387.2443752, tmp)))^(((tmp = -1848398085, tmp)&x)>>>(tmp = -2860470842, tmp)))))))%(tmp = 2315077030, tmp))^x)); + assertEquals(0, x ^= x); + assertEquals(-288007757, x ^= ((tmp = 183607156.1803962, tmp)-(tmp = 471614914, tmp))); + assertEquals(-270573581, x |= (tmp = -849475741.9424644, tmp)); + assertEquals(-2129929, x |= (((((1942852445)&(tmp = 1280372312, tmp))*(x*(tmp = -1601900291, tmp)))^((509080002.81080174)-(tmp = 2699498226.9164257, tmp)))>>(((-335361221)>>(tmp = 843134832, tmp))%(-35532542)))); + assertEquals(-232622355, x ^= ((-3060885134.5375547)-(((tmp = 1965966723, tmp)-((tmp = 1248630129.6970558, tmp)<<(tmp = 1859637857.5027392, tmp)))*x))); + assertEquals(-52149658093200070, x *= (224181627.31264615)); + assertEquals(-697122968, x ^= (x-(x+(tmp = 2747211186.407712, tmp)))); + assertEquals(-2146269688, x &= ((tmp = -1466710519, tmp)^(x/(1419998975)))); + assertEquals(-536567422, x >>= (((((tmp = -1760701688.999274, tmp)>>(-1821976334))/(((tmp = -1660849531, tmp)>>>x)-((x+((tmp = -2489545009.4327965, tmp)>>>((tmp = -267360771.39148235, tmp)^x)))*(((-1453528661)%x)>>>(((243967010.3118453)/((((((2977476024)>>>((-1630798246)<<x))&(591563895.2506002))*(((2668543723.9720144)>>>x)|(1600638279)))^x)>>(x<<(tmp = -152589389, tmp))))>>>(x|(2821305924.9225664)))))))+(618968002.8307843))%(tmp = -1005408074.368274, tmp))); + assertEquals(40962, x &= (114403906)); + assertEquals(19741977727890, x *= ((-2367133915.963945)>>>(-3119344126))); + assertEquals(1313341440, x <<= x); + assertEquals(626, x >>>= ((((-333992843)%(tmp = -2742280618.6046286, tmp))>>>x)|x)); + assertEquals(0, x <<= (2598188575)); + assertEquals(NaN, x %= x); + assertEquals(NaN, x %= x); + assertEquals(0, x ^= (x%((2507288229.3233204)&(tmp = -1714553169.9276752, tmp)))); + assertEquals(0, x /= ((633436914.3859445)>>>(tmp = 1579804050.6442273, tmp))); + assertEquals(0, x *= ((tmp = 1172218326, tmp)<<((tmp = -2491306095.8456626, tmp)*(((tmp = 1305371897.9753594, tmp)>>((x^(((3077992060)*x)<<(492815553.904796)))>>((652151523)|x)))%x)))); + assertEquals(0, x <<= x); + assertEquals(0, x %= (1118131711)); + assertEquals(0, x &= ((tmp = 2734673884, tmp)|(x-((tmp = 2694578672.8975897, tmp)*(((x>>(2350811280.974167))*(1052548515))&(x^(x*(tmp = -1336287059.0982835, tmp)))))))); + assertEquals(-2632782867.1256156, x += ((tmp = -2743992725.1256156, tmp)+(tmp = 111209858, tmp))); + assertEquals(-0, x %= x); + assertEquals(0, x >>>= (((tmp = -2050519887, tmp)^(106865302.74529803))>>(1642851915.2909596))); + assertEquals(-171964826, x |= (tmp = -171964826.6087358, tmp)); + assertEquals(-2.113405951193522, x /= (tmp = 81368572.80206144, tmp)); + assertEquals(3, x >>>= x); + assertEquals(0, x %= x); + assertEquals(-1717345907.837667, x += (-1717345907.837667)); + assertEquals(-100964883, x |= (tmp = -109574931.80629134, tmp)); + assertEquals(-33849857, x |= (-974111718.2433801)); + assertEquals(1, x >>>= (tmp = -2556222849.005595, tmp)); + assertEquals(1, x /= x); + assertEquals(0, x >>>= (-1796630999.4739401)); + assertEquals(0, x >>>= x); + assertEquals(2031695758, x += (((x/(((tmp = -2364918403, tmp)%(x^((tmp = 277767803.6375599, tmp)>>((((tmp = 540036080, tmp)/(x|(2665298931)))/(x|((x>>(-2035456216.6165116))<<(2143184420.5651584))))^x))))&(tmp = 927798419.8784283, tmp)))-(-2031695758))>>>x)); + assertEquals(2031695758, x |= x); + assertEquals(2031695758, x <<= (((x>>(x%x))|(tmp = -1164531232.7384055, tmp))*x)); + assertEquals(124004, x >>>= x); + assertEquals(529846352, x += ((529722348)%((2417645298.865121)|(x>>(x>>>(x+x)))))); + assertEquals(60067920, x &= (((tmp = -3166008541.8486233, tmp)-x)|(x%x))); + assertEquals(1415594240755200, x *= ((-2786707452.873729)>>(((tmp = -2369315809, tmp)*((1559868465)|(1011218835.1735028)))>>>x))); + assertEquals(1415595182259140, x += (941503939.9023957)); + assertEquals(0, x <<= ((tmp = 2887184784.265529, tmp)/(-2575891671.0881453))); + assertEquals(0, x &= ((tmp = -1546339583, tmp)>>>(tmp = -587433830, tmp))); + assertEquals(0, x *= (((tmp = 1356991166.5990682, tmp)%(tmp = -284401292, tmp))*(1869973719.9757812))); + assertEquals(NaN, x %= x); + assertEquals(0, x ^= (((tmp = 92575404.43720293, tmp)>>>(263475358.17717505))%x)); + assertEquals(0, x <<= (((561514358)*(tmp = -439584969, tmp))%((((-3005411368.7172136)+x)|(-2230472917))&x))); + assertEquals(0, x >>= ((x>>>x)-((x-(1630649280.510933))+x))); + assertEquals(0, x >>= (tmp = -1772403084.7012017, tmp)); + assertEquals(0, x *= x); + assertEquals(0, x += x); + assertEquals(0, x &= x); + assertEquals(0, x >>= (tmp = 1622680387, tmp)); + assertEquals(1033887633558225200, x -= ((-510616337)*(tmp = 2024783695, tmp))); + assertEquals(-2.8073538539158063e+27, x *= (tmp = -2715337492, tmp)); + assertEquals(-2.8073538539158063e+27, x -= ((tmp = -1664804757, tmp)&((tmp = -226616419, tmp)>>>(1006711498)))); + assertEquals(1894539615, x |= (tmp = -2400427681.1831083, tmp)); + assertEquals(7400545, x >>= (774629608.4463601)); + assertEquals(456756268, x += (449355723)); + assertEquals(285771784, x &= (-1316427366)); + assertEquals(17, x >>= ((tmp = -220509931.20787525, tmp)*(((tmp = 2518859292, tmp)+(-1477543005.1586645))>>(tmp = 3172820250.687789, tmp)))); + assertEquals(85924262443, x *= (x*((tmp = -2856669745.965829, tmp)&(((tmp = 401420695, tmp)^(tmp = 2355371132, tmp))|(tmp = 590645330.021911, tmp))))); + assertEquals(1703875715, x ^= ((-2576394029.7843904)-x)); + assertEquals(1703875715, x %= (tmp = 2234144310, tmp)); + assertEquals(271405807, x ^= (1973569132)); + assertEquals(1060178, x >>>= (tmp = -84823096, tmp)); + assertEquals(8, x >>>= (tmp = 2246120561.905554, tmp)); + assertEquals(-2846791089, x += (-2846791097)); + assertEquals(104933962, x &= (x-(-2969030955.99584))); + assertEquals(489215611.96215343, x -= (-384281649.96215343)); + assertEquals(489215611, x |= x); + assertEquals(1186191360, x <<= ((tmp = 774407142.993727, tmp)%x)); + assertEquals(1186191360, x %= (1555004022)); + assertEquals(-1697134080, x ^= (tmp = -597421568, tmp)); + assertEquals(-1102053376, x <<= ((-927370769.4059179)^((tmp = 1093490918, tmp)>>(((-2522227493.3821955)%x)+(-2657319903))))); + assertEquals(1086450058, x ^= (-23991926.187098265)); + assertEquals(1086450058, x |= x); + assertEquals(-1.6554590588410778, x /= (x|(x<<(x+x)))); + assertEquals(67108863, x >>>= ((-926530233)+x)); + assertEquals(494553310, x ^= (tmp = 512079649, tmp)); + assertEquals(207751168, x &= (2892146720.6261826)); + assertEquals(207751168, x &= x); + assertEquals(207751168, x |= x); + assertEquals(6340, x >>>= (((((x<<(x-((-2819638321)*((x<<x)+x))))>>x)+(tmp = 2016170261, tmp))+(tmp = 2755496043.772017, tmp))+(-841368625.1402085))); + assertEquals(6340, x ^= ((x/(tmp = -192734784, tmp))>>>(((-140306239)&x)-x))); + assertEquals(1, x /= x); + assertEquals(0, x >>= x); + assertEquals(26786600, x ^= (tmp = 26786600, tmp)); + assertEquals(-0.014657576899542954, x /= ((-1454855938.0338)+(-372635753.3681567))); + assertEquals(0, x &= ((tmp = 2480635933, tmp)&(-2986584704.9165974))); + assertEquals(-2108639122, x += ((tmp = 2108639123.8683565, tmp)^((-881296055)/(((x<<(2026200582))|(tmp = -862495245.138771, tmp))-(-1111596494.892467))))); + assertEquals(1893466112, x <<= (tmp = 607974481, tmp)); + assertEquals(1893466112, x |= x); + assertEquals(1133122783.997418, x += ((tmp = -760343332, tmp)-((x-(tmp = -878561823.4218843, tmp))/(tmp = -693454632.596637, tmp)))); + assertEquals(8, x >>>= (tmp = 700339003.3919828, tmp)); + assertEquals(4.605305035175536e-9, x /= (1737127060.8343256)); + assertEquals(4.605305035175536e-9, x -= ((x%(897221779))>>>x)); + assertEquals(-1864423625.5704088, x += (tmp = -1864423625.5704088, tmp)); + assertEquals(1132240092, x <<= (1304417186.1193643)); + assertEquals(-2088985380, x ^= (x<<x)); + assertEquals(-4, x >>= ((tmp = 1959823884.0935726, tmp)%(-1679792398.569136))); + assertEquals(-268435456, x <<= ((tmp = 2586838136, tmp)|((tmp = -481716750.718518, tmp)>>>((1485826674.882607)/(tmp = -2826294011, tmp))))); + assertEquals(-32768, x >>= (2060648973)); + assertEquals(1, x /= x); + assertEquals(-2838976297, x -= (tmp = 2838976298, tmp)); + assertEquals(-1382985298, x <<= ((tmp = -2104305023, tmp)&x)); + assertEquals(10, x >>>= (x+x)); + assertEquals(10, x -= (x>>>(361588901.70779836))); + assertEquals(854603510, x -= (-854603500)); + assertEquals(-557842432, x <<= (tmp = 1212985813.6094751, tmp)); + assertEquals(-459390188241943040, x *= (tmp = 823512450.6304014, tmp)); + assertEquals(-232800033621957060, x /= ((((((686635689)/(tmp = 2013252543, tmp))*(tmp = -1591617746.8678951, tmp))|(((tmp = -1777454093.5611362, tmp)>>>((tmp = 2680809394, tmp)^(((x>>((((((tmp = -265022244, tmp)%((tmp = -3075004537, tmp)>>(((((1427784269.5686688)^((tmp = -1095171528.911587, tmp)^(-942424985.7979553)))>>(-1279441481.1987405))*((2493620394)>>(-2769016043)))/(x&((tmp = 2059033657, tmp)%(((tmp = 1948606940.1488457, tmp)-(tmp = -2645984114.13219, tmp))^x))))))^x)^x)%(x%((((tmp = 3209433446.4551353, tmp)%(tmp = 1364430104.0424738, tmp))/(tmp = -2103044578.349498, tmp))+(tmp = -2613222750, tmp))))*(2099218034)))&(((tmp = -378500985.49700975, tmp)>>(((x+x)|(x%(((-1841907486)<<(-1220613546.194021))<<(tmp = -1260884176, tmp))))^(tmp = 1858784116, tmp)))>>>((x%x)%((x>>>(tmp = -2540799113.7667685, tmp))|x))))/((((tmp = 642072894.6455215, tmp)-(-324951103.6679399))*(tmp = 1424524615, tmp))+((x<<(tmp = -904578863.5945344, tmp))*(tmp = 49233475.435349464, tmp))))))<<(tmp = 1680210257, tmp)))+((tmp = -1516431503, tmp)>>>(-1105406695.3068116)))/(-275019361.6764543))); + assertEquals(192359387.42913792, x /= (-1210234846)); + assertEquals(192359387.42913792, x %= (-2920206625.0154076)); + assertEquals(192359387.42913803, x -= (((((((tmp = -1263203016.3258834, tmp)-(2432034005.6011124))&x)<<(1479434294))>>((tmp = -1695856315.523002, tmp)>>>(tmp = 557391345, tmp)))/(tmp = -1280240246.2501266, tmp))%((tmp = -2196489823.034029, tmp)>>(((x&((912221637.1101809)+((tmp = -3003677979.652423, tmp)>>(tmp = -716129460.1668484, tmp))))-((x+(x-(-2780610859)))>>>(-2445608016)))<<((x*(x+(x+(((-2124412727.9007604)%(tmp = -593539041.5539455, tmp))&(tmp = 2404054468.768749, tmp)))))%(x>>(tmp = -2913066344.404591, tmp))))))); + assertEquals(11740, x >>= (688848398.7228824)); + assertEquals(11740, x >>= ((1545765912)*(307650529.9764147))); + assertEquals(23480, x += x); + assertEquals(0, x >>>= ((tmp = 1313078391, tmp)|x)); + assertEquals(1726251264, x -= ((1939413887)<<(1004888744.2840619))); + assertEquals(765324793.5278986, x %= (960926470.4721014)); + assertEquals(747387, x >>= ((2483010044)-(tmp = -413698190, tmp))); + assertEquals(1, x /= x); + assertEquals(3016811624, x *= (3016811624)); + assertEquals(17408, x &= (((tmp = -991624868, tmp)<<(((63107932)/(tmp = 2659939199, tmp))|(tmp = -1968768911.3575773, tmp)))>>(((-2876822038.9910746)|(tmp = 2550230179.243425, tmp))<<((x*(x<<((x<<((tmp = -1627718523.616604, tmp)|((2154120561.254636)-(x%(x<<(1484563622.1791654))))))<<((((x^(tmp = 3016524169, tmp))<<(((x+(tmp = 1887816698.2455955, tmp))+x)-x))-(-3023329069))-x))))+x)))); + assertEquals(0, x <<= (((1247441062.177967)/(-1717276234))+x)); + assertEquals(0, x |= ((x%((-1648299429.4520087)>>(-137511052)))>>(tmp = 221301016.4926411, tmp))); + assertEquals(0, x /= ((-2598501544.913707)>>>(-2177037696))); + assertEquals(NaN, x %= (x>>x)); + assertEquals(0, x &= (tmp = 1852419158, tmp)); + assertEquals(-829029120, x |= (((2122339180)*((((((tmp = 768748914, tmp)<<((1008490427)&((1937367899.957056)-(((635094486)>>(((tmp = -795046025, tmp)*(2665104134.4455256))^(tmp = 706594584.2462804, tmp)))/(504397522)))))/(-556057788))>>((x/(tmp = -2732280594, tmp))-x))+(-1989667473))+(tmp = 2766802447.789895, tmp)))<<(((tmp = -2969169096, tmp)-x)+(tmp = 2093593159.0942125, tmp)))); + assertEquals(0.6451933462602606, x /= ((-1284931292)<<(x<<(tmp = 1294716764, tmp)))); + assertEquals(1515416866.520901, x *= (2348779440)); + assertEquals(-1620606242886682600, x *= ((-993898625.5357854)&(((tmp = -571100481, tmp)/x)*((2428590177.311031)%(tmp = -2671379453, tmp))))); + assertEquals(-1137472828, x %= (tmp = -1195183004, tmp)); + assertEquals(-3096634005473250000, x *= (tmp = 2722380640, tmp)); + assertEquals(-3096634003996758500, x -= (-1476491033.833419)); + assertEquals(-3096634000805538000, x += (3191220521.978341)); + assertEquals(-3096634000805468000, x += ((((tmp = -3024976741, tmp)&(952616360))|((x*(-1547952311))+(x*x)))>>>(tmp = 981373323, tmp))); + assertEquals(-3096633998655594000, x += (2149873927)); + assertEquals(-118812224101.54297, x %= (((2641881276.9898443)*(((502159480)^x)<<x))%((tmp = -2840045365.547772, tmp)*(((((-2297661528)>>>(x>>(-229103883.94961858)))&(((-1285047374.6746495)<<((-360045084)>>>((x-(tmp = -956123411.1260898, tmp))%x)))>>((tmp = -2375660287.5213504, tmp)+((((tmp = -2753478891, tmp)>>>(((tmp = 101438098, tmp)>>(((tmp = -2736502951, tmp)<<((tmp = -3084561882.368902, tmp)&(tmp = 1491700884, tmp)))|x))&(tmp = 1627412882.6404104, tmp)))>>>(tmp = 1039002116.6784904, tmp))<<((tmp = -2840130800, tmp)-(tmp = -740035567, tmp))))))&(tmp = -416316142, tmp))>>x)))); + assertEquals(86, x >>>= (tmp = -293489896.5572462, tmp)); + assertEquals(172, x += (x%((((-2635082487.364155)|((-2361650420.634912)&(-2147095650.7451198)))<<((tmp = 2258905145.9231243, tmp)%((((tmp = -1365987098.5130103, tmp)*(((((((932437391)/x)/(289270413.0780891))%(x-x))+((((2194986374.917528)>>(((((tmp = -1553805025, tmp)|x)^(((x>>(-564400586.0780811))^(tmp = 1738428582.0238137, tmp))>>(tmp = 1717774140, tmp)))&(tmp = -2789427438, tmp))%(((tmp = -1386118057, tmp)*(-2333221237.7915535))*(x>>>(((((41346648.46438944)&x)%(-478973697.6792319))|(tmp = 2108106738, tmp))/x)))))-(tmp = -133437701.64136505, tmp))>>>x))+(tmp = -1567210003, tmp))*(x+((x&x)-(2942851671)))))>>>(tmp = -446377136, tmp))*((((((tmp = 1597203255, tmp)>>>(619157171))|(-2766246629.005985))>>((tmp = 3130227370, tmp)%x))*(tmp = 2072227901.6101904, tmp))|((tmp = 1369019520, tmp)^(759659487))))))>>>x))); + assertEquals(1996475731, x ^= ((1456327892.2281098)|(1728022827))); + assertEquals(0, x %= x); + assertEquals(0, x &= (1323847974)); + assertEquals(3076829073.8848357, x += (3076829073.8848357)); + assertEquals(9569842648396755000, x *= (3110293883.2782717)); + assertEquals(9569842646260304000, x -= (2136450372.9038036)); + assertEquals(9.158188827418242e+37, x *= x); + assertEquals(0, x <<= ((x&(tmp = -2241179286, tmp))+((tmp = 2553144081, tmp)&((tmp = -1914709694, tmp)^(tmp = -1469651409.0651562, tmp))))); + assertEquals(0, x <<= x); + assertEquals(0, x /= (2177840666.276347)); + assertEquals(0, x %= (-690827104)); + assertEquals(0, x >>>= x); + assertEquals(0, x ^= x); + assertEquals(-0, x /= (tmp = -803415280, tmp)); + assertEquals(-2355576914.316743, x += (-2355576914.316743)); + assertEquals(-833671722514674000, x *= ((3053388806.692315)-(tmp = 2699474775.081724, tmp))); + assertEquals(1, x /= x); + assertEquals(1898147684, x += ((tmp = 1898147683, tmp)|(x<<x))); + assertEquals(2.192324660388075, x %= ((tmp = 2630187518, tmp)/((2868794982.790862)|(490860748)))); + assertEquals(0, x >>>= ((2751021779)/(-952522559))); + assertEquals(321040461, x ^= ((321040461.153594)-x)); + assertEquals(-2.3814602031636922, x /= ((tmp = -170472190, tmp)|x)); + assertEquals(-1, x >>= (2200125174.177402)); + assertEquals(-2964432647.9379396, x += (-2964432646.9379396)); + assertEquals(-370116502.93793964, x %= (tmp = -518863229, tmp)); + assertEquals(777927355.2283959, x -= (-1148043858.1663356)); + assertEquals(0, x *= ((tmp = 1134913539, tmp)&(((x>>>((tmp = -989822787, tmp)>>>x))%x)&(tmp = 1078636160.7313156, tmp)))); + assertEquals(-1089245637, x ^= (3205721659.3548856)); + assertEquals(-1192493056, x <<= (-1173291054)); + assertEquals(78013832, x += ((tmp = 2462999944, tmp)+x)); + assertEquals(0, x %= x); + assertEquals(0, x >>>= (1794908927.7409873)); + assertEquals(1708338504, x += ((-2586628792.3484306)<<x)); + assertEquals(12, x >>= (-545794789.3827574)); + assertEquals(0, x &= ((2753207225)<<(((-1776581207.557251)+((tmp = -2414140402, tmp)*x))+(x<<(x|(tmp = 772358560.3022032, tmp)))))); + assertEquals(0, x <<= ((tmp = -2755724712.152605, tmp)/((x>>(-732875466))&x))); + assertEquals(NaN, x *= (((tmp = 2617815318.1134562, tmp)/x)%(x|((((((-851659337.194871)<<(tmp = 2072294700, tmp))%((x+(2193880878.5566335))^((tmp = 3005338026, tmp)-(2947963290))))/x)/(x+(2091745239.4210382)))-(x>>x))))); + assertEquals(NaN, x /= (tmp = -427684595.0278094, tmp)); + assertEquals(NaN, x /= (tmp = -263945678, tmp)); + assertEquals(0, x <<= x); + assertEquals(0, x <<= x); + assertEquals(0, x -= (((x>>((x&x)-(tmp = -673697315, tmp)))>>(((1575095242.2330558)/(x-(-1816886266)))%(-1580195729)))>>>x)); + assertEquals(0, x >>>= x); + assertEquals(0, x >>= (-2815518206)); + assertEquals(0, x -= (x/(1795634670.692437))); + assertEquals(-2753579891, x += (tmp = -2753579891, tmp)); + assertEquals(2.7773776150171776, x /= (tmp = -991431585, tmp)); + assertEquals(5.554755230034355, x += x); + assertEquals(3.362161997528237e-9, x /= (1652137890.4758453)); + assertEquals(3.362161997528237e-9, x %= (tmp = -10848734.527020693, tmp)); + assertEquals(1, x /= x); + assertEquals(-2978012493, x -= (x+(2978012493))); + assertEquals(-5.158905851797543, x /= (((x+((tmp = -2548840164, tmp)>>x))<<(x^((tmp = -533281232.7294345, tmp)&x)))&(tmp = -1502692171, tmp))); + assertEquals(-5.158905851797543, x %= (-3009435255.5612025)); + assertEquals(-20971520, x <<= ((tmp = -2728812464, tmp)%(2619809573.672677))); + assertEquals(-1900019712, x &= (2398099552)); + assertEquals(-1991377, x %= ((tmp = 1562364373.7334614, tmp)>>>(((x-(-946283217))<<(-2044590694))^(((tmp = 1681238509, tmp)>>(-2801649769))-x)))); + assertEquals(1, x /= x); + assertEquals(1, x %= (x/(x-x))); + assertEquals(1.3525631913093335e-9, x /= (739336991)); + assertEquals(0, x &= ((x&(x|(-1530424204)))<<((((tmp = -295143065.9115021, tmp)>>x)+x)<<x))); + assertEquals(0, x <<= (-1311017801)); + assertEquals(-0, x /= (-667133339.1918633)); + assertEquals(1038307283, x += (1038307283)); + assertEquals(506985, x >>>= ((tmp = 1550624472.9157984, tmp)^x)); + assertEquals(506985, x >>>= ((254646626)<<(tmp = 1572845412.744642, tmp))); + assertEquals(32447040, x <<= (tmp = -2427326042, tmp)); + assertEquals(0, x -= (x<<((x|x)>>>x))); + assertEquals(0, x &= x); + assertEquals(0, x &= ((-484420357)|((tmp = 807540590.6132902, tmp)/(x/x)))); +} +f(); diff --git a/src/3rdparty/v8/test/mjsunit/numops-fuzz-part4.js b/src/3rdparty/v8/test/mjsunit/numops-fuzz-part4.js new file mode 100644 index 0000000..c4ea614 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/numops-fuzz-part4.js @@ -0,0 +1,1177 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +function f() { + var x = 0; + var tmp = 0; + assertEquals(-890607324, x ^= ((tmp = -890607324, tmp)>>((((-2876826295)>>x)<<((tmp = 2351495148.117994, tmp)>>(tmp = 1368611893.274765, tmp)))*(tmp = 1531795251, tmp)))); + assertEquals(-729075363, x += (x+(tmp = 1052139285, tmp))); + assertEquals(531550884933581760, x *= x); + assertEquals(1980836332, x ^= ((-746269795.2320724)-((2400458512)>>((1290672548)>>>((((1536843439.5629003)&(3185059975.158061))*(tmp = -1339249276.2667086, tmp))&x))))); + assertEquals(941373096, x %= ((x+(-451098412))^(tmp = 1725497732, tmp))); + assertEquals(-1766019323, x += (tmp = -2707392419, tmp)); + assertEquals(2528947973, x >>>= (x^(-896237435.3809054))); + assertEquals(-263192576, x <<= (-866361580)); + assertEquals(-2008, x >>= (-2608071791)); + assertEquals(-88, x %= (((-1076807218.4792447)&((tmp = 601044863, tmp)>>((tmp = 1228976729, tmp)+((((-2711426325)*x)|x)|(x%(-2700007330.3266068))))))&(tmp = 3147972836.778858, tmp))); + assertEquals(1762886843, x ^= (tmp = 2532080403, tmp)); + assertEquals(1762886843, x %= ((((((tmp = -2059247788, tmp)>>x)/x)+(x<<x))^x)>>>(-1969283040.3683646))); + assertEquals(4812334726.587896, x += (tmp = 3049447883.587897, tmp)); + assertEquals(1, x /= x); + assertEquals(1, x *= x); + assertEquals(-2150507334, x -= ((tmp = 1578221999, tmp)+(tmp = 572285336, tmp))); + assertEquals(-4546475858941548500, x *= ((tmp = -931533139.5546813, tmp)^(tmp = 3061503275, tmp))); + assertEquals(-269064192, x |= ((207217276.91936445)<<(tmp = -957353678.4997551, tmp))); + assertEquals(1, x /= x); + assertEquals(1, x <<= (((1463856021.8616743)%(x*(tmp = -2286419102, tmp)))/(-2852887593))); + assertEquals(2223868564.8383617, x *= (tmp = 2223868564.8383617, tmp)); + assertEquals(918797189.9033995, x -= ((1305071374.9349623)%(x+(2211992629)))); + assertEquals(-2212004787.4668465, x -= (tmp = 3130801977.370246, tmp)); + assertEquals(31783, x >>= (2951958960)); + assertEquals(31783, x ^= ((((tmp = -2441511566, tmp)&((tmp = 91427553.90168321, tmp)+((tmp = 3001737720.327718, tmp)%x)))>>>(-2263859841))>>>((2109161329)>>(tmp = -2816295136.7443414, tmp)))); + assertEquals(4068224, x <<= (x%((tmp = -682576250.4464607, tmp)*(x/(((x-x)>>>(x&((((x<<(x<<x))>>>((((2243036981.528562)/(((-1839328916.9411087)>>(-1907748022.162144))<<(x+x)))+((tmp = 2362574171, tmp)<<(tmp = 1987834539, tmp)))|(-444329240)))|(399451601.1717081))>>x)))&(968363335.6089249)))))); + assertEquals(0.0030991932898194294, x /= ((tmp = 1067316540.5529796, tmp)^(-2388640366))); + assertEquals(0, x >>= x); + assertEquals(0, x >>>= (tmp = -393433349.1636851, tmp)); + assertEquals(0, x *= (((x^(((1806955787.471396)<<x)^((517668047.55566347)>>>(x%(x<<(tmp = -276586733.4844558, tmp))))))%(1661242196.1472542))|x)); + assertEquals(0, x |= (x>>x)); + assertEquals(-155236210, x |= (tmp = -155236210.19366312, tmp)); + assertEquals(-606392, x >>= ((tmp = -1533446042.97781, tmp)^x)); + assertEquals(-1, x >>= (936126810)); + assertEquals(2325115611, x -= (-2325115612)); + assertEquals(0, x -= x); + assertEquals(0, x >>= (tmp = -354826623, tmp)); + assertEquals(-0, x *= (-1232528947.7321298)); + assertEquals(0, x |= x); + assertEquals(0, x <<= (((tmp = 187758893.4254812, tmp)&(x-(tmp = 648201576, tmp)))&(385106597))); + assertEquals(0, x >>= (tmp = 2554891961, tmp)); + assertEquals(-1311492611.2970417, x += (-1311492611.2970417)); + assertEquals(-688179220.3221785, x += (623313390.9748632)); + assertEquals(1416835528, x &= (tmp = 1953739224, tmp)); + assertEquals(-11.04719252755072, x /= (-128252995)); + assertEquals(-6.287413042114223e-9, x /= (tmp = 1757033052.1558928, tmp)); + assertEquals(-4231171, x |= (((((2022730885.7773404)*((-2495777565.221855)|(tmp = 274627292, tmp)))<<(-3072596920.4902725))>>>((-2215057529)+(-1134713759.4247034)))^((tmp = -1888181788, tmp)/(572025985.2748461)))); + assertEquals(-4194305, x |= ((tmp = 167328318.038759, tmp)>>>(153800904.34551537))); + assertEquals(-1316525687, x -= (1312331382)); + assertEquals(1448723245.7863903, x += (2765248932.7863903)); + assertEquals(1.7219707102205526, x /= (tmp = 841317008, tmp)); + assertEquals(1872027792.5217001, x *= (x|(tmp = 1087142645.6665378, tmp))); + assertEquals(3504488055973669400, x *= x); + assertEquals(-1075254784, x |= x); + assertEquals(-5, x >>= (((844461331.8957539)-((x&x)<<((tmp = 1443904777, tmp)+(tmp = 736164505.3670597, tmp))))-(((tmp = 1348422110, tmp)>>((tmp = -2878252514, tmp)/(-1175443113)))|((-2138724317)%(2057081133))))); + assertEquals(-3.038875804165675e-9, x /= (1645345292.8698258)); + assertEquals(1.25204541454491e-18, x /= (-2427129055.274914)); + assertEquals(-1.7151576137235622e-9, x *= (-1369884505.6247284)); + assertEquals(1590804618, x ^= (1590804618.4910607)); + assertEquals(5061318665300252000, x *= (x+x)); + assertEquals(5061318665300252000, x %= ((tmp = 1102144242, tmp)*x)); + assertEquals(-7, x >>= (2772167516.624264)); + assertEquals(16383, x >>>= (-2979259214.5855684)); + assertEquals(47108415435, x *= ((2944456517.839616)>>>(1041288554.5330646))); + assertEquals(61, x >>>= (x^(((-1305163705)<<((948566605)-x))-x))); + assertEquals(0, x %= x); + assertEquals(0, x ^= (((tmp = 1918861879.3521824, tmp)/((x%(tmp = 945292773.7188392, tmp))%(x|x)))>>x)); + assertEquals(-0, x *= ((((x|((2810775287)|(tmp = 1265530406, tmp)))^((tmp = 3198912504.175658, tmp)-(((tmp = 1422607729.281712, tmp)<<(tmp = 2969836271.8682737, tmp))&x)))<<((tmp = 844656612, tmp)*(((((tmp = -828311659, tmp)%(((-2083870654)>>>(x^(((((933133782)-(tmp = 1033670745, tmp))-(629026895.4391923))%((-605095673.8097742)*((((-227510375.38460112)*x)+x)&(((((tmp = 472873752.68609154, tmp)^(tmp = 2815407038.712165, tmp))+((x>>>((tmp = -1331030665.3510115, tmp)>>>(2281234581)))-(x>>>x)))&(tmp = -2160840573.325921, tmp))&x))))<<(tmp = 1411888595, tmp))))|(((tmp = -915703839.0444739, tmp)/((x+(418836101.8158506))%(-1112605325.4404268)))&((-3098311830.6721926)-x))))-((49446671.477988124)*(-2522433127)))+((tmp = 443068797, tmp)>>(tmp = 418030554.97275746, tmp)))*((tmp = 38931296.738208175, tmp)+(1842742215.3282685)))))-((tmp = 1325672181.205841, tmp)^(tmp = 669284428, tmp)))); + assertEquals(-0, x *= (tmp = 93843030, tmp)); + assertEquals(0, x ^= x); + assertEquals(0, x ^= x); + assertEquals(0, x <<= x); + assertEquals(0, x >>>= (x%((((((tmp = -107458601, tmp)>>(x*((x|((tmp = 2117286494, tmp)>>((x^(tmp = 114214295.42048478, tmp))>>>(tmp = 1032826615, tmp))))&((x*x)&(-225386977.67686415)))))^((-780566702.5911419)+(-1113319771)))|(((x^x)<<(1288064444))>>(-2292704291.619477)))>>(365125945))-((tmp = -1986270727.235776, tmp)/x)))); + assertEquals(-0, x *= (((-18925517.67125845)|((((-1975220517)+(tmp = -1250070128.296064, tmp))+(1085931410.5895243))<<(((x|(((x*(tmp = 160207581.50536323, tmp))|(tmp = 1798744469.7958293, tmp))-x))>>>(((x+((x%x)&((((x^x)<<((tmp = 2538012074.623554, tmp)^x))*x)&x)))/(x+(tmp = -2563837407, tmp)))/(tmp = 2189564730, tmp)))/(((-1703793330.5770798)<<((176432492)|x))<<(1347017755.345185)))))<<(((tmp = -577100582.7258489, tmp)&x)/(-31246973)))); + assertEquals(0, x >>>= x); + assertEquals(NaN, x %= ((x*(tmp = 1167625971, tmp))&(((tmp = -770445060, tmp)>>((339248786)^((2058689781.2387645)-((-2381162024)*(660448066)))))&x))); + assertEquals(NaN, x += ((3088519732.515986)-(-267270786.06493092))); + assertEquals(0, x &= (tmp = 2748768426.3393354, tmp)); + assertEquals(-1109969306, x ^= ((-1109969306)>>>x)); + assertEquals(-1109969306, x %= (tmp = 1150376563.581773, tmp)); + assertEquals(-2058145178, x &= (-2057586057)); + assertEquals(-850185626, x |= ((x^(tmp = 1223093422, tmp))&((-589909669)<<(2299786170)))); + assertEquals(1489215443, x += (2339401069)); + assertEquals(-23592960, x <<= x); + assertEquals(2063937322, x ^= (-2053296342.2317986)); + assertEquals(12922122, x %= (x^((-2259987830)>>(x*(((tmp = -799867804.7716949, tmp)&(tmp = -1068744142, tmp))*(((((1091932754.8596292)-((tmp = -1778727010, tmp)>>(((tmp = 1207737073.2689717, tmp)-(x-(tmp = -1191958946, tmp)))+(-631801383.7488799))))-(-618332177))>>>(-156558558))>>>(3032101547.6262517))))))); + assertEquals(12922122, x &= x); + assertEquals(Infinity, x /= (x%x)); + assertEquals(0, x &= (x*(-227800722.62070823))); + assertEquals(-865648691, x ^= (-865648691)); + assertEquals(1, x /= (x%(tmp = 1524739353.8907173, tmp))); + assertEquals(16, x <<= (x<<(2335214658.789205))); + assertEquals(0, x &= ((tmp = 570332368.1239192, tmp)^(-2278439501))); + assertEquals(1881145344, x -= (((-569715735.8853142)+(2093355159))<<(tmp = 2788920949, tmp))); + assertEquals(0, x ^= x); + assertEquals(NaN, x -= ((tmp = -1427789954, tmp)%((((((411038329.49866784)-x)-(x<<((-1330832247)+x)))/x)^((x*(845763550.2134092))>>(tmp = 1427987604.5938706, tmp)))>>>(1857667535)))); + assertEquals(NaN, x /= (-313793473)); + assertEquals(0, x >>>= (x/x)); + assertEquals(1869358566, x -= (-1869358566)); + assertEquals(-1901664519209545200, x += ((tmp = 944729941.3936644, tmp)*(-2012918653))); + assertEquals(-1901664519209545200, x += ((tmp = 1348246793, tmp)/(x&x))); + assertEquals(-1576791552, x &= (tmp = 2719250966.739456, tmp)); + assertEquals(-305087899, x ^= (-2955630491.030272)); + assertEquals(0, x ^= (x%(1575252839.559443))); + assertEquals(4184604407, x += ((((tmp = -244720076.17657042, tmp)|(2819320515))^((((tmp = 1222623743.9184055, tmp)*(-95662379.577173))/(x/(x+(((x-(tmp = -3024718107.6310973, tmp))^(-1494390781))&(tmp = 2284054218.8323536, tmp)))))>>>(tmp = 2090069761, tmp)))>>>(x%x))); + assertEquals(3148907440, x -= (((tmp = -332379100.7695112, tmp)-(-1145399547))^(((((((tmp = 3133792677.785844, tmp)+x)<<(2306999139.5799255))>>((tmp = -2051266106, tmp)*(((((x+(((-728654312.8954825)>>(x>>>(((x%x)&(-1587152364))|(((((-2114138294)&x)&(1547554688))^x)-(-1856094268)))))*(((-1135018784)&((x+(tmp = -1444020289, tmp))|x))+x)))>>x)&x)/(2449005489))<<((131073798.64314616)%(x>>>((-2592101383.2205048)^(tmp = -757096673.0381112, tmp)))))))^(2766467316.8307915))-(-2465892914.515834))-((((tmp = 234064056, tmp)^((x>>>(1622627548.7944543))+(-1750474146)))|(-1959662039.4687617))^((-1222880974)&(-2794536175.906498)))))); + assertEquals(-1157627488, x &= (-1156639323)); + assertEquals(-1342170624, x <<= ((x/((((1829945345.0613894)/(x*((tmp = 1278865203.0854595, tmp)/(((tmp = -2298274086.519347, tmp)+(tmp = -545203761, tmp))-(tmp = 2712195820, tmp)))))>>>((tmp = 240870798.9384452, tmp)-(tmp = -3188865300.4768195, tmp)))>>>(x%((648799266)>>>(tmp = 24460403.864815235, tmp)))))|((tmp = 232533924, tmp)|x))); + assertEquals(-2684341248, x += x); + assertEquals(1073755136, x &= (((-662718514.9245079)>>(tmp = -1915462105, tmp))+(tmp = 1478850441.8689613, tmp))); + assertEquals(-1073755136, x /= (x|((tmp = -1767915185, tmp)|((325827419.1430224)|(((-1343423676)|(tmp = -1929549501, tmp))|(-866933068.9585254)))))); + assertEquals(-1073755136, x %= ((tmp = 547342356, tmp)-((tmp = 2213249646.7047653, tmp)-((((((-2463314705)^(tmp = -993331620, tmp))^(((x%x)>>(tmp = 1798026491.3658786, tmp))-(((1024072781)/(tmp = -2407354455, tmp))%(1973295010))))<<(-1966787233))^x)|(-1787730004))))); + assertEquals(-1073754452, x |= (tmp = 3099823788.077907, tmp)); + assertEquals(-1540683096, x &= (-1540674632.7013893)); + assertEquals(-1540683052, x ^= ((tmp = -126183090, tmp)>>>((-622437575.5788481)|((((tmp = -2947914022, tmp)%(((tmp = 2512586745, tmp)>>x)>>>((27238232.23677671)/(tmp = 3203958551, tmp))))/(tmp = 2906005721.402535, tmp))^((((tmp = 1763897860.737334, tmp)^(1445562340.2485332))/x)+(-2393501217.716533)))))); + assertEquals(-1258599433, x |= (tmp = 351291767.59661686, tmp)); + assertEquals(-1241560065, x |= (626346046.5083935)); + assertEquals(-1241560065, x ^= ((2263372092)/((tmp = -2868907862, tmp)>>>x))); + assertEquals(-893685228, x -= (tmp = -347874837, tmp)); + assertEquals(3401282068, x >>>= (x*x)); + assertEquals(0, x %= x); + assertEquals(0, x >>>= x); + assertEquals(-2079237393, x ^= (tmp = 2215729903, tmp)); + assertEquals(NaN, x %= ((((tmp = 3203450436, tmp)/(2867575150.6528325))&(1864945829))&((x&((((tmp = -1927086741.3438427, tmp)|x)|(-1783290909.3240588))*((-1074778499.0697656)*(x-((tmp = -848983542.8456669, tmp)^(tmp = -1324673961, tmp))))))>>(tmp = -2144580304.245896, tmp)))); + assertEquals(-43334009, x |= (x^(-43334009.72683525))); + assertEquals(-43334009, x &= x); + assertEquals(-43334009, x %= (tmp = 1252450645.060542, tmp)); + assertEquals(-43334009, x |= (((((((tmp = 968062202, tmp)/(x|(tmp = 2766801984, tmp)))*((2173353793.938968)>>(((tmp = -2459317247, tmp)<<(tmp = -2333601397, tmp))>>>((tmp = -578254251.8969193, tmp)*(tmp = 839964110.7893236, tmp)))))&(((1675305119)&(tmp = -929153707, tmp))*((x*x)*x)))/x)|(x/(tmp = 384740559.43867135, tmp)))%(1657362591))); + assertEquals(0, x -= x); + assertEquals(0, x %= (-1334758781.1087842)); + assertEquals(0, x -= x); + assertEquals(-54, x += ((tmp = -1787151355.470972, tmp)>>((tmp = 237028977, tmp)>>(((2829473542)<<(x>>>(((((((x-(-1950724753))*(((x>>>(2807353513.6283565))<<((-583810779.1155353)>>(x*x)))>>(-1068513265)))^(x^(-696263908.5131407)))%(((tmp = -1325619399, tmp)<<((tmp = -1030194450, tmp)-x))^x))+((-2852768585.3718724)>>(tmp = -3160022361, tmp)))%(x&x))>>(tmp = 2667222702.5454206, tmp))))+((804998368.8915854)<<x))))); + assertEquals(-54, x %= (-1601267268.4306633)); + assertEquals(1, x >>>= (tmp = -543199585.579128, tmp)); + assertEquals(4.732914708226396e-10, x /= (tmp = 2112862922, tmp)); + assertEquals(-4266932650, x -= ((((x^((((tmp = 2784618443, tmp)^(tmp = -2271260297.9010153, tmp))|((((tmp = -599752639.7516592, tmp)*(2751967680.3680997))^(tmp = -1478450055.578217, tmp))*x))-x))&((tmp = -520061982, tmp)-((tmp = 1400176711.9637299, tmp)^(((2100417541)|(x+(tmp = -674592897.0420957, tmp)))>>x))))^(tmp = -365650686.7947228, tmp))>>>((-2943521813)&(((tmp = -1888789582, tmp)>>(tmp = 700459655.488978, tmp))+(tmp = -1725725703.655931, tmp))))); + assertEquals(224277168, x <<= (tmp = 2885115011.8229475, tmp)); + assertEquals(224277168, x %= (tmp = -2655345206.442777, tmp)); + assertEquals(850395136, x <<= (x-(((((-769868538.1729524)/((tmp = -298603579, tmp)%(x^x)))+((2691475692)|(((x>>>(628995710.4745524))^(x<<(((tmp = -1046054749, tmp)|(919868171))-x)))^((-1377678789.8170452)&((3065147797)%(tmp = 2638804433, tmp))))))^(tmp = -2036295169, tmp))&(((tmp = -157844758.08476114, tmp)*(tmp = -2819601496, tmp))&((((tmp = 78921441, tmp)<<(653551762.5197772))/(1801316098))*(-1479268961.8276927)))))); + assertEquals(1645565728, x ^= (tmp = 1353013024, tmp)); + assertEquals(1645565728, x >>>= x); + assertEquals(3020513544, x += (1374947816)); + assertEquals(0, x %= x); + assertEquals(0, x %= ((((((tmp = -304228072.4115715, tmp)>>>((-90523260.45975709)-(tmp = -3013349171.084838, tmp)))%((-1640997281)*((tmp = -1600634553, tmp)%((tmp = 557387864, tmp)<<((888796080.766409)|(x^((((x%(((((tmp = 1164377954.1041703, tmp)*x)|(2742407432.192806))&((tmp = 1707928950, tmp)<<(1279554132.4481683)))+(tmp = -2108725405.7752397, tmp)))%(tmp = -465060827, tmp))^((tmp = 2422773793, tmp)+x))^((((((((tmp = -1755376249, tmp)^((-267446806)^x))/(((tmp = -1808578662.4939392, tmp)+((tmp = -1997100217, tmp)+x))+(((tmp = -2469853122.411479, tmp)/x)>>(tmp = 660624616.7956645, tmp))))%((x<<((((((tmp = -1701946558, tmp)-(tmp = 133302235, tmp))>>>x)/(738231394))<<(-1060468151.4959564))&(((((-1877380837.4678264)|(tmp = 2366186363, tmp))%x)>>>(-2382914822.1745577))>>((-1874291848.9775913)<<(tmp = 2522973186, tmp)))))<<(-2672141993)))|(tmp = 732379966, tmp))%x)^x)^x))))))))%(tmp = 2385998902.7287374, tmp))*x)+(tmp = -2195749866.017106, tmp))); + assertEquals(401488, x ^= (((-320896627)>>>(tmp = 2812780333.9572906, tmp))&(tmp = -2088849328, tmp))); + assertEquals(-1661116571.0046256, x += (tmp = -1661518059.0046256, tmp)); + assertEquals(-1616122720, x <<= x); + assertEquals(-1616122720, x >>= x); + assertEquals(-390439413, x %= (tmp = -1225683307, tmp)); + assertEquals(-84189205, x |= ((x|(2054757858))^(((x<<(((x|x)|(((x>>>((-2938303938.1397676)<<((2993545056)^((tmp = -643895708.5427527, tmp)/((1371449825.5345795)-(1896270238.695752))))))-(tmp = 1061837650, tmp))+(x+(tmp = 3072396681, tmp))))>>(x-((((tmp = -1877865355.1550744, tmp)&x)%(-2766344937))>>>(2055121782)))))-((x<<x)|(tmp = -2742351880.1974454, tmp)))<<((-2600270279.219802)>>(-1625612979))))); + assertEquals(-168378410, x += x); + assertEquals(-168378410, x &= x); + assertEquals(-1534983792, x &= (-1501412943)); + assertEquals(-1821543761, x ^= (938439487)); + assertEquals(-1821543761, x &= (x^(((tmp = -4237854, tmp)>>x)/x))); + assertEquals(2358, x >>>= (2954252724.620632)); + assertEquals(4716, x <<= ((-75522382.8757689)/((tmp = 1074334479, tmp)|((tmp = -720387522, tmp)>>(x>>>(-3085295162.6877327)))))); + assertEquals(-1313079316, x |= (2981887904.020387)); + assertEquals(-1957790646, x -= (644711330)); + assertEquals(17831, x >>>= ((tmp = -2550108342, tmp)-(((tmp = 454671414.0146706, tmp)+(-661129693.9333956))>>(x>>>(((tmp = 1752959432.3473055, tmp)*(-2619510342.1812334))%(tmp = -456773274.2411971, tmp)))))); + assertEquals(689287937.6879716, x -= ((tmp = -397126863.6879716, tmp)-(((x>>x)^(x/(-1387467129.6278908)))|((x>>((tmp = -2361114214.8413954, tmp)<<(tmp = -805670024.4717407, tmp)))<<(-2724018098))))); + assertEquals(1378575875.3759432, x += x); + assertEquals(84112428460187.8, x *= (((((2681425112.3513584)%(tmp = -1757945333, tmp))|x)>>(-1793353713.0003397))%x)); + assertEquals(-3221, x >>= (-1976874128)); + assertEquals(-3221, x %= (((tmp = 2318583056.834932, tmp)|((tmp = -1016115125, tmp)+((-472566636.32567954)+x)))|(tmp = 3135899138.065598, tmp))); + assertEquals(-6596608, x <<= x); + assertEquals(-1249902592, x <<= (((tmp = -2025951709.5051148, tmp)/((-465639441)<<(-2273423897.9682302)))*((tmp = -2408892408.0294642, tmp)-(tmp = 1017739741, tmp)))); + assertEquals(73802092170444800, x *= (tmp = -59046275, tmp)); + assertEquals(-1619001344, x <<= x); + assertEquals(0, x <<= (tmp = 1610670303, tmp)); + assertEquals(-0, x *= ((((x+(tmp = 2039867675, tmp))|(tmp = 399355061, tmp))<<(1552355369.313559))^x)); + assertEquals(0, x *= x); + assertEquals(0, x >>>= (((2875576018.0610805)>>x)%(tmp = -2600467554, tmp))); + assertEquals(2290405226.139538, x -= (-2290405226.139538)); + assertEquals(0, x %= x); + assertEquals(0, x ^= (((tmp = 2542309844.485515, tmp)-x)%((-2950029429.0027323)/(tmp = 2943628481, tmp)))); + assertEquals(0, x += x); + assertEquals(0, x -= x); + assertEquals(0, x >>>= (tmp = 2337330038, tmp)); + assertEquals(0, x += (x/(((292272669.0808271)&(tmp = 2923699026.224247, tmp))^(tmp = 367745855, tmp)))); + assertEquals(0, x &= x); + assertEquals(0, x %= ((tmp = 1565155613.3644123, tmp)<<(-308403859.5844681))); + assertEquals(-1845345399.3731332, x += (tmp = -1845345399.3731332, tmp)); + assertEquals(5158590659731951000, x *= (-2795460763.8680177)); + assertEquals(-364664, x >>= (1837745292.5701954)); + assertEquals(1, x /= x); + assertEquals(-860616114.8182092, x += ((tmp = 2076961323.1817908, tmp)+(-2937577439))); + assertEquals(-860616115, x ^= ((x*(tmp = 2841422442.583121, tmp))>>>((tmp = 1929082917.9039137, tmp)>>(-2602087246.7521305)))); + assertEquals(-38387843, x |= (3114677624)); + assertEquals(2927507837, x += (tmp = 2965895680, tmp)); + assertEquals(1, x /= x); + assertEquals(-1792887531, x *= (-1792887531)); + assertEquals(-0, x %= ((x^x)+x)); + assertEquals(-0, x %= (tmp = 2800752702.562547, tmp)); + assertEquals(1384510548, x ^= (tmp = 1384510548, tmp)); + assertEquals(42251, x >>= (1645421551.363844)); + assertEquals(0, x >>>= (17537561)); + assertEquals(-2076742862, x ^= (tmp = 2218224434, tmp)); + assertEquals(-2.790313825067623, x /= (744268563.3934636)); + assertEquals(5313538, x &= (((((tmp = -2406579239.0691676, tmp)+((-1470174628)+(((tmp = -783981599, tmp)<<(tmp = -1789801141.272646, tmp))^(((((((tmp = -844643189.5616491, tmp)&(tmp = -252337862, tmp))&(x|x))%((-3159642145.7728815)+(tmp = 2149920003.9525595, tmp)))&(x>>(1737589807.9431858)))-((((((((1610161800)<<(497024994))>>x)<<x)/x)>>>x)&x)-(757420763.2141517)))-(tmp = -3061016994.9596977, tmp)))))/(tmp = 1810041920.4089384, tmp))&(tmp = 5887654.786785364, tmp))&((tmp = 1626414403.2432103, tmp)+(x%x)))); + assertEquals(-2147483648, x <<= (tmp = 1304102366.8011155, tmp)); + assertEquals(-208418816, x %= (((((-2850404799)*(x+(3158771063.226051)))*(-2017465205))/(x>>x))>>(x%(tmp = 2760203322, tmp)))); + assertEquals(-2189223477, x -= (1980804661)); + assertEquals(-859239912, x ^= (tmp = 2974421971.3544703, tmp)); + assertEquals(-1599850415, x ^= (tmp = -2475871671.140151, tmp)); + assertEquals(-1600636847, x += ((((tmp = -1311002944, tmp)<<((tmp = -1137871342, tmp)<<(tmp = 115719116, tmp)))/(413107255.6242596))<<(x>>((((-1908022173)&(((-1519897333)^((x>>(x*(tmp = -2886087774.426503, tmp)))*(tmp = 530910975, tmp)))+(-2579617265.889692)))+((2518127437.127563)>>>((tmp = 481642471.56441486, tmp)>>>(792447239))))^(x<<(248857393.6819017)))))); + assertEquals(-191, x >>= (-1591265193)); + assertEquals(-192.27421813247196, x += ((tmp = 2627329028.207775, tmp)/(tmp = -2061914644.9523563, tmp))); + assertEquals(1230613220, x ^= (tmp = 3064354212.307105, tmp)); + assertEquals(1230613220, x &= x); + assertEquals(1230613220, x %= (1833479205.1064768)); + assertEquals(1230613220, x >>>= ((((1559450742.1425748)|((2151905260.956583)*(1213275165)))%(514723483.12764716))>>>x)); + assertEquals(1230613493, x |= ((((3004939197.578903)*(tmp = -576274956, tmp))+((tmp = 1037832416.2243971, tmp)^x))>>>(tmp = 2273969109.7735467, tmp))); + assertEquals(2461226986, x += x); + assertEquals(-27981, x >>= ((692831755.8048055)^((tmp = -1593598757, tmp)%(x-((((-1470536513.882593)|((tmp = -2716394020.466401, tmp)|(tmp = 2399097686, tmp)))&x)%x))))); + assertEquals(-1.4660454948034359e+23, x *= (((x>>>((((((tmp = -3056016696, tmp)<<(-2882888332))*(2041143608.321916))&(((tmp = -634710040, tmp)|(tmp = -2559412457, tmp))>>(1916553549.7552106)))%((-2150969350.3643866)*x))<<((x*(tmp = 2657960438.247278, tmp))|x)))%((tmp = 526041379, tmp)*(tmp = 2514771352.4509397, tmp)))*(1219908294.8107886))); + assertEquals(-1.4660454948034359e+23, x -= ((1709004428)>>(((x|(-422745730.626189))%x)>>x))); + assertEquals(-2247766068, x %= (-3105435508)); + assertEquals(-386845856.0649812, x -= (-1860920211.9350188)); + assertEquals(-386846803.0649812, x -= ((((-3214465921)|((tmp = -1326329034, tmp)+(((tmp = -1203188938.9833462, tmp)%((((((-1318276502)+(x+x))^((x<<x)%(x>>>x)))+(tmp = -439689881, tmp))+((-1455448168.695214)^(x-((-388589993)>>((((940252202)^(-2218777278))|x)/(tmp = -1007511556, tmp))))))&(-140407706.28176737)))-(x/((888903270.7746506)-((tmp = -2885938478.632409, tmp)<<(((((tmp = -1750518830.270917, tmp)>>(((((((tmp = 868557365.7908674, tmp)/(tmp = -2805687195.5172157, tmp))*x)|((((((-1342484550)-((tmp = 1089284576, tmp)^(tmp = 120651272, tmp)))<<(tmp = 2230578669.4642825, tmp))-(x*x))%(x^(((tmp = -3177941534, tmp)+(x>>(-1595660968)))/(-1738933247))))>>>(tmp = 2860175623, tmp)))-(((2392690115.8475947)>>>(tmp = -1754609670.2068992, tmp))>>>(tmp = 2615573062, tmp)))-(tmp = 2590387730, tmp))^((x+((((x-(tmp = -2823664112.4548965, tmp))*(200070977))>>>(((x|((((tmp = 1361398, tmp)>>((tmp = 1649209268, tmp)%x))+x)+(x>>>(tmp = -2379989262.1245675, tmp))))|(x^((tmp = -647953298.7526417, tmp)-x)))&(tmp = -1881232501.1945808, tmp)))>>>x))%(x^(tmp = -1737853471.005935, tmp)))))>>>(427363558))>>>((tmp = -3076726422.0846386, tmp)^(-1518782569.1853383)))/x)))))))|x)>>>(1854299126))); + assertEquals(-386846803.0649812, x -= (x%x)); + assertEquals(238532, x >>>= (-448890706.10774803)); + assertEquals(232, x >>>= (-791593878)); + assertEquals(232, x <<= (((x^((x-x)&(tmp = 1219114201, tmp)))/(tmp = -427332955, tmp))%(tmp = 1076283154, tmp))); + assertEquals(210, x ^= (x>>>((2975097430)>>>x))); + assertEquals(1, x /= x); + assertEquals(2317899531, x *= (2317899531)); + assertEquals(1131786, x >>>= x); + assertEquals(2301667519.6379366, x += ((tmp = 193109669.63793683, tmp)+(tmp = 2107426064, tmp))); + assertEquals(3842614963.6379366, x += (((-1676516834)>>>(tmp = -1817478916.5658965, tmp))^(((tmp = 1122659711, tmp)>>>(tmp = -2190796437, tmp))|(tmp = -2754023244, tmp)))); + assertEquals(-452352333, x &= x); + assertEquals(-863, x >>= x); + assertEquals(-3.777863669459606e-7, x /= (2284359827.424491)); + assertEquals(-3.777863669459606e-7, x %= ((tmp = -2509759238, tmp)>>>x)); + assertEquals(0, x <<= (-814314066.6614306)); + assertEquals(0, x %= (tmp = 190720260, tmp)); + assertEquals(2301702913, x += (2301702913)); + assertEquals(-249158048, x >>= (tmp = -2392013853.302008, tmp)); + assertEquals(-249158048, x >>= x); + assertEquals(-498316096, x += x); + assertEquals(-498316096, x %= (tmp = 2981330372.914731, tmp)); + assertEquals(106616.2199211318, x *= (((((tmp = 1020104482.2766557, tmp)^((tmp = -416114189.96786, tmp)>>>(1844055704)))|(tmp = 1665418123, tmp))>>(1826111980.6564898))/(-2446724367))); + assertEquals(106616, x |= x); + assertEquals(1094927345, x -= (((-1229759420)|(741260479.7854375))-x)); + assertEquals(8353, x >>= x); + assertEquals(0, x >>>= (tmp = -327942828, tmp)); + assertEquals(-953397616.8888416, x += (tmp = -953397616.8888416, tmp)); + assertEquals(-1906641240.7776833, x += (x+((-3033450184.9106326)>>>(tmp = 2090901325.5617187, tmp)))); + assertEquals(-1906641240.7776833, x %= (tmp = 2584965124.3953505, tmp)); + assertEquals(-1098907671, x |= (tmp = -1272590495, tmp)); + assertEquals(-1.8305258600334393, x /= (600323489)); + assertEquals(-1, x &= x); + assertEquals(-1, x |= ((x+x)-x)); + assertEquals(1, x *= x); + assertEquals(867473898, x ^= (tmp = 867473899.0274491, tmp)); + assertEquals(6, x >>>= (tmp = 1174763611.341228, tmp)); + assertEquals(0, x >>= ((689882795)^(2250084531))); + assertEquals(0, x /= (tmp = 2545625607, tmp)); + assertEquals(0, x >>= x); + assertEquals(0, x += x); + assertEquals(0, x -= (x*(-1098372339.5157008))); + assertEquals(NaN, x %= x); + assertEquals(NaN, x -= (tmp = -1797344676.375759, tmp)); + assertEquals(1121476698, x |= (tmp = 1121476698, tmp)); + assertEquals(1, x /= x); + assertEquals(1, x &= (-191233693)); + assertEquals(330137888.92595553, x += (330137887.92595553)); + assertEquals(-1792236714, x ^= (tmp = 2256609910, tmp)); + assertEquals(269000724, x &= (316405813.62093115)); + assertEquals(256, x >>= x); + assertEquals(256, x %= ((2556320341.54669)|(1066176021.2344948))); + assertEquals(256, x |= x); + assertEquals(131072, x <<= ((-1650561175.8467631)|x)); + assertEquals(-286761951, x -= ((tmp = 287024095, tmp)-((-2293511421)&(x|x)))); + assertEquals(-1561852927, x &= (3002663949.0989227)); + assertEquals(-460778761, x %= (tmp = -550537083, tmp)); + assertEquals(-3023749308.0492287, x += (tmp = -2562970547.0492287, tmp)); + assertEquals(-481313332.04922867, x %= ((x|((tmp = -855929299, tmp)%((2181641323)%(x|(220607471.33018696)))))&x)); + assertEquals(17510668, x &= (tmp = 363557663, tmp)); + assertEquals(12552, x &= (3020225307)); + assertEquals(1814655896, x |= ((x<<(((-1475967464)*(-3122830185))*x))+(x^(-2480340864.2661023)))); + assertEquals(-3209124403525266400, x -= ((1146847590)*(tmp = 2798213497, tmp))); + assertEquals(-6418248807050533000, x += x); + assertEquals(1.1856589432073933e+28, x *= (-1847324681.313275)); + assertEquals(-1238853292, x ^= (-1238853292)); + assertEquals(-77428331, x >>= (x&((((2043976651.8514216)>>>x)^(x>>>(((tmp = -1785122464.9720652, tmp)%x)<<(1570073474.271266))))*x))); + assertEquals(2011, x >>>= x); + assertEquals(2011, x &= x); + assertEquals(0, x >>= (-2682377538)); + assertEquals(-1.1367252770299785, x -= (((tmp = 2704334195.566802, tmp)/(2379056972))%((((-1764065164)*((((468315142.8822602)>>((x%(((tmp = 2537190513.506641, tmp)+((x&(x|((tmp = -947458639, tmp)^(2653736677.417406))))*((x<<((1243371170.1759553)>>>(((tmp = 1572208816, tmp)<<((tmp = 963855806.1090456, tmp)>>>x))%((-3078281718.7743487)*x))))^(-1154518374))))^(-2839738226.6314087)))^((-2865141241.190915)*(-2400659423.8207664))))>>((tmp = 32940590, tmp)/(tmp = 2917024064.570817, tmp)))+(((27601850)/(tmp = 3168834986, tmp))>>x)))+(tmp = 2528181032.600125, tmp))/(3162473952)))); + assertEquals(-1697395408.7948515, x -= (1697395407.6581264)); + assertEquals(1536992607912062500, x *= (tmp = -905500627.5781817, tmp)); + assertEquals(102759872, x >>= (tmp = -707887133.4484048, tmp)); + assertEquals(102759872, x %= (tmp = -1764067619.7913327, tmp)); + assertEquals(12543, x >>>= (-144142995.1469829)); + assertEquals(-2059555229.2592103, x += ((-2059555229.2592103)-x)); + assertEquals(-537022593, x |= (tmp = -2770761410.407701, tmp)); + assertEquals(23777505, x ^= (-560496738.6854918)); + assertEquals(-64329014115772310, x *= ((tmp = -2729234369.198843, tmp)+x)); + assertEquals(189083830, x ^= (tmp = 933619934, tmp)); + assertEquals(189083830, x %= ((tmp = -2918083254, tmp)-(x|(x^(-2481479224.0329475))))); + assertEquals(378167660, x += x); + assertEquals(-0.45833387791900504, x /= ((tmp = 2727991875.241294, tmp)<<(tmp = 2570034571.9084663, tmp))); + assertEquals(0, x <<= x); + assertEquals(-0, x /= (tmp = -67528553.30662966, tmp)); + assertEquals(0, x <<= (938440044.3983492)); + assertEquals(-945479171, x ^= (tmp = -945479171, tmp)); + assertEquals(-225632619284361200, x *= (238643670.00884593)); + assertEquals(-0, x %= x); + assertEquals(-585826304, x ^= ((-1256265560)<<(tmp = 1144713549, tmp))); + assertEquals(-671583855, x ^= (183333265.1468178)); + assertEquals(-484311040, x <<= x); + assertEquals(-3969762.62295082, x /= ((((tmp = -1164308668.931008, tmp)-x)%x)>>>(((397816647)>>(-1605343671.4070785))<<x))); + assertEquals(758097879, x ^= ((tmp = -2871307491, tmp)^(-2043176492.646442))); + assertEquals(0, x *= ((x>>(tmp = 1983292927, tmp))&(tmp = -860505131.4484091, tmp))); + assertEquals(0, x <<= x); + assertEquals(0, x &= x); + assertEquals(0, x %= ((3132981707)-(-2832016477))); + assertEquals(0, x >>= (x<<((1830195133.0342631)>>>(tmp = -1003969250, tmp)))); + assertEquals(NaN, x %= x); + assertEquals(NaN, x += (tmp = 273271019.87603223, tmp)); + assertEquals(NaN, x += (625749326.1155348)); + assertEquals(0, x >>= (tmp = -531039433.3702333, tmp)); + assertEquals(0, x -= (((tmp = 2029464099, tmp)-(x-(tmp = -329058111.411458, tmp)))*(x<<x))); + assertEquals(-0, x *= ((-1112957170.5613296)|((tmp = 847344494, tmp)>>>(tmp = 2735119927, tmp)))); + assertEquals(-0, x /= (tmp = 544636506, tmp)); + assertEquals(0, x >>>= (x^(545093699))); + assertEquals(0, x %= (((tmp = -2208409647.5052004, tmp)+(3083455385.374988))+(((-482178732.7077277)*x)>>>((2661060565)*(-2125201239))))); + assertEquals(0, x >>>= (-212334007.34016395)); + assertEquals(0.7004300865203454, x -= ((2032883941)/(-2902336693.0154715))); + assertEquals(0, x <<= (x<<((265868133.50175047)>>>(1162631094)))); + assertEquals(604920272.4394834, x -= (-604920272.4394834)); + assertEquals(604920272, x &= x); + assertEquals(0, x <<= (((-1961880051.1127694)%(tmp = 1715021796, tmp))|((tmp = 2474759639.4587016, tmp)|(243416152.55635)))); + assertEquals(-46419074, x |= (((tmp = -518945938.5238774, tmp)%((x+(tmp = 242636408, tmp))+(-1974062910)))|(1546269242.0259726))); + assertEquals(-46419074, x += ((-629802130)*((tmp = -658144149, tmp)%((-905005358.5370393)>>>x)))); + assertEquals(-46419074, x |= (x%(-1103652494))); + assertEquals(7892881050983985, x *= (-170035297.36469936)); + assertEquals(1105701997.4273424, x %= ((((-490612260.0023911)>>>(tmp = 1803426906, tmp))^(x%(2725270344.2568116)))-(1010563167.8934317))); + assertEquals(1088619532, x &= (-2232199650)); + assertEquals(1073807364, x &= (-888024506.5008001)); + assertEquals(1153062254980628500, x *= x); + assertEquals(1153062255703627000, x -= (tmp = -722998613.897227, tmp)); + assertEquals(-1141418584, x |= (3017232552.4814596)); + assertEquals(-373464140, x ^= (-2914372068)); + assertEquals(994050048, x <<= x); + assertEquals(0, x ^= x); + assertEquals(0, x &= (tmp = -3166402389, tmp)); + assertEquals(0, x &= ((-1760842506.337213)|(tmp = 2538748127.795164, tmp))); + assertEquals(-0, x /= (-2635127769.808626)); + assertEquals(0, x &= ((((tmp = 1414701581, tmp)^(((2425608769)/((x<<x)^(x-x)))^((tmp = -2641946468.737288, tmp)|(tmp = -313564549.1754241, tmp))))*(tmp = -2126027460, tmp))|(-2255015479))); + assertEquals(225482894, x ^= (225482894.8767246)); + assertEquals(0, x ^= x); + assertEquals(306216231, x += (tmp = 306216231, tmp)); + assertEquals(306216231, x -= ((-465875275.19848967)&((-806775661.4260025)/((((-184966089.49763203)>>>((x>>x)+((tmp = -1951107532, tmp)|x)))%x)*((2704859526.4047284)%((x*x)>>x)))))); + assertEquals(30754, x &= (1706162402.033193)); + assertEquals(30454.010307602264, x -= (((590456519)>>>(tmp = 2713582726.8181214, tmp))/x)); + assertEquals(8419062, x |= ((2848886788)<<(tmp = 2993383029.402275, tmp))); + assertEquals(16, x >>= (tmp = -1651287021, tmp)); + assertEquals(1, x /= x); + assertEquals(-1407643485, x ^= (-1407643486)); + assertEquals(2, x >>>= (-1126004674)); + assertEquals(470812081, x ^= ((-2411718964)>>>x)); + assertEquals(550443688.6407901, x += (tmp = 79631607.6407901, tmp)); + assertEquals(3669092443.64079, x -= (-3118648755)); + assertEquals(-625874853, x <<= (((tmp = -1640437346, tmp)/(((x*x)>>>x)<<x))/x)); + assertEquals(-1431439050363516700, x *= (2287101077)); + assertEquals(-1921660672, x |= ((((((((-1912249689.9978154)&(-1676922742.5343294))*(2625527768))<<((820676465)^(((x+(tmp = -852743692, tmp))&((x-((((1361714551)/(311531668))>>>(tmp = -1330495518.8175917, tmp))<<(((tmp = 1369938417.8760853, tmp)*(-1217947853.8942266))<<(-2048029668))))-(-513455284)))>>>(tmp = 1980267333.6201067, tmp))))<<(((1503464217.2901971)>>(tmp = 2258265389, tmp))>>>(1868451148)))&(x-(x^(tmp = -1565209787, tmp))))*x)<<(tmp = -2426550685, tmp))); + assertEquals(-1921660672, x %= (((tmp = 523950472.3315773, tmp)+(((2971865706)^x)-x))&(-1773969177))); + assertEquals(420176973.1169958, x += (2341837645.116996)); + assertEquals(420176973, x >>>= (((tmp = -2485489141, tmp)<<((tmp = -2520928568.360244, tmp)+x))&(543950045.0932506))); + assertEquals(50, x ^= (x|((tmp = 2001660699.5898843, tmp)>>>(tmp = 1209151128, tmp)))); + assertEquals(138212770720.96973, x *= (2764255414.4193945)); + assertEquals(-28683, x |= (((-535647551)|x)>>((((2065261509)>>(-354214733))*x)+(-3218217378.2592907)))); + assertEquals(1627048838, x ^= (tmp = -1627044749, tmp)); + assertEquals(-839408795, x ^= (2903337187.480303)); + assertEquals(-1000652427, x += (tmp = -161243632, tmp)); + assertEquals(740237908.4196916, x += ((tmp = 1587000348, tmp)+(tmp = 153889987.41969144, tmp))); + assertEquals(Infinity, x /= (((((-615607376.1012697)&(57343184.023578644))+((-1967741575)|(-3082318496)))<<(((tmp = -958212971.99792, tmp)>>(tmp = 2962656321.3519197, tmp))-(x|(x*(969365195)))))<<(tmp = -1739470562.344624, tmp))); + assertEquals(-Infinity, x /= ((tmp = -1736849852, tmp)%x)); + assertEquals(0, x <<= x); + assertEquals(0, x %= (tmp = -226505646, tmp)); + assertEquals(1982856549, x -= (((x+(-1982856549))%(-2274946222))>>(x%(((tmp = -1289577208.9097936, tmp)>>x)^(778147661))))); + assertEquals(1648018703, x ^= ((3085618856)+((tmp = 1546283467, tmp)&(((x|((-2376306530)*(((((((tmp = -2807616416, tmp)%(((((tmp = 347097983.1491085, tmp)<<x)|(((((1135380667)/(x>>>(tmp = 1679395106, tmp)))^((1277761947)<<((tmp = -1614841203.5244312, tmp)>>x)))%((tmp = 1552249234.2065845, tmp)>>>x))>>>(tmp = -1677859287, tmp)))>>>(2605907565))/(tmp = 2291657422.221277, tmp)))%(((tmp = 425501732.6666014, tmp)>>>(1327403879.455553))+x))>>((tmp = -3075752653.2474413, tmp)&(x-(tmp = -71834630, tmp))))|((((2532199449.6500597)*(-842197612.4577162))%x)>>x))*(((1220047194.5100307)<<((tmp = 1642962251, tmp)<<((-662340)>>>((tmp = -1672316631.3251066, tmp)<<((tmp = 1762690952.542441, tmp)-(x/(1904755683.3277364)))))))>>x))|(((((tmp = 1625817700.7052522, tmp)%(tmp = -2990984460, tmp))|(2395645662))-((2619930607.550086)>>x))^(tmp = 130618712, tmp)))))&((-3142462204.4628367)/(1078126534.8819227)))%(((tmp = -256343715.2267704, tmp)+x)^(tmp = 2009243755, tmp)))))); + assertEquals(1937698223, x |= (((tmp = 866354374.7435778, tmp)+(tmp = 2751925259.3264275, tmp))%(-2252220455))); + assertEquals(0, x -= x); + assertEquals(-823946290.6515498, x -= (tmp = 823946290.6515498, tmp)); + assertEquals(706970324, x ^= (-457174758)); + assertEquals(32916, x &= (25740724)); + assertEquals(0, x >>>= ((-1658933418.6445677)|(tmp = -846929510.4794133, tmp))); + assertEquals(0, x ^= ((-834208600)/((-1256752740)&(tmp = 1973248337.8973258, tmp)))); + assertEquals(-1639195806, x += (-1639195806)); + assertEquals(-1559416478, x ^= ((tmp = 1349893449.0193534, tmp)*(tmp = 2044785568.1713037, tmp))); + assertEquals(0, x &= ((x>>(tmp = 1720833612, tmp))/((x+(-1305879952.5854573))^x))); + assertEquals(-0, x *= (tmp = -1713182743, tmp)); + assertEquals(0, x >>= x); + assertEquals(NaN, x /= (((x%((x>>>(((-1515761763.5499895)^(-3076528507.626539))<<(tmp = 1293944457.8983147, tmp)))<<(tmp = 276867491.8483894, tmp)))>>(tmp = -2831726496.6887417, tmp))%((((tmp = 1780632637.3666987, tmp)^x)%((208921173.18897665)>>(tmp = 633138136, tmp)))+x))); + assertEquals(0, x >>= (tmp = -2755513767.0561147, tmp)); + assertEquals(0, x |= x); + assertEquals(840992300.0324914, x -= ((-840992300.0324914)+x)); + assertEquals(840992300, x &= x); + assertEquals(-1094140277, x ^= (2364029095)); + assertEquals(-Infinity, x /= ((((((1257084956)<<(2009241695))>>(x+x))*x)>>>x)>>>(205318919.85870552))); + assertEquals(-Infinity, x -= (((x>>>(tmp = 3037168809.20163, tmp))&x)*(x&(((806151109)*x)-(tmp = -1741679480.58333, tmp))))); + assertEquals(400659949, x ^= (tmp = 400659949, tmp)); + assertEquals(5, x >>= (tmp = 1175519290, tmp)); + assertEquals(5, x |= x); + assertEquals(0, x >>= x); + assertEquals(0, x >>= ((1317772443)&(x<<x))); + assertEquals(-1123981819, x ^= (tmp = 3170985477, tmp)); + assertEquals(1123864651, x ^= ((x%(((x&x)&(-2606227299.7590737))<<((tmp = -2018123078.1859496, tmp)*x)))|(x+(((((1935939774.8139446)/((-1303958190)/(2802816697.32639)))<<((2880056582)*x))+x)+x)))); + assertEquals(1543368927, x |= (-2795691884)); + assertEquals(NaN, x /= (x%((tmp = -1129915114, tmp)<<x))); + assertEquals(NaN, x += (tmp = -3045743135, tmp)); + assertEquals(NaN, x -= (tmp = -2849555731.8207827, tmp)); + assertEquals(NaN, x /= (((((2127485827)>>>((((tmp = 363239924, tmp)>>x)|((((tmp = -1419142286.0523334, tmp)-(x<<x))^(tmp = -1990365089.8283136, tmp))*((tmp = 2780242444.0739098, tmp)>>>(((-2336511023.342298)&x)/(tmp = 2296926221.402897, tmp)))))>>((tmp = 1378982475.6839466, tmp)>>(tmp = -816522530, tmp))))&(x^(tmp = -1668642255.0586753, tmp)))%(((tmp = 921249300.1500335, tmp)^x)*(tmp = -2228816905, tmp)))>>x)); + assertEquals(-1460685191, x |= (tmp = 2834282105, tmp)); + assertEquals(-1463439264, x &= (tmp = 2881860064.146755, tmp)); + assertEquals(20.98100714963762, x /= (((3017150580.7875347)^((250499372.5339837)<<(tmp = -42767556.30788112, tmp)))|(x%(-2829281526)))); + assertEquals(1, x /= x); + assertEquals(2, x += x); + assertEquals(8, x <<= x); + assertEquals(0, x >>>= ((730174750)>>>x)); + assertEquals(0, x ^= x); + assertEquals(-1459637373, x ^= (2835329923.456409)); + assertEquals(-1233115861, x ^= (511678120)); + assertEquals(95682857, x >>>= ((tmp = 1534570885, tmp)|(tmp = -414425499.3786578, tmp))); + assertEquals(70254633, x &= (-1502067585)); + assertEquals(51384749748909710, x *= (tmp = 731407276, tmp)); + assertEquals(9390482.873469353, x %= (tmp = -592576964.7982686, tmp)); + assertEquals(4695241, x >>>= (tmp = -1879898431.5395758, tmp)); + assertEquals(-3129811912538149000, x += (((-727481809)^((3106908604)%x))*((((tmp = -1218123690, tmp)^(x>>((-942923806)^x)))/(x+x))>>>(-1508881888.969373)))); + assertEquals(1596870236, x ^= (-1135673764.9721224)); + assertEquals(0, x ^= x); + assertEquals(2133782410, x |= (((-2202469371)>>((tmp = 1327588406.183342, tmp)/(tmp = 253581265.7246865, tmp)))-((tmp = 2226575446.838795, tmp)^x))); + assertEquals(-81895217.83608055, x -= (tmp = 2215677627.8360806, tmp)); + assertEquals(812089344, x <<= ((tmp = 882824005, tmp)/(((x>>((((((((tmp = 1211145185, tmp)/((-137817273)-(((tmp = 2165480503.1144185, tmp)-(-1840859887.1288517))*((155886014.8393339)>>((-1984526598)<<(tmp = 1331249058.3246582, tmp))))))>>(x*x))%(2830324652))%(933701061))|(1346496215))^(tmp = -988800810, tmp))+x))>>>x)<<(-2372088384)))); + assertEquals(812089344, x <<= x); + assertEquals(8472, x %= ((((x|(((x%(tmp = 2772099481.664402, tmp))+(2894690616))-x))&(x&(((-715790638.6454093)>>(tmp = -1447931029, tmp))-(tmp = 1761027889, tmp))))^x)%(((tmp = 830969811, tmp)|x)|((-1102267929)-(3193018687))))); + assertEquals(-0.0000028559857417864914, x /= (-2966401364)); + assertEquals(0, x >>= x); + assertEquals(-701800392, x += (tmp = -701800392, tmp)); + assertEquals(2034756873, x -= (tmp = -2736557265, tmp)); + assertEquals(-0.9475075048394501, x /= (((((82879340.27231383)+((tmp = -2876678920.653639, tmp)*(-2801097850)))<<x)>>>((x<<(((((x|x)&(tmp = -1572694766, tmp))>>(x+(x/((x-(((tmp = 1435301275, tmp)|(tmp = 983577854.212041, tmp))>>(tmp = 632633852.1644179, tmp)))+x))))>>>x)|(-850932021)))>>x))<<(-821983991))); + assertEquals(0, x >>= (x>>(2424003553.0883207))); + assertEquals(2599386349, x -= (-2599386349)); + assertEquals(-68157441, x |= (((tmp = -1170343454.9327996, tmp)+((((tmp = 448468098, tmp)|(x>>(x>>(((x>>(((x/(x&(x<<x)))<<(2436876051.2588806))^(3010167261)))%((tmp = 2577616315.7538686, tmp)>>>(-2953152591.015912)))%((tmp = -1304628613, tmp)/(x&((x|((-2000952119)%((691146914)/((tmp = 1480966978.7766845, tmp)<<((tmp = 2644449477.392441, tmp)|(-2143869305.871568))))))+(tmp = -315254308, tmp))))))))&(-2060205555))|((-604140518.8186448)^(x*x))))%(x*((tmp = 1383244000.2807684, tmp)/(3195793656))))); + assertEquals(-68157441, x |= x); + assertEquals(-1, x >>= x); + assertEquals(-2147483648, x <<= x); + assertEquals(-1.5257198286933313, x /= (tmp = 1407521622, tmp)); + assertEquals(1149084989.47428, x += (((tmp = 1149084991.9004865, tmp)&x)^((((((2797053000)/(x^x))*(-2829253694))>>>((tmp = -610924351, tmp)>>x))>>>(tmp = -675681012, tmp))<<(2812852729)))); + assertEquals(0, x %= x); + assertEquals(0, x <<= ((tmp = -584069073, tmp)*(-2953140326))); + assertEquals(0, x <<= (tmp = -481515023.6404002, tmp)); + assertEquals(-1441535370, x ^= (2853431926)); + assertEquals(2853431926, x >>>= (((((((tmp = 2215663525.9620194, tmp)%((-1102832735.9274108)/x))>>x)&(3220898702.76322))&(((2077584946)*((x>>x)<<((tmp = 1845701049, tmp)-x)))/(tmp = 1947184202.5737212, tmp)))|(((tmp = 2976351488, tmp)^(-42517339))%((2648230244.410125)^(1520051731.31089))))/(1761635964))); + assertEquals(43539, x >>>= (tmp = 1361671184.7432632, tmp)); + assertEquals(21769, x >>= ((tmp = -804932298.9572575, tmp)>>((((tmp = 1749006993.253409, tmp)+(276536978))^x)|(2698166994)))); + assertEquals(1103025563, x |= (tmp = 1103007891, tmp)); + assertEquals(1327594607, x += (tmp = 224569044, tmp)); + assertEquals(1327594607, x |= x); + assertEquals(-478674944, x <<= (((672378508)&x)^(((-2070209708.6470091)|x)|(x>>>x)))); + assertEquals(-478674943, x ^= ((-1832457698.6345716)>>>((tmp = -3077714019, tmp)/(1809383028)))); + assertEquals(229129701056053250, x *= x); + assertEquals(1, x /= x); + assertEquals(2, x <<= (-1522529727)); + assertEquals(2, x &= x); + assertEquals(-2016989182, x |= ((((tmp = -1267845511, tmp)*(1225350332))+((tmp = -1397690831.5717893, tmp)>>>(tmp = -2575382994, tmp)))+x)); + assertEquals(-241, x >>= (tmp = 931869591, tmp)); + assertEquals(-1048087547, x &= (tmp = -1048087403.1163051, tmp)); + assertEquals(-4004486369.844599, x += (tmp = -2956398822.844599, tmp)); + assertEquals(-4004486368.844599, x -= (((2701878498)>>x)|(x|(-1079354967)))); + assertEquals(1, x >>= (tmp = -1583689092, tmp)); + assertEquals(1, x *= (x>>(x%x))); + assertEquals(0, x %= x); + assertEquals(-0, x *= (-120818969)); + assertEquals(0, x >>= ((tmp = 1794099660, tmp)/(((x&(((-321906091)^(tmp = -3009885933.8449526, tmp))&((tmp = -140917780, tmp)|(2037803173.4075825))))&x)&(tmp = -745357154, tmp)))); + assertEquals(0, x <<= (563984257.3493614)); + assertEquals(NaN, x %= ((((x>>(tmp = -2190891392.320677, tmp))-x)<<(462714956))<<((tmp = -84413570, tmp)|((x|(-2787022855))-((tmp = 2028532622, tmp)|(tmp = 1103757073.9178817, tmp)))))); + assertEquals(NaN, x *= ((2137674085.3142445)|((tmp = -1054749859.2353804, tmp)%x))); + assertEquals(NaN, x /= (x>>>(((((tmp = 597103360.9069608, tmp)>>>(-2850217714.1866236))-((tmp = 1125150527, tmp)*x))%(tmp = -982662312, tmp))|((x/(((968656808.6069037)*(((128484784.15362918)>>x)^x))&((((x/((((tmp = 748775979, tmp)*((x-(((tmp = 709571811.9883962, tmp)%(-2083567026))%(x/(tmp = -680467505, tmp))))/((tmp = -167543858, tmp)/(tmp = -3113588783, tmp))))/x)<<(-2605415230)))>>>(tmp = 3133054172, tmp))%(tmp = -1904650393, tmp))*((x|(-1193709562))*(tmp = -1731312795.718104, tmp)))))/((tmp = -672386301, tmp)/(tmp = 808898833.4163612, tmp)))))); + assertEquals(-9, x |= (((((tmp = 150377964.57195818, tmp)/(tmp = 2161910879.0514045, tmp))-(-2381625849))>>(-2715928517))/(((452113643)^(-2502232011))/((-3076471740)^(((tmp = 1664851172, tmp)*(((-1460011714)>>>x)<<((-2870606437)%x)))*((tmp = -2836565755.609597, tmp)-((x/(tmp = -871461415, tmp))-(2278867564)))))))); + assertEquals(-1, x >>= x); + assertEquals(-1, x |= ((-1319927272)>>>(-2866709980))); + assertEquals(-1, x >>= ((2345179803.155703)&(-978025218.2243443))); + assertEquals(1, x /= x); + assertEquals(-260730973, x |= (tmp = -260730973, tmp)); + assertEquals(1174405120, x <<= (2681054073)); + assertEquals(1174405120, x &= x); + assertEquals(1073741824, x &= (tmp = 2017166572.7622075, tmp)); + assertEquals(1073741824, x |= x); + assertEquals(168806102, x %= ((((tmp = -2939969193.950067, tmp)|((-2325174027.614815)/(-2329212715)))*(x/(((((-2927776738)/(x|x))+(x%(tmp = -3007347037.698492, tmp)))<<(-1898633380))>>(tmp = 204338085.45241892, tmp))))^x)); + assertEquals(168806102, x %= ((-832849739.5197744)&(tmp = -141908598, tmp))); + assertEquals(-401033205.05225074, x -= (tmp = 569839307.0522507, tmp)); + assertEquals(-401033205, x &= x); + assertEquals(-401130402, x ^= ((x*(tmp = 311418759.22436893, tmp))>>x)); + assertEquals(793533469, x ^= (-950312893.5201888)); + assertEquals(756, x >>>= (-1096189516)); + assertEquals(711, x += ((tmp = -753105189, tmp)>>(599823192.5381484))); + assertEquals(0, x >>>= ((tmp = -2859668634.4641137, tmp)+(-1160392986.1521513))); + assertEquals(2427599726.176195, x -= (-2427599726.176195)); + assertEquals(1942312465.2523103, x -= (485287260.92388475)); + assertEquals(0, x >>>= ((tmp = -1740656456, tmp)/(tmp = 1339746799.9335847, tmp))); + assertEquals(0, x <<= ((-7017077.38786912)*((-699490904.4551768)^x))); + assertEquals(0, x <<= (tmp = 715662384, tmp)); + assertEquals(0, x *= (x>>>(2149735450.0758677))); + assertEquals(NaN, x /= x); + assertEquals(0, x >>= ((397078885)*((851639692.8982519)-x))); + assertEquals(0, x &= (-2526654445)); + assertEquals(0, x %= (-1204924598)); + assertEquals(251639720, x ^= (x|(tmp = 251639720, tmp))); + assertEquals(695433573, x ^= (663539405)); + assertEquals(-1038050104, x -= (1733483677)); + assertEquals(0, x ^= x); + assertEquals(NaN, x %= x); + assertEquals(0, x &= (392107269)); + assertEquals(0, x %= (-3084908458.241551)); + assertEquals(0, x ^= x); + assertEquals(-2121660509, x ^= (tmp = -2121660509.7861986, tmp)); + assertEquals(2285041855588855800, x *= (x|(3209046634))); + assertEquals(54915072, x >>>= (x%(((((x%((((tmp = -1429433339.5078833, tmp)|(tmp = 2906845137, tmp))^(3207260333))&(-848438650)))-(-2721099735))&(141851917.19978714))+x)/x))); + assertEquals(54915072, x &= x); + assertEquals(54915072, x %= (x+(1855489160))); + assertEquals(70078753, x ^= ((((((-1648661736)+(x%((-1421237596)+(tmp = 2053180992.3857927, tmp))))+(tmp = 38606889, tmp))<<((-241334284)%((x>>(215316122))*(tmp = 396488307, tmp))))+((tmp = -2900704565, tmp)^x))^(((1103481003.1111188)^x)-(tmp = 1304113534, tmp)))); + assertEquals(1149501440, x <<= ((x>>(tmp = 3203172843, tmp))*(tmp = -192535531, tmp))); + assertEquals(0, x ^= x); + assertEquals(0, x >>= ((tmp = 2751499787, tmp)&((tmp = 2217654798, tmp)*(tmp = -2798728014, tmp)))); + assertEquals(NaN, x /= ((((-2019592425)>>>((((-1571930240.741224)>>>((-183952981)/((((1990518443.672842)>>(((((2051371284)%(685322833.6793983))>>>(2662885938))<<(-1212029669.6675105))|((-2790877875)<<(1546643473))))<<x)-(tmp = 804296674.4579233, tmp))))-(tmp = -417759051.68770766, tmp))/((-621859758)>>>x)))&x)<<(tmp = -48558935.55320549, tmp))); + assertEquals(0, x <<= (x&x)); + assertEquals(0, x *= (x%(tmp = 301196068, tmp))); + assertEquals(398290944, x |= (((tmp = 1904146839, tmp)+(1521017178))*(-3174245888.562067))); + assertEquals(1256401076, x ^= (1566464180)); + assertEquals(149620758, x %= ((tmp = 532626355, tmp)^(tmp = -382971203, tmp))); + assertEquals(149620791, x |= (x>>x)); + assertEquals(-0.07034576194938641, x /= ((tmp = -1977313182.7573922, tmp)-x)); + assertEquals(0, x <<= x); + assertEquals(0, x &= x); + assertEquals(0, x /= ((2182424851.139966)%(((-2768516150)+x)>>>x))); + assertEquals(0, x %= (-504299638.53962016)); + assertEquals(-0, x *= (-2915134629.6909094)); + assertEquals(0, x <<= ((tmp = 952692723.402582, tmp)%(2146335996.785011))); + assertEquals(230457472, x |= ((tmp = -574776101.8681948, tmp)*(683185125))); + assertEquals(933795934, x ^= (tmp = 974395614, tmp)); + assertEquals(933801974, x ^= (x>>>((-148683729)*(((tmp = 2912596991.415531, tmp)^(-2883672328))/x)))); + assertEquals(222, x >>= (-3060224682)); + assertEquals(27, x >>>= (1429156099.1338701)); + assertEquals(754519106, x ^= (tmp = 754519129.7281355, tmp)); + assertEquals(188629776, x >>>= ((x>>>((1247267193)<<(tmp = -936228622, tmp)))%((tmp = 978604324.8236886, tmp)*((tmp = -3018953108, tmp)^(((tmp = 259650195, tmp)>>>(tmp = 2762928902.7901163, tmp))*(x>>((tmp = 787444263.5542864, tmp)/(x>>>(((-2039193776)<<(tmp = -1408159169, tmp))-(1238893783)))))))))); + assertEquals(188629775.33987066, x += ((tmp = 1040520414, tmp)/((-1576237184)|((tmp = -970083705, tmp)&(((tmp = -312062761.12228274, tmp)|(1171754278.2968853))<<(-2069846597.7723892)))))); + assertEquals(1473670, x >>>= ((tmp = 202409672, tmp)^x)); + assertEquals(2171703268900, x *= (x>>(((tmp = 840468550, tmp)&(-3208057101.2136793))/x))); + assertEquals(0, x ^= x); + assertEquals(0, x ^= (x&((tmp = 2569871408.2405066, tmp)|((tmp = -3149374622, tmp)<<(x-(x|((tmp = -821239139.1626894, tmp)>>>x))))))); + assertEquals(NaN, x /= x); + assertEquals(NaN, x %= (tmp = 1926106354, tmp)); + assertEquals(0, x >>= ((x/(-2848416))/(tmp = 2484293767, tmp))); + assertEquals(0, x <<= ((tmp = -2484137114, tmp)>>>(tmp = -887083772.8318355, tmp))); + assertEquals(0, x >>= (tmp = -2651389432, tmp)); + assertEquals(0, x ^= x); + assertEquals(1041871201, x += ((tmp = 1041871201.9272791, tmp)|(x<<(-1136959830)))); + assertEquals(651390879501530900, x *= ((tmp = 1250424964.0346212, tmp)>>x)); + assertEquals(1965815296.245636, x %= ((2650603245.655831)+((-1610821947.8640454)>>>(((878987151.6917406)*((((784630543)%(((1448720244)>>(((tmp = 3036767847, tmp)+((tmp = 1012548422, tmp)<<(1957000200)))-x))/(x>>x)))<<((tmp = 914710268, tmp)*(((x^(1559603121))<<(tmp = 3181816736, tmp))|((-1964115655)+x))))-(-1055603890)))&(946797797.0616649))))); + assertEquals(1965815296.245636, x %= (tmp = -2601038357.593118, tmp)); + assertEquals(-769384440.872302, x += (-2735199737.117938)); + assertEquals(-769384440.872302, x %= (2193123162)); + assertEquals(1, x /= x); + assertEquals(1, x -= (((x>>>(-1968465925))*((tmp = 563037904, tmp)>>((tmp = 3009534415.769578, tmp)>>((-2567240601.7038674)<<(tmp = -1258402723.4150183, tmp)))))%(3112239470.276867))); + assertEquals(1, x |= x); + assertEquals(1505461527, x ^= (tmp = 1505461526.5858076, tmp)); + assertEquals(406553877, x &= (tmp = 2558242293, tmp)); + assertEquals(406553877, x |= x); + assertEquals(-574902339, x |= ((-709809495)%(tmp = -2880884811.410611, tmp))); + assertEquals(-20281777.349363208, x %= (22184822.46602547)); + assertEquals(1, x /= x); + assertEquals(-4360732, x ^= ((x|(tmp = 3178620274, tmp))>>(((2686286888)&(((-1107223053.8716578)/(((-2955575332.3675404)+(-2770518721))|(-2705016953.640522)))-x))^((1473641110.4633303)*((((-1466496401)<<x)+x)%(1805868749.082736)))))); + assertEquals(-1158545408, x <<= ((((x/((-2710098221.691819)-(-2421462965.788145)))/(((((x>>>(tmp = 1994541591.1032422, tmp))+(tmp = -1276676679.9747126, tmp))&((tmp = 1764029634.2493339, tmp)+((x|(tmp = -3050446156, tmp))-((tmp = -9441859, tmp)/(((-2072420232)&x)*(-1003199889))))))+(tmp = -2443230628, tmp))*x))*((x&((((x|(747566933))*(((2039741506)>>>((tmp = -2456000554, tmp)>>>(-1566360933.7788877)))^((tmp = 960600745, tmp)/x)))&(x^(((-2649310348.777452)^((2224282875)-(tmp = -2129141087.3182096, tmp)))<<((x<<x)+((-1307892509.3874407)-(x|(tmp = -2831643528.9720087, tmp)))))))/(((tmp = -35502946, tmp)<<((tmp = 1091279222, tmp)>>(((-2686069468.8930416)-x)+(tmp = 367442353.2904701, tmp))))%(1218262628))))/x))^(-919079153.7857773))); + assertEquals(747, x >>>= (1229157974)); + assertEquals(747, x |= x); + assertEquals(NaN, x %= (((3086718766.4715977)*((7912648.497568846)*((-2713828337.1659327)*(-176492425.4011252))))<<(tmp = -1074475173, tmp))); + assertEquals(0, x >>>= ((((444923201)<<x)>>>(-883391420.2142565))*((((617245412)<<x)>>>x)*(-913086143.2793813)))); + assertEquals(1941802406, x ^= (tmp = -2353164890, tmp)); + assertEquals(14, x >>>= (-1600311077.4571416)); + assertEquals(-18229482703.7246, x += (((x+(-993157139.7880647))%x)*(1862419512.1781366))); + assertEquals(-14.531388114858734, x /= ((tmp = -1649072797.951641, tmp)<<x)); + assertEquals(0, x ^= x); + assertEquals(0, x >>= ((x/x)^x)); + assertEquals(2, x ^= ((-1597416259)/(-738770020))); + assertEquals(0, x >>= (tmp = -387850072.74833393, tmp)); + assertEquals(0, x >>>= ((2491085477.186817)>>(x*(((tmp = -1592498533, tmp)+(tmp = 2086841852, tmp))&(-3174019330.8288536))))); + assertEquals(0, x >>= x); + assertEquals(0, x >>>= (tmp = -3045348659.45243, tmp)); + assertEquals(-1208573479, x |= ((3086393817)-x)); + assertEquals(1460649854142163500, x *= x); + assertEquals(1588199424, x <<= (-1902076952)); + assertEquals(1586102272, x &= (tmp = 2139876091.9142454, tmp)); + assertEquals(-460908552.5528109, x -= (tmp = 2047010824.552811, tmp)); + assertEquals(-460908552.5528109, x %= (tmp = 507904117.09368753, tmp)); + assertEquals(-460908552.5528109, x %= (2749577642.527038)); + assertEquals(234012, x >>>= (-340465746.91275)); + assertEquals(0, x >>>= x); + assertEquals(0, x %= (tmp = -2601875531, tmp)); + assertEquals(0, x %= (x|(tmp = 650979981.1158671, tmp))); + assertEquals(0, x %= (tmp = -2286020987, tmp)); + assertEquals(0, x |= x); + assertEquals(0, x &= (x|((tmp = 2568101411, tmp)-(-1438002403)))); + assertEquals(0, x >>>= (1399248574)); + assertEquals(0, x %= (-1906670287.2043698)); + assertEquals(0, x >>= (1019286379.6962404)); + assertEquals(0, x |= (x/(tmp = -82583591.62643051, tmp))); + assertEquals(NaN, x %= x); + assertEquals(NaN, x *= (x^(1874776436))); + assertEquals(NaN, x -= ((-1238826797)-(-2971588236.7228813))); + assertEquals(0, x <<= (2064632559)); + assertEquals(-0.5967273958864694, x += (((tmp = 1502995019, tmp)>>x)/(-2518729707))); + assertEquals(0, x >>>= x); + assertEquals(-0, x /= (-1923030890)); + assertEquals(NaN, x %= x); + assertEquals(0, x >>= (tmp = 1081732779.9449487, tmp)); + assertEquals(-820183066, x |= ((tmp = -3169007292.4721155, tmp)|(-1912588318))); + assertEquals(0, x -= x); + assertEquals(NaN, x %= x); + assertEquals(NaN, x /= (tmp = 287181840, tmp)); + assertEquals(0, x &= (x/((tmp = -1139766051, tmp)<<(x&(tmp = 2779004578, tmp))))); + assertEquals(0, x >>= (((tmp = -1816938028, tmp)+(-224851993.3139863))*(-2933829524))); + assertEquals(0, x |= ((((tmp = 305077929.1808746, tmp)&((x-(((((tmp = 2122810346.7475111, tmp)<<(717271979))*(tmp = 256854043.72633624, tmp))%((x+(tmp = -318657223.9992106, tmp))*((1993144830)<<(2594890698.603228))))^((((tmp = 257370667, tmp)>>>((((x^(3160746820))>>>(2049640466.8116226))>>>(2543930504.7117066))^(x-x)))^(x%(964838975)))^x)))%(x*x)))>>>x)*(tmp = -46861540, tmp))); + assertEquals(747575633, x ^= ((-2406502427)-(-3154078060.3794584))); + assertEquals(0, x *= (x%x)); + assertEquals(0, x <<= (1313773705.3087234)); + assertEquals(0, x >>>= ((x+x)>>>(3068164056))); + assertEquals(-0, x *= (tmp = -1771797797, tmp)); + assertEquals(1784146970, x ^= (tmp = 1784146970, tmp)); + assertEquals(1784146970, x >>>= (tmp = -2219972320.7195597, tmp)); + assertEquals(1744830464, x <<= ((((-2769476584)-(((1798431604)>>(tmp = 1337687914.799577, tmp))>>>((-2802941943.15014)>>x)))>>>(tmp = 646033678, tmp))-x)); + assertEquals(3044433348102455300, x *= x); + assertEquals(0, x >>= ((tmp = 1592076570.1900845, tmp)-((645774223.6317859)>>x))); + assertEquals(0, x >>= (x>>>(-3045822290.1536255))); + assertEquals(-0, x *= (tmp = -2450298800.986624, tmp)); + assertEquals(0, x >>= (tmp = 1379605393, tmp)); + assertEquals(0, x &= (((x-((((tmp = 837939461.6683749, tmp)+((((-813261853.3247359)|(x&(((-2565113940)*(tmp = -2725085381.240134, tmp))|x)))%(-1457259320))-(x+((tmp = -273947066, tmp)%((1164825698.879649)>>(1653138880.3434052))))))>>>(2823967606.411492))>>>((((((((1189235604.9646997)/(tmp = -2875620103.4002438, tmp))-(tmp = -801261493, tmp))<<(((1832556579.5095325)<<x)|((tmp = -2740330665, tmp)>>(tmp = -2352814025, tmp))))-(tmp = -1445043552.99499, tmp))&(x<<(((((445325471)*(1293047043.1808558))>>>(((1901837408.5910044)-(tmp = -2349093446.5313253, tmp))>>>(tmp = 1000847053.1861948, tmp)))*(x>>>(1771853406.6567078)))>>x)))>>>x)>>>(x^((tmp = 2813422715, tmp)-(x+(-342599947)))))))&(x>>>x))*x)); + assertEquals(NaN, x %= ((tmp = -3027713526, tmp)-((((x%(((((x/((2711155710)^(((((x>>>x)%((1098599291.155015)^(((((tmp = 1855724377.8987885, tmp)/(x|x))*((-1963179786)*((x-((-1634717702)%x))<<x)))>>(2008859507))>>((tmp = 2635024299.7983694, tmp)^(tmp = -602049246, tmp)))))*(x>>x))&(tmp = -1925103609, tmp))*((tmp = 2106913531.2828505, tmp)%((tmp = -200970069, tmp)*(-2809001910.951446))))))%x)*((1990098169)>>((x<<(2303347904.2601404))%x)))|(2767962065.9846206))+(201589933.301661)))>>(((tmp = 1921071149.5140274, tmp)>>(1054558799.1731887))|x))*(x/((((-2833879637.345674)>>>(tmp = 2849099601, tmp))%x)+(x%(x%(((tmp = 1983018049, tmp)^(tmp = -2659637454, tmp))>>((-1335497229.6945198)-(x+(((((tmp = 1136612609.848967, tmp)%(2471741030.01762))<<(x|(((tmp = 1644081190.1972675, tmp)&(-1422527338))^(2379264356.265957))))/(tmp = 2979299484.1884174, tmp))/x)))))))))*((tmp = 1858298882, tmp)^((tmp = -547417134.9651439, tmp)*x))))); + assertEquals(-7664, x |= ((2286000258.825538)>>(1716389170))); + assertEquals(-1, x >>= x); + assertEquals(-1231640486.3023372, x += ((tmp = 1231640485.3023372, tmp)*x)); + assertEquals(-2463280972.6046743, x += x); + assertEquals(1746, x >>>= x); + assertEquals(1746, x >>>= (((tmp = -562546488.0669937, tmp)*((-2475357745.8508205)&((x%(821425388.8633704))%((((-2315481592.687686)&(((tmp = 3130530521.7453523, tmp)+x)-x))^(-973033390.1773088))/x))))<<x)); + assertEquals(1746, x %= (-1544973951.076033)); + assertEquals(27936, x <<= (-525441532.33816123)); + assertEquals(27936, x %= (x*((tmp = 344991423.5336287, tmp)+(-2267207281)))); + assertEquals(27, x >>>= (tmp = 1249792906, tmp)); + assertEquals(0, x >>>= (tmp = -1068989615, tmp)); + assertEquals(0, x >>>= (tmp = 347969658.92579734, tmp)); + assertEquals(-2656611892, x -= (2656611892)); + assertEquals(1944539596, x |= (((tmp = 3000889963, tmp)-x)<<((tmp = 2917390580.5323124, tmp)^(-996041439)))); + assertEquals(1944539596, x |= x); + assertEquals(-739740167.0752468, x -= ((1712009965.0752468)+(x>>((tmp = -740611560.99014, tmp)>>>((tmp = -1033267419.6253037, tmp)&(862184116.3583733)))))); + assertEquals(-1479480334.1504936, x += x); + assertEquals(-4294967296.150494, x -= (x>>>((1219235492.3661718)&(3138970355.0665245)))); + assertEquals(0, x >>= (x*x)); + assertEquals(-0, x *= ((-2202530054.6558375)-(-676578695))); + assertEquals(-0, x %= (1336025846)); + assertEquals(0, x &= x); + assertEquals(0, x /= (1759366510)); + assertEquals(630007622, x |= (630007622)); + assertEquals(-0.22460286863455903, x /= (tmp = -2804984753, tmp)); + assertEquals(1102410276.775397, x -= (-1102410277)); + assertEquals(1102410276.775397, x %= ((((-2569525203)&x)*(x|(-1932675298)))/((-2376634450)>>>(x>>>(tmp = 936937604.9491489, tmp))))); + assertEquals(33642, x >>= (3028252527)); + assertEquals(2181106522.688034, x -= (-2181072880.688034)); + assertEquals(-2113861630, x &= (2523921542)); + assertEquals(-2147483646, x &= (-1996601566.9370148)); + assertEquals(-2147483648, x &= (tmp = -665669175.1968856, tmp)); + assertEquals(-2858673260.1367273, x -= (tmp = 711189612.1367272, tmp)); + assertEquals(350657, x >>= (tmp = -170243892.25474262, tmp)); + assertEquals(-0.0001405571562140975, x /= (-2494764474.7868776)); + assertEquals(0, x ^= x); + assertEquals(NaN, x /= ((x&(-2041236879))*((tmp = -2182530229, tmp)^((1274197078)*x)))); + assertEquals(0, x |= (x&(x-(1794950303)))); + assertEquals(1222105379, x |= (tmp = 1222105379, tmp)); + assertEquals(729884484, x ^= (tmp = 1666645607.6907792, tmp)); + assertEquals(729884484, x %= (tmp = -2896922082, tmp)); + assertEquals(8768, x &= ((tmp = 358940932, tmp)>>>(3159687631.3308897))); + assertEquals(1892384495, x |= (-2402591569)); + assertEquals(1892470533, x += ((((x^(-2266612043))>>>(tmp = -531009952, tmp))<<(x>>>((-1365315963.5698428)>>>((x+((-3168207800.184341)-(tmp = 1776222157.609917, tmp)))+(-1588857469.3596382)))))>>>x)); + assertEquals(143587205, x += (tmp = -1748883328, tmp)); + assertEquals(0, x ^= x); + assertEquals(0, x >>= (tmp = 2334880462.3195543, tmp)); + assertEquals(0, x &= ((tmp = 1819359625.4396145, tmp)|(tmp = -1323513565, tmp))); + assertEquals(-1102259874, x ^= (3192707422)); + assertEquals(2567457772588852700, x *= (-2329267202)); + assertEquals(-16783687, x |= ((-2212476227.060922)^(378973700.78452563))); + assertEquals(4278183609, x >>>= ((((((((tmp = 1766363150.197206, tmp)*(-2774552871))%x)>>>((3071429820)&((((((tmp = 351068445.27642524, tmp)<<(tmp = 2646575765, tmp))^(806452682))<<((x>>>(-2217968415.505327))<<(1564726716)))|x)-(tmp = -3110814468.9023848, tmp))))+x)^x)>>>(tmp = -617705282.0788529, tmp))>>>x)); + assertEquals(4314933530, x -= ((1032195469.789219)|(tmp = -448053861.9531791, tmp))); + assertEquals(9709850, x %= (((tmp = -3056286252.5853324, tmp)*x)&x)); + assertEquals(9709850, x %= (tmp = -2596800940, tmp)); + assertEquals(2655489828.9461126, x -= (tmp = -2645779978.9461126, tmp)); + assertEquals(369266212, x &= (((335712316.24874604)|(tmp = 33648215, tmp))-((x/(2639848695))<<((-499681175)<<(-2490554556))))); + assertEquals(-2147483648, x <<= (-834465507)); + assertEquals(1073741824, x >>>= (((tmp = 3018385473.1824775, tmp)>>(x*(-2574502558.216812)))|(((tmp = -1742844828, tmp)*(1698724455))&x))); + assertEquals(-270818218, x += (-1344560042)); + assertEquals(360710144, x <<= x); + assertEquals(0, x <<= (tmp = 612718075, tmp)); + assertEquals(0, x <<= x); + assertEquals(-0, x /= (tmp = -1922423684, tmp)); + assertEquals(-0, x *= ((((tmp = 741806213.3264687, tmp)%(-711184803.2022421))+((tmp = -3209040938, tmp)&(525355849.044886)))&(x<<(tmp = -698610297, tmp)))); + assertEquals(0, x <<= (-482471790)); + assertEquals(0, x &= ((-921538707)/(tmp = -482498765.988616, tmp))); + assertEquals(0, x ^= (x^x)); + assertEquals(-351721702, x ^= (-351721702.8850286)); + assertEquals(726242219625599900, x -= ((2064820612)*x)); + assertEquals(1452484439251199700, x += x); + assertEquals(2.52318299412847e-15, x %= ((((x<<((2508143285)+x))>>(-2493225905.011774))%(1867009511.0792103))/((((x<<(2542171236))>>((x|x)&(tmp = -384528563, tmp)))+((-1168755343)*(1731980691.6745195)))+(tmp = -1608066022.71164, tmp)))); + assertEquals(79905008, x += ((((-2702081714.590131)&(x+(tmp = -1254725471.2121565, tmp)))*(3088309981))%(((tmp = 1476844981.1453142, tmp)|((((tmp = -1243556934.7291331, tmp)%x)^(-1302096154))+((660489180)/(tmp = -681535480.8642154, tmp))))^(tmp = -8410710, tmp)))); + assertEquals(1215822204, x ^= ((-3008054900)>>>(tmp = -1990206464.460693, tmp))); + assertEquals(-394790532, x |= ((((-1334779133.2038574)+(tmp = -1407958866.832946, tmp))<<(1699208315))-(((x^(x%x))<<(3216443))>>(x+((((2576716374.3081336)|((tmp = 2316167191.348064, tmp)&((51086351.20208645)&((x|(tmp = -357261999, tmp))^(x/x)))))*(-45901631.10155654))*(((-439588079)>>>((-2358959768.7634916)|(1613636894.9373643)))+(((-908627176)<<x)%(x%((-1669567978)>>>((x>>(1289400876))+(tmp = 2726174270, tmp))))))))))); + assertEquals(-0.17717467607696327, x /= (2228255982.974148)); + assertEquals(-1905616474, x ^= (tmp = 2389350822.851587, tmp)); + assertEquals(-0, x %= x); + assertEquals(2818124981.508915, x -= (-2818124981.508915)); + assertEquals(-1476842315, x |= x); + assertEquals(73408564, x &= (-3147390604.3453345)); + assertEquals(70, x >>>= x); + assertEquals(1, x >>= x); + assertEquals(3086527319.899181, x *= (3086527319.899181)); + assertEquals(-145, x >>= x); + assertEquals(-145, x %= (tmp = -2500421077.3982406, tmp)); + assertEquals(-1, x >>= (tmp = -2970678326.712191, tmp)); + assertEquals(-1, x %= ((tmp = -535932632.4668834, tmp)+(((-1226598339.347982)<<((tmp = 616949449, tmp)/(tmp = 2779464046, tmp)))/(214578501.67984307)))); + assertEquals(1, x *= x); + assertEquals(1, x >>= ((tmp = 11080208, tmp)<<(460763913))); + assertEquals(-1.8406600706723492e-19, x /= ((tmp = -2334126306.1720915, tmp)*(tmp = 2327566272.5901165, tmp))); + assertEquals(856681434186007200, x -= ((tmp = -2286974992.8133907, tmp)*(374591518))); + assertEquals(3126084224, x >>>= x); + assertEquals(-1160460669, x |= (tmp = 181716099, tmp)); + assertEquals(873988096, x <<= (tmp = 406702419, tmp)); + assertEquals(0, x <<= ((tmp = 802107965.4672925, tmp)-((tmp = 1644174603, tmp)>>((tmp = 604679952, tmp)+(tmp = -515450096.51425123, tmp))))); + assertEquals(NaN, x %= ((x>>(tmp = 2245570378, tmp))*(tmp = 1547616585, tmp))); + assertEquals(NaN, x /= ((tmp = -776657947.0382309, tmp)&(tmp = 163929332.28270507, tmp))); + assertEquals(NaN, x *= (tmp = 243725679.78916526, tmp)); + assertEquals(NaN, x /= (x>>x)); + assertEquals(0, x <<= ((tmp = -1293291295.5735884, tmp)%(((((63309078)>>>x)&(x&(-2835108260.025297)))+x)>>>(-1317213424)))); + assertEquals(0, x *= ((((tmp = -1140319441.0068483, tmp)*(tmp = 2102496185, tmp))&(-2326380427))<<(tmp = -2765904696, tmp))); + assertEquals(0, x /= (tmp = 2709618593, tmp)); + assertEquals(0, x >>= (-1753085095.7670164)); + assertEquals(1766381484, x |= (-2528585812)); + assertEquals(1766381484, x %= (2735943476.6363373)); + assertEquals(1766381484, x %= (x*(tmp = 2701354268, tmp))); + assertEquals(-2147483648, x <<= (-323840707.4949653)); + assertEquals(4611686018427388000, x *= (x<<x)); + assertEquals(0, x <<= (3066735113)); + assertEquals(0, x ^= ((((x*x)^(tmp = -2182795086.39927, tmp))<<(x^(tmp = 1661144992.4371827, tmp)))<<((((-2885512572.176741)*(tmp = 609919485, tmp))|(tmp = 929399391.0790694, tmp))>>>((((((((((399048996)>>((-107976581.61751771)>>>x))|(((-1502100015)<<(tmp = -1108852531.9494338, tmp))&(x/(tmp = -3198795871.7239237, tmp))))+((-2627653357)>>x))>>>x)*(1066736757.2718519))%(tmp = 1326732482.201604, tmp))/(tmp = 2513496019.814191, tmp))>>>((1694891519)>>>(-2860217254.378931)))<<(tmp = 31345503, tmp))))); + assertEquals(0, x ^= (x/((-2556481161)>>>(x/(x%(x&(1302923615.7148068))))))); + assertEquals(NaN, x /= x); + assertEquals(NaN, x += (tmp = 846522031, tmp)); + assertEquals(0, x >>= (x+(-1420249556.419045))); + assertEquals(0, x ^= (((x%(-1807673170))&x)-x)); + assertEquals(-3484.311990686845, x -= ((((((-510347602.0068991)>>>x)<<((tmp = 1647999950, tmp)&(((305407727)>>((1781066601.791009)&x))<<((tmp = -998795238, tmp)%(((x/x)+x)<<(((2586995491.434947)<<x)-((((tmp = 545715607.9395425, tmp)*x)>>>x)>>>(((((2332534960.4595165)^(-3159493972.3695474))<<(tmp = 867030294, tmp))|(2950723135.753855))^(((3150916666)<<x)>>((tmp = 414988690, tmp)|((tmp = -1879594606, tmp)/(tmp = 1485647336.933429, tmp))))))))))))>>(tmp = -2676293177, tmp))%(617312699.1995015))/((((tmp = -1742121185, tmp)^((((x&x)<<(tmp = 698266916, tmp))/(-1860886248))+((-213304430)%((((((-2508973021.1333447)+(tmp = 2678876318.4903, tmp))&(tmp = -43584540, tmp))-x)^(-2251323850.4611115))-x))))>>>(tmp = 2555971284, tmp))%((((tmp = 16925106, tmp)^x)&x)|((x/((x|(tmp = -2787677257.125139, tmp))<<(-853699567)))+(tmp = -1721553520, tmp)))))); + assertEquals(-447873933.26863855, x += (-447870448.9566479)); + assertEquals(200591060101520900, x *= x); + assertEquals(200591062202483420, x -= (-2100962536)); + assertEquals(-5.261023346568228e+24, x *= ((tmp = -419641692.6377077, tmp)>>(tmp = -224703100, tmp))); + assertEquals(1269498660, x |= (195756836)); + assertEquals(1269498660, x |= x); + assertEquals(1269498660, x |= x); + assertEquals(-37.75978948486164, x /= (((tmp = -595793780, tmp)+((tmp = 2384365752, tmp)>>>(1597707155)))|((968887032)^(tmp = 2417905313.4337964, tmp)))); + assertEquals(-37.75978948486164, x %= (tmp = -1846958365.291661, tmp)); + assertEquals(1102319266.6421175, x += (1102319304.401907)); + assertEquals(-1664202255175155200, x -= ((x^(tmp = 407408729, tmp))*x)); + assertEquals(-752874653, x ^= (tmp = 314673507, tmp)); + assertEquals(-72474761, x |= (tmp = -2538726025.8884344, tmp)); + assertEquals(-72474761, x |= x); + assertEquals(-122849418, x += ((tmp = -2332080457, tmp)|(((((30496388.145492196)*(((-1654329438.451212)|(-2205923896))&(x>>(tmp = -1179784444.957002, tmp))))&(tmp = 319312118, tmp))*(651650825))|(((-2305190283)|x)>>>(-428229803))))); + assertEquals(994, x >>>= x); + assertEquals(614292, x *= (((((2565736877)/((tmp = 649009094, tmp)>>>(((x>>>(2208471260))>>(x>>>x))%x)))&(tmp = 357846438, tmp))<<(tmp = -2175355851, tmp))%x)); + assertEquals(1792008118, x |= (tmp = 1791924774.5121183, tmp)); + assertEquals(1246238208, x &= (tmp = 1264064009.9569638, tmp)); + assertEquals(-88877082, x ^= (2969289190.285704)); + assertEquals(0.044923746573582474, x /= ((tmp = -3057438043, tmp)^(-1009304907))); + assertEquals(0, x <<= ((-828383918)-((((x>>(734512101))*(tmp = -3108890379, tmp))-(x|((tmp = 3081370585.3127823, tmp)^((-271087194)-(x/(tmp = -2777995324.4073873, tmp))))))%x))); + assertEquals(1604111507.3365753, x -= (-1604111507.3365753)); + assertEquals(-1721314970, x ^= (tmp = -956686859, tmp)); + assertEquals(-102247425, x |= (tmp = -2535095555, tmp)); + assertEquals(-102247425, x %= (-955423877)); + assertEquals(1053144489850425, x *= (((tmp = 1583243590.9550207, tmp)&(1356978114.8592746))|(tmp = -10299961.622774363, tmp))); + assertEquals(-0.0043728190668037336, x /= ((-1196259252.435701)*(((-689529982)|(tmp = -1698518652.4373918, tmp))<<x))); + assertEquals(-2, x ^= (((x+(tmp = 2961627388, tmp))>>(tmp = 231666110.84104693, tmp))|x)); + assertEquals(-1, x >>= (tmp = -83214419.92958307, tmp)); + assertEquals(-1, x %= (-1303878209.6288595)); + assertEquals(2944850457.5213213, x -= (tmp = -2944850458.5213213, tmp)); + assertEquals(-1.6607884436053055, x /= (-1773164107)); + assertEquals(-0.6607884436053055, x %= ((x>>(1240245489.8629928))%(tmp = -3044136221, tmp))); + assertEquals(-0, x *= ((x*x)>>>((1069542313.7656753)+x))); + assertEquals(0, x >>>= (tmp = -202931587.00212693, tmp)); + assertEquals(-0, x *= (-375274420)); + assertEquals(0, x |= ((x/(((tmp = -876417141, tmp)*(x>>>x))&(-2406962078)))<<x)); + assertEquals(0, x &= ((tmp = -650283599.0780096, tmp)*(tmp = 513255913.34108484, tmp))); + assertEquals(3027255453.458466, x += (3027255453.458466)); + assertEquals(-12568623413253943000, x *= (((x-(198689694.92141533))|x)-x)); + assertEquals(-12568623410285185000, x -= (tmp = -2968758030.3694654, tmp)); + assertEquals(-2008903680, x &= (3111621747.7679076)); + assertEquals(-110045263.26583672, x += (tmp = 1898858416.7341633, tmp)); + assertEquals(15964, x >>>= (1141042034)); + assertEquals(31928, x += x); + assertEquals(0, x ^= x); + assertEquals(-1159866377, x |= (-1159866377)); + assertEquals(0, x ^= x); + assertEquals(3072699529.4306993, x -= (tmp = -3072699529.4306993, tmp)); + assertEquals(1, x /= x); + assertEquals(-1471195029, x |= (2823772267.429641)); + assertEquals(-4152937108, x += (-2681742079)); + assertEquals(142030188, x |= x); + assertEquals(270, x >>= (tmp = 1013826483, tmp)); + assertEquals(0, x >>>= (529670686)); + assertEquals(-2912300367, x -= (2912300367)); + assertEquals(2213791134963007500, x *= (x<<((((-3214746140)>>(tmp = -588929463, tmp))+((tmp = -3084290306, tmp)>>x))>>x))); + assertEquals(2213791133466809900, x -= (tmp = 1496197641, tmp)); + assertEquals(69834416, x >>>= (x|(((2755815509.6323137)^(x%(((x*((((tmp = 375453453, tmp)<<(x*x))>>(tmp = -973199642, tmp))*x))>>((tmp = -356288629, tmp)>>(tmp = 2879464644, tmp)))<<((((1353647167.9291127)>>>(x/x))<<((2919449101)/(2954998123.5529594)))^x))))&((-2317273650)>>>(tmp = 34560010.71060455, tmp))))); + assertEquals(69834416, x >>>= (x^(-2117657680.8646245))); + assertEquals(2217318064, x -= ((tmp = 2035883891, tmp)<<(tmp = -1884739265, tmp))); + assertEquals(-1272875686, x ^= (tmp = 805889002.7165648, tmp)); + assertEquals(-1272875686, x >>= (x&(((1750455903)*x)>>((722098015)%((tmp = 1605335626, tmp)>>(tmp = -565369634, tmp)))))); + assertEquals(-1274351316, x -= (x>>>((tmp = 2382002632, tmp)-((tmp = -2355012843, tmp)+(1465018311.6735773))))); + assertEquals(-2982908522.4418216, x -= ((tmp = 1635549038.4418216, tmp)+(((1952167017.720186)&((tmp = -2284822073.1002254, tmp)>>(-1403893917)))%(tmp = 655347757, tmp)))); + assertEquals(312, x >>>= x); + assertEquals(1248, x <<= (2376583906)); + assertEquals(0, x ^= x); + assertEquals(0, x *= ((((tmp = 1914053541.881434, tmp)>>>(tmp = 1583032186, tmp))>>>(-2511688231))%(tmp = -2647173031, tmp))); + assertEquals(0, x >>>= (tmp = -2320612994.2421227, tmp)); + assertEquals(0, x %= (((x+(tmp = -720216298.5403998, tmp))<<(414712685))>>(tmp = 480416588, tmp))); + assertEquals(0, x >>= ((((3039442014.271272)<<x)%(-2402430612.9724464))&((-2141451461.3664773)%((x>>(1361764256))/((tmp = -1723952801.9320493, tmp)%(477351810.2485285)))))); + assertEquals(-0, x /= (tmp = -1627035877, tmp)); + assertEquals(0, x >>>= (tmp = 1745193212, tmp)); + assertEquals(0, x >>>= (2309131575)); + assertEquals(NaN, x %= (((x*(tmp = -1730907131.6124666, tmp))%((((1481750041)|(x>>((((x>>>(tmp = 3128156522.5936565, tmp))/(tmp = -1277222645.9880452, tmp))^(tmp = -2327254789, tmp))+x)))>>>(-1161176960))>>>(tmp = 3135906272.5466847, tmp)))*(((((-2230902834.464362)^(1822893689.8183987))+(((tmp = 1597326356, tmp)/(x&((tmp = -3044163063.587389, tmp)>>(tmp = 2844997555, tmp))))%(x^x)))>>((x|x)/x))^(2634614167.2529745)))); + assertEquals(0, x &= (3081901595)); + assertEquals(0, x &= (-2453019214.8914948)); + assertEquals(0, x &= x); + assertEquals(0, x >>>= (-596810618.3666217)); + assertEquals(0, x >>= (((908276623)|x)/x)); + assertEquals(0, x ^= x); + assertEquals(958890056, x |= (tmp = 958890056.474458, tmp)); + assertEquals(1325436928, x <<= (tmp = -2474326583, tmp)); + assertEquals(711588532333838300, x *= ((-148161646.68183947)<<(tmp = -1149179108.8049204, tmp))); + assertEquals(0, x ^= (((2862565506)%x)/(tmp = -2865813112, tmp))); + assertEquals(-2064806628, x += (((tmp = -2677361175.7317276, tmp)/((817159440)>>>(tmp = 1895467706, tmp)))^(x|(tmp = -2309094859, tmp)))); + assertEquals(-69806982479424, x *= ((x&(tmp = 2857559765.1909904, tmp))&(-3166908966.754988))); + assertEquals(-430255744, x %= ((((((-2968574724.119535)<<x)<<((tmp = 1603913671, tmp)%((-1495838556.661653)^(tmp = 1778219751, tmp))))*(-400364265))<<((((1607866371.235576)-(1961740136))|(1259754297))&(tmp = -1018024797.1352971, tmp)))^x)); + assertEquals(6.828637393208647e-7, x /= (x*(tmp = 1464421, tmp))); + assertEquals(0, x &= x); + assertEquals(-0, x *= (((tmp = -2510016276, tmp)-(2088209546))<<((tmp = -1609442851.3789036, tmp)+(tmp = 1919930212, tmp)))); + assertEquals(-0, x %= (tmp = 1965117998, tmp)); + assertEquals(-290294792.53186846, x += ((tmp = -2361555894.5318685, tmp)%(2071261102))); + assertEquals(-70873, x >>= (tmp = 2206814124, tmp)); + assertEquals(-141746, x += x); + assertEquals(-141733.9831459089, x -= (((tmp = -806523527, tmp)>>>(tmp = 1897214891, tmp))/x)); + assertEquals(-141733.9831459089, x %= ((tmp = 1996295696, tmp)<<(tmp = 3124244672, tmp))); + assertEquals(141733.9831459089, x /= (x>>(2688555704.561076))); + assertEquals(3196954517.3075542, x -= (tmp = -3196812783.3244085, tmp)); + assertEquals(-19929155, x |= (((x|x)+x)^((tmp = 391754876, tmp)-(((((((tmp = -3051902902.5100636, tmp)*(x/(1546924993)))|(tmp = 1494375949, tmp))/((((-795378522)/(tmp = 509984856, tmp))>>>(tmp = -106173186, tmp))+x))|x)|(1916921307))>>>x)))); + assertEquals(1279271449, x &= ((tmp = 1289446971, tmp)&(tmp = 1836102619, tmp))); + assertEquals(17876992, x <<= (-207633461)); + assertEquals(0, x >>= (tmp = -903885218.9406946, tmp)); + assertEquals(0, x >>>= x); + assertEquals(-2999, x -= (((754533336.2183633)%(tmp = 557970276.0537136, tmp))>>(tmp = -1171045520, tmp))); + assertEquals(-0.000003020470363504361, x /= (tmp = 992891715.2229724, tmp)); + assertEquals(1, x /= x); + assertEquals(0.45768595820301217, x %= ((tmp = 673779031, tmp)/(tmp = -1242414872.3263657, tmp))); + assertEquals(-980843052.1872087, x += (tmp = -980843052.6448946, tmp)); + assertEquals(-Infinity, x /= ((((tmp = 317747175.8024508, tmp)&(x&(((tmp = 1632953053, tmp)>>x)/x)))%x)/(3145184986))); + assertEquals(0, x &= (x<<x)); + assertEquals(0, x ^= (x-((2969023660.5619783)/x))); + assertEquals(0, x *= x); + assertEquals(NaN, x %= (x/(((x-x)/((tmp = -1622970458.3812745, tmp)-(1626134522)))&((((((tmp = 1384729039.4149384, tmp)^(x%(tmp = -2736365959, tmp)))+((-1465172172)%x))>>(tmp = -1839184810.2603343, tmp))^(((tmp = 1756918419, tmp)>>>(x+(x%(tmp = -2011122996.9794662, tmp))))<<(-3026600748.902623)))*((tmp = -2040286580, tmp)>>(-2899217430.655154)))))); + assertEquals(0, x >>>= (tmp = 2100066003.3046467, tmp)); + assertEquals(1362012169, x ^= (tmp = 1362012169, tmp)); + assertEquals(1476312683, x |= ((457898409)>>>(-3079768830.723079))); + assertEquals(1441711, x >>>= (905040778.7770994)); + assertEquals(2078530607521, x *= x); + assertEquals(-208193103, x |= ((tmp = -241750000, tmp)^x)); + assertEquals(745036378, x ^= (((tmp = -1737151062.4726632, tmp)<<x)|(tmp = -1900321813, tmp))); + assertEquals(1744830464, x <<= x); + assertEquals(212992, x >>>= ((1210741037)-(x-(x>>>((x^(-1273817997.0036907))+((2401915056.5471)%(x<<(tmp = 1696738364.277438, tmp)))))))); + assertEquals(0.0001604311565639742, x /= (1327622418)); + assertEquals(0, x <<= (tmp = 166631979.34529006, tmp)); + assertEquals(0, x *= ((((tmp = 657814984, tmp)/(((-831055031)>>>(1531978379.1768064))|((tmp = 2470027754.302619, tmp)^(-223467597))))/(tmp = 1678697269.468965, tmp))&(tmp = -1756260071.4360774, tmp))); + assertEquals(-2049375053, x ^= (tmp = -2049375053, tmp)); + assertEquals(-1879109889, x |= (tmp = -1963586818.0436726, tmp)); + assertEquals(718239919, x ^= (tmp = -1523550640.1925273, tmp)); + assertEquals(-1361085185, x |= (-1939964707)); + assertEquals(2, x >>>= (1864136030.7395325)); + assertEquals(0.794648722849246, x %= ((-668830999)*(((-2227700170.7193384)%(x^(x>>>x)))/(tmp = 399149892, tmp)))); + assertEquals(0, x >>= x); + assertEquals(0, x *= x); + assertEquals(0, x &= ((tmp = -2389008496.5948563, tmp)|((((tmp = -2635919193.905919, tmp)*((-64464127)<<(2136112830.1317358)))>>((184057979)*(-1204959085.8362718)))>>>(-442946870.3341484)))); + assertEquals(-243793920, x -= ((tmp = 3002998032, tmp)<<((537875759)<<x))); + assertEquals(0, x -= x); + assertEquals(0, x *= ((((66852616.82442963)/((((x^x)&(2975318321.223734))+(((tmp = -1388210811.1249495, tmp)^((((-680567297.7620237)%(x-(tmp = -672906716.4672911, tmp)))-x)*(tmp = -1452125821.0132627, tmp)))*(((2770387154.5427895)%x)%x)))-x))<<((-1481832432.924325)>>(tmp = 3109693867, tmp)))>>>(x/(((((((tmp = 928294418, tmp)^(((-1018314535)/(tmp = -3167523001, tmp))%((((((tmp = -1639338126, tmp)-(tmp = -2613558829, tmp))&x)/x)%(tmp = 513624872, tmp))/((-520660667)&x))))*(2620452414))^((tmp = 2337189239.5949326, tmp)*(3200887846.7954993)))>>>((tmp = 1173330667, tmp)^x))<<x)>>(((tmp = -2475534594.982338, tmp)*x)|x))))); + assertEquals(0, x /= (2520915286)); + assertEquals(0, x &= x); + assertEquals(0, x >>= (-1908119327)); + assertEquals(0, x >>>= (tmp = 549007635, tmp)); + assertEquals(0, x >>= (-994747873.8117285)); + assertEquals(0, x <<= ((((x>>>((-3084793026.846681)%((1107295502)&(tmp = -296613957.8133817, tmp))))&((19637717.166736007)/(x+x)))+x)/(-2479724242))); + assertEquals(-695401420, x += (-695401420)); + assertEquals(-695401394, x += (x>>>(tmp = 2340097307.6556053, tmp))); + assertEquals(-555745552, x -= (x|(-483851950.68644))); + assertEquals(-17825792, x <<= x); + assertEquals(-17825792, x >>= x); + assertEquals(-17, x %= ((tmp = 1799361095, tmp)|((x>>(((-1201252592)<<((((543273288)+(-2859945716.606924))*x)<<((-3030193601)<<(3081129914.9217644))))|((1471431587.981769)>>(-246180750))))|(((tmp = -2689251055.1605787, tmp)>>x)&(((2131333169)^x)-((tmp = -951555489, tmp)/x)))))); + assertEquals(-8912896, x <<= (1146444211)); + assertEquals(2854567584, x += (tmp = 2863480480, tmp)); + assertEquals(426232502.24151134, x %= (1214167540.8792443)); + assertEquals(1806802048, x ^= (-2368317898)); + assertEquals(432537600, x <<= (tmp = 2831272652.589364, tmp)); + assertEquals(432537600, x %= (((1713810619.3880467)-x)&((-2853023009.553296)&(tmp = -3158798098.3355417, tmp)))); + assertEquals(-509804066, x += (tmp = -942341666, tmp)); + assertEquals(-509804066, x %= (-732349220)); + assertEquals(259900185710132350, x *= x); + assertEquals(711598501.7021885, x %= ((tmp = 2020395586.2280731, tmp)-(tmp = 3031459563.1386633, tmp))); + assertEquals(711598503.0618857, x += ((tmp = 967558548.4141241, tmp)/x)); + assertEquals(711598503, x &= x); + assertEquals(711598503, x ^= (((((1609355669.1963444)+((((tmp = -2660082403.258437, tmp)+(tmp = -235367868, tmp))&(x/x))*((-2595932186.69466)|((tmp = -3039202860, tmp)<<x))))>>>(-951354869))-((tmp = -691482949.6335375, tmp)/(tmp = -1735502400, tmp)))/(tmp = 798440377, tmp))); + assertEquals(558262613882868500, x *= (784519095.4299527)); + assertEquals(558262611968479000, x -= ((((tmp = 1039039153.4026555, tmp)/(-3138845051.6240187))*(tmp = 633557994, tmp))&(1981507217))); + assertEquals(1170427648, x |= ((x>>((((-1086327124)%((tmp = -1818798806.368613, tmp)^(tmp = 2183576654.9959817, tmp)))>>x)&((((((tmp = 1315985464.0330539, tmp)&(2774283689.333836))%x)*((2722693772.8994813)&(tmp = -2720671984.945404, tmp)))^(tmp = -76808019, tmp))<<((tmp = 685037799.2336662, tmp)^((tmp = 1057250849, tmp)&(tmp = 1469205111.2989025, tmp))))))+(x*(((tmp = 448288818.47173154, tmp)-(-2527606231))-((8387088.402292728)>>x))))); + assertEquals(558, x >>>= (tmp = 2732701109, tmp)); + assertEquals(558, x &= x); + assertEquals(-0.00015855057024653912, x /= ((x+(((tmp = -1963815633, tmp)-(x>>x))-((x|x)>>x)))/x)); + assertEquals(1.3458861596445712e-13, x /= (-1178038492.4116466)); + assertEquals(0, x <<= (-104550232)); + assertEquals(0, x >>>= (x>>(tmp = -255275244.12613606, tmp))); + assertEquals(0, x >>= x); + assertEquals(375, x |= ((1576819294.6991196)>>>(-2570246122))); + assertEquals(96000, x <<= ((2252913843.0150948)>>>(-49239716))); + assertEquals(6144000, x <<= ((((tmp = -2478967279, tmp)&((x%((tmp = -1705332610.8018858, tmp)+(x+(tmp = 590766349, tmp))))<<(tmp = 1759375933, tmp)))+(-2024465658.849834))&(1564539207.3650014))); + assertEquals(-1149239296, x <<= (1862803657.7241006)); + assertEquals(-9, x >>= (((tmp = 463306384.05696774, tmp)^x)|((x>>((((-2098070856.799663)<<((-2054870274.9012866)<<(((-2582579691)/(829257170.0266814))<<(((((tmp = -1753535573.7074275, tmp)<<((x>>(-197886116))%((2487188445)%(tmp = 2465391564.873364, tmp))))&(((tmp = -500069832, tmp)&(tmp = 3016637032, tmp))&((tmp = 2525942628, tmp)|((((-920996215)|x)^((((tmp = -687548533.419106, tmp)&(1423222636.058937))<<((tmp = -1096532228, tmp)>>((((tmp = -3124481449.2740726, tmp)^(tmp = 2724328271.808975, tmp))>>x)*x)))+(-1661789589.5808442)))+(((x*(tmp = -1224371664.9549093, tmp))^((tmp = 3202970043, tmp)^x))/(tmp = 131494054.58501709, tmp))))))|(((tmp = -1654136720, tmp)<<x)>>((1652979932.362416)-(tmp = -863732721, tmp))))^(-113307998)))))^(-90820449.91417909))*((tmp = 641519890, tmp)-((((x<<(tmp = 2349936514.071881, tmp))*(2324420443.587892))^x)%(x<<((tmp = -1838473742, tmp)/(((-3154172718.4274178)-x)+x)))))))|(x>>>((tmp = 2096024376.4308293, tmp)<<x))))); + assertEquals(81, x *= x); + assertEquals(81, x &= x); + assertEquals(81, x %= (tmp = 2223962994, tmp)); + assertEquals(81, x ^= ((x/(((-1606183420.099584)|(-1242175583))&(((x|((tmp = 828718431.3311573, tmp)/(x>>x)))+(((-2207542725.4531174)^(x*x))*(tmp = 551575809.955105, tmp)))/x)))&((x>>x)&x))); + assertEquals(81, x %= (tmp = 279598358.6976975, tmp)); + assertEquals(101.72338484518858, x -= (((tmp = 2452584495.44003, tmp)%((-1181192721)+(((x>>(((x&x)^x)+((x>>>((x+(-2472793823.57181))/(((2854104951)>>(-1208718359.6554642))>>>(1089411895.694705))))/(x|(-2821482890.1780205)))))^(-1786654551))/(-29404242.70557475))))/(((-4352531)<<((-1227287545)<<x))%(-2558589438)))); + assertEquals(101.72338484518858, x %= (-943645643)); + assertEquals(0, x -= x); + assertEquals(0, x >>>= (-2440404084)); + assertEquals(0, x >>= (tmp = 1029680958.405923, tmp)); + assertEquals(0, x >>>= (1213820208.7204895)); + assertEquals(-0, x /= (tmp = -103093683, tmp)); + assertEquals(0, x >>>= (-2098144813)); + assertEquals(-0, x /= (((-3087283334)+(((tmp = -3129028112.6859293, tmp)%(tmp = 2413829931.1605015, tmp))-(2578195237.8071446)))|x)); + assertEquals(-15, x |= ((((-178926550.92823577)>>>(-965071271))^((tmp = -484633724.7237625, tmp)-(tmp = 473098919.1486404, tmp)))>>((-2264998310.203265)%(tmp = -499034672, tmp)))); + assertEquals(0, x ^= x); + assertEquals(0, x >>= (((-3207915976.698118)<<(tmp = 2347058630, tmp))|(tmp = -2396250098.559627, tmp))); + assertEquals(NaN, x %= x); + assertEquals(NaN, x *= (621843222)); + assertEquals(0, x >>= (((-2409032228.7238913)*x)-(tmp = -887793239, tmp))); + assertEquals(NaN, x /= x); + assertEquals(1193017666, x ^= (tmp = 1193017666, tmp)); + assertEquals(3.5844761899682753, x /= (tmp = 332829011.206393, tmp)); + assertEquals(-888572929, x |= (((tmp = 1032409228, tmp)+(tmp = -1920982163.7853453, tmp))+x)); + assertEquals(-1817051951333455600, x *= (((-1506265102)^(tmp = -775881816, tmp))-(tmp = -32116372.59181881, tmp))); + assertEquals(-1638479616, x |= x); + assertEquals(-114489, x %= (((tmp = -247137297.37866855, tmp)>>>((((((-322805409)-x)^x)>>((((((((x>>>(tmp = -900610424.7148039, tmp))/(-1155208489.6240904))|((-2874045803)|(tmp = 3050499811, tmp)))+(x/((tmp = -613902712, tmp)^((-982142626.2892077)*((((tmp = -3201753245.6026397, tmp)|((1739238762.0423079)^x))/(243217629.47237313))^((tmp = -11944405.987132788, tmp)/(tmp = 2054031985.633406, tmp)))))))*(tmp = 2696108952.450961, tmp))*x)>>>(tmp = 3058430643.0660386, tmp))>>(x<<x)))>>(-984468302.7450335))%((tmp = 1302320585.246251, tmp)>>>x)))%(tmp = -2436842285.8208156, tmp))); + assertEquals(2047, x >>>= (2380161237)); + assertEquals(0, x >>= x); + assertEquals(0, x &= (tmp = 980821012.975836, tmp)); + assertEquals(-1090535537, x -= ((-3064511503.1214876)&((tmp = -2598316939.163751, tmp)<<((tmp = -969452391.8925576, tmp)*x)))); + assertEquals(-2181071074, x += x); + assertEquals(1, x >>>= ((2902525386.449062)>>x)); + assertEquals(1, x += (x&(tmp = -2643758684.6636515, tmp))); + assertEquals(1, x %= ((tmp = -2646526891.7004848, tmp)/x)); + assertEquals(448735695.7888887, x -= (tmp = -448735694.7888887, tmp)); + assertEquals(1, x /= x); + assertEquals(1, x >>= ((-480385726)<<(2641021142))); + assertEquals(1, x %= (375099107.9200462)); + assertEquals(1, x >>= (((x&((tmp = -2402469116.9903326, tmp)%(tmp = -2862459555.860298, tmp)))*(tmp = -2834162871.0586414, tmp))%(((x>>>(tmp = 721589907.5073895, tmp))*(x^x))%(((tmp = 2844611489.231776, tmp)^((983556913)&(906035409.6693488)))^(x>>>(1239322375)))))); + assertEquals(268435456, x <<= (tmp = 178807644.80966163, tmp)); + assertEquals(44, x %= ((tmp = 2527026779.081539, tmp)>>>(2736129559))); + assertEquals(88, x += x); + assertEquals(0, x >>>= x); + assertEquals(0, x -= x); + assertEquals(-1523121602, x |= (2771845694)); + assertEquals(-2, x >>= x); + assertEquals(-4, x += x); + assertEquals(-256, x <<= (((2522793132.8616533)>>(tmp = 77232772.94058788, tmp))+(3118669244.49152))); + assertEquals(4294967040, x >>>= x); + assertEquals(-256, x &= x); + assertEquals(1278370155.835435, x -= (-1278370411.835435)); + assertEquals(-3.488228054921667, x /= (tmp = -366481243.6881058, tmp)); + assertEquals(1.162742684973889, x /= ((x|(((((2404819175.562809)*(tmp = -2524589506, tmp))&(tmp = -675727145, tmp))>>>(x*x))&((-413250006)<<(tmp = 2408322715, tmp))))|((2940367603)>>>x))); + assertEquals(0, x >>>= ((2513665793)-(tmp = 1249857454.3367786, tmp))); + assertEquals(0, x ^= x); + assertEquals(0, x ^= x); + assertEquals(1989998348.6336238, x -= (-1989998348.6336238)); + assertEquals(903237918.986834, x %= (1086760429.6467898)); + assertEquals(-4.4185765232981975, x /= (-204418304)); + assertEquals(1471621914, x ^= (tmp = -1471621914.1771696, tmp)); + assertEquals(1471621914, x |= ((((((x<<(tmp = -2676407394.536844, tmp))%(((343324258)+(x/(x>>(((-221193011)>>>x)|x))))>>(((-2737713893)^((tmp = -49214797.00735545, tmp)+((-2818106123.172874)/(tmp = -2361786565.3028684, tmp))))<<(1859353297.6355076))))*(tmp = -751970685, tmp))|((tmp = 2502717391.425871, tmp)/(tmp = -2647169430, tmp)))*((tmp = -1647567294, tmp)&(((tmp = 1819557651, tmp)/x)>>((((-3073469753)/x)-(((tmp = -1973810496.6407511, tmp)&((x-(x+(tmp = -2986851659, tmp)))>>>(tmp = -2226975699, tmp)))|(418770782.142766)))<<x))))*(((((tmp = 125466732, tmp)/((((1453655756.398259)|(((874792086.7064595)-(194880772.91499102))>>>x))%(x<<(tmp = -1445557137, tmp)))<<x))>>>(tmp = -1953751906, tmp))/((tmp = -2140573172.2979035, tmp)*((-108581964)^x)))|(-481484013.0393069)))); + assertEquals(1454179065, x += ((tmp = 947147038.2829313, tmp)|(tmp = -154822975.3629098, tmp))); + assertEquals(1, x /= x); + assertEquals(1, x %= ((((((tmp = -2262250297.991866, tmp)-(tmp = 481953960, tmp))/(1629215187.6020458))|(2515244216))>>>((tmp = -3040594752.2184515, tmp)-(tmp = -1116041279, tmp)))^(((-182133502)-(1065160192.6609197))+(((((-1850040207)^(tmp = -1570328610, tmp))^(tmp = 20542725.09256518, tmp))*x)|(2386866629))))); + assertEquals(1, x &= (2889186303)); + assertEquals(0, x >>= (((-1323093107.050538)>>(x%x))-(((((((-1736522840)+(tmp = -2623890690.8318863, tmp))*(959395040.5565329))*(233734920))<<((x+(x%((tmp = -2370717284.4370327, tmp)%(tmp = 2109311949, tmp))))-(tmp = -1005532894, tmp)))|(861703605))>>>((2399820772)/x)))); + assertEquals(0, x >>= x); + assertEquals(57233408, x |= ((tmp = 2655923764.4179816, tmp)*(-1353634624.3025436))); + assertEquals(997939728, x |= (980552208.9005274)); + assertEquals(1859642592476610800, x *= (1863481872)); + assertEquals(-977190656, x <<= x); + assertEquals(4.378357529141239e+26, x *= ((((x/(((tmp = 2429520991, tmp)/(x/(tmp = 784592802, tmp)))-(tmp = -2704781982, tmp)))*(tmp = -2161015768.2322354, tmp))&((((-3164868762)>>(tmp = 2390893153.32907, tmp))^x)>>(-2422626718.322538)))*(tmp = 278291869, tmp))); + assertEquals(4.378357529141239e+26, x -= (1710777896.992369)); + assertEquals(0, x &= (((((tmp = -2532956158.400033, tmp)|((2195255831.279001)|(1051047432)))|(-1628591858))|(tmp = -2042607521.947963, tmp))>>((-1471225208)/(((-133621318)>>(1980416325.7358408))*((1741069593.1036062)-(x|(2133911581.991011))))))); + assertEquals(-0, x /= (-656083507)); + assertEquals(NaN, x += ((tmp = -1071410982.2789869, tmp)%x)); + assertEquals(NaN, x *= (tmp = -1513535145.3146675, tmp)); + assertEquals(0, x >>= ((2831245247.5267224)>>(x<<((x+(((3068824580.7922907)|(1708295544.275714))*((tmp = -1662930228.1170444, tmp)-(((tmp = 1979994889, tmp)<<(tmp = -1826911988, tmp))&((x/(x<<(1909384611.043981)))+(1958052414.7139997))))))<<(tmp = 2481909816.56558, tmp))))); + assertEquals(0, x *= (((tmp = -2979739958.1614842, tmp)&x)+x)); + assertEquals(-0, x *= ((-332769864.50313234)^x)); + assertEquals(0, x >>= ((((689018886.1436445)+(tmp = -2819546038.620694, tmp))|(((tmp = -1459669934.9066005, tmp)|x)/x))<<(((tmp = 2640360389, tmp)/((x%((-1947492547.9056122)%((1487212416.2083092)-(-1751984129))))^x))%(tmp = 2666842881, tmp)))); + assertEquals(-1801321460, x |= (tmp = 2493645836, tmp)); + assertEquals(-1801321460, x %= (2400405136)); + assertEquals(-2905399858195810300, x *= (tmp = 1612926911, tmp)); + assertEquals(-2905399858195810300, x -= (x>>(tmp = 1603910263.9593458, tmp))); + assertEquals(-238798848, x &= ((tmp = -2638646212.767516, tmp)/(((tmp = 1755616291.436998, tmp)>>>(tmp = 1083349775, tmp))-(x%(((tmp = 1728859105.53634, tmp)^(1931522619.0403612))/(tmp = 712460587.0025489, tmp)))))); + assertEquals(-2363873607.2302856, x += (-2125074759.230286)); + assertEquals(1712665, x &= (((117229515)>>>(((1707090894.1915488)>>>((-1696008695)>>(((-1045367326.7522249)<<(tmp = -209334716, tmp))-x)))|(-1707909786.080653)))%(1260761349.172689))); + assertEquals(1073741824, x <<= (tmp = -289437762.34742975, tmp)); + assertEquals(1073741824, x &= (tmp = 2079141140, tmp)); + assertEquals(0, x <<= ((x^(-3139646716.1615124))-(((-362323071.74237394)|(tmp = 2989896849, tmp))*(tmp = -218217991, tmp)))); + assertEquals(0, x &= (tmp = -1476835288.425903, tmp)); + assertEquals(0, x >>>= (tmp = 61945262.70868635, tmp)); + assertEquals(0, x ^= x); + assertEquals(-2735263498.7189775, x -= (2735263498.7189775)); + assertEquals(-1182289920, x <<= (x+x)); + assertEquals(-1182289580, x ^= ((2858446263.2258)>>>(2387398039.6273785))); + assertEquals(696693056, x &= ((2178665823)*(-51848583))); + assertEquals(1652555776, x <<= (((tmp = 2943916975, tmp)-((-1544273901)>>(-1671503106.2896929)))|x)); + assertEquals(6455296, x >>>= (tmp = 1492638248.675439, tmp)); + assertEquals(2097152, x &= (((x|x)*(2873891571.7000637))^((2165264807)+(tmp = 451721563, tmp)))); + assertEquals(2097152, x %= (tmp = 1089484582.1455994, tmp)); + assertEquals(2097152, x <<= x); + assertEquals(2097152, x &= ((tmp = 119096343.4032247, tmp)^((-1947874541)*x))); + assertEquals(0, x &= (tmp = 2363070677, tmp)); + assertEquals(0, x &= ((tmp = -1897325383, tmp)>>>((2368480527)>>>((tmp = 1837528979, tmp)*(-1838904077))))); + assertEquals(-1898659416, x ^= (-1898659416.1125412)); + assertEquals(-725506048, x <<= x); + assertEquals(1392943104, x <<= (295287938.9104482)); + assertEquals(-63620329, x ^= ((tmp = -3175925826.5573816, tmp)-(tmp = 2474613927, tmp))); + assertEquals(-1135111726, x -= ((tmp = -1133259081, tmp)^(((tmp = -742228219, tmp)>>((-7801909.587711811)%((tmp = -642758873, tmp)+(tmp = 2893927824.6036444, tmp))))^((tmp = -2145465178.9142997, tmp)+x)))); + assertEquals(0, x ^= x); + assertEquals(660714589, x |= (660714589)); + assertEquals(660714676, x ^= ((-376720042.8047826)>>>(2196220344))); + assertEquals(660714676, x |= ((((((((x<<(-1140465568))-(tmp = -1648489774.1573918, tmp))%(((tmp = -2955505390.573639, tmp)*x)<<((((tmp = -1769375963, tmp)*(tmp = -440619797, tmp))&((tmp = 1904284066, tmp)%(-2420852665.0629807)))+(-324601009.2063596))))>>(tmp = 2317210783.9757776, tmp))^((tmp = 750057067.4541628, tmp)^(tmp = -1391814244.7286487, tmp)))>>((344544658.6054913)%((tmp = -1508630423.218488, tmp)&(tmp = 1918909238.2974637, tmp))))>>((-647746783.685822)&(tmp = 2444858958.3595476, tmp)))&x)); + assertEquals(-962337195, x ^= (tmp = -507358495.30825853, tmp)); + assertEquals(-182008925.58535767, x %= (tmp = -195082067.35366058, tmp)); + assertEquals(502070, x >>>= (tmp = 1459732237.1447744, tmp)); + assertEquals(-2391009930.7235765, x -= (tmp = 2391512000.7235765, tmp)); + assertEquals(1568669696, x <<= x); + assertEquals(0, x <<= (tmp = -571056688.2717848, tmp)); + assertEquals(1770376226, x ^= (tmp = 1770376226.0584736, tmp)); + assertEquals(0, x ^= x); + assertEquals(0, x &= ((((x<<x)>>>x)|x)|(((tmp = -2141573723, tmp)^x)|(64299956)))); + assertEquals(0, x ^= x); + assertEquals(0, x &= x); + assertEquals(0, x <<= (1106060336.7362857)); + assertEquals(-0, x /= (x|(tmp = 2760823963, tmp))); + assertEquals(0, x <<= ((-2436225757)|(-1800598694.4062433))); + assertEquals(0, x >>>= ((-728332508.9870625)<<x)); + assertEquals(-173377680, x ^= ((tmp = -173377680, tmp)%(tmp = -2843994892, tmp))); + assertEquals(-173377680, x |= ((((-819217898)&(tmp = -1321650255, tmp))&(x+((x^x)<<((1700753064)>>((((((-1038799327)>>((782275464)^x))-(tmp = -2113814317.8539028, tmp))>>(2143804838))&x)-((2970418921)/(-3073015285.6587048)))))))&((-1759593079.4077306)%((1699128805)-((tmp = -467193967, tmp)&(((2225788267.3466334)*(((2687946762.5504274)+x)>>>x))<<(-1853556066.880512))))))); + assertEquals(-0.5520657226957338, x /= ((tmp = -755493878, tmp)&(tmp = 918108389, tmp))); + assertEquals(0.30477656217556287, x *= x); + assertEquals(0, x &= ((tmp = -2746007517, tmp)<<(2749629340))); + assertEquals(0, x ^= ((x%(tmp = 1683077876, tmp))%(-162706778))); + assertEquals(0, x *= (tmp = 10203423, tmp)); + assertEquals(119043212.1461842, x += (tmp = 119043212.1461842, tmp)); + assertEquals(587202560, x <<= (tmp = 658697910.7051642, tmp)); + assertEquals(-138689730, x |= (x-(tmp = 1296317634.5661907, tmp))); + assertEquals(-138663011, x -= ((-1751010109.5506423)>>(152829872))); + assertEquals(-138663011, x %= (-1266200468)); + assertEquals(-138663011, x &= (x|((tmp = -571277275.622529, tmp)<<x))); + assertEquals(-138663011, x >>= ((971259905.1265712)*(tmp = 2203764981, tmp))); + assertEquals(-138663011, x %= (-904715829)); + assertEquals(-138663011, x |= ((tmp = -2823047885.283391, tmp)>>>(((tmp = 533217000, tmp)|(650754598.7836078))|(-1475565890)))); + assertEquals(-1610612736, x <<= x); + assertEquals(-1610612736, x &= x); + assertEquals(163840, x >>>= (-188885010)); + assertEquals(-1224224814, x |= (tmp = 3070742482, tmp)); + assertEquals(1498726395213334500, x *= x); + assertEquals(1723591210, x |= ((tmp = 615164458, tmp)|x)); + assertEquals(1721910480, x ^= (x>>>x)); + assertEquals(4505284605.764313, x -= (tmp = -2783374125.7643127, tmp)); + assertEquals(-9504912393868483000, x *= (((tmp = 2896651872, tmp)<<(-2896385692.9017262))&(((((tmp = -2081179810.20238, tmp)|(tmp = -2484863999, tmp))>>((tmp = 1560885110.2665749, tmp)/(((tmp = 934324123.4289343, tmp)<<((tmp = -1591614157.0496385, tmp)+x))/(((x%(((tmp = 1672629986.8055913, tmp)%x)>>(tmp = 2116315086.2559657, tmp)))/(((-2687682697.5806303)>>x)/(-2034391222.5029132)))%(x-((((((tmp = 2598594967, tmp)/(((((((2950032233)%x)/x)^(tmp = -2126753451.3732262, tmp))<<(tmp = -3019113473, tmp))+(tmp = -2021220129.2320697, tmp))%((((-587645875.4666483)>>(((((x+x)+x)&(tmp = 533801785, tmp))|x)-((tmp = -2224808495.678903, tmp)/(1501942300))))>>>(-2558947646))>>((2798508249.020792)>>>x))))>>>((1060584557)/((((((((x&x)|(1426725365))>>>(tmp = 1500508838, tmp))>>(-1328705938))*((tmp = -2288009425.598777, tmp)>>>(((2586897285.9759064)%((-1605651559.2122297)>>>(tmp = 1936736684.4887302, tmp)))+((tmp = 2316261040, tmp)^(570340750.353874)))))&(x^((tmp = -2266524143, tmp)-(tmp = 2358520476, tmp))))+(tmp = 1449254900.9222453, tmp))%((-100598196)%((tmp = -2985318242.153491, tmp)>>((620722274.4565848)>>(871118975)))))))<<x)*(tmp = -1287065606.4143271, tmp))>>>(1038059916.2438471)))))))+((x/(-276990308.1264961))&(tmp = 2471016351.2195315, tmp)))|(((((tmp = -1288792769.3210807, tmp)+((tmp = -641817194, tmp)*(x<<(((-1933817364)>>(((tmp = 2084673536, tmp)|x)&x))&(tmp = -2752464480, tmp)))))%((796026752)*x))+(((tmp = -3083359669, tmp)|x)-((715303522)|(tmp = 181297266, tmp))))*(-1691520182.3207517))))); + assertEquals(0, x <<= (-2322389800)); + assertEquals(0, x *= (tmp = 3188682235, tmp)); + assertEquals(0, x |= (x>>>((tmp = -2729325231.8288336, tmp)^((-393497076.96012783)*(x/(tmp = -2198942459.9466457, tmp)))))); + assertEquals(0, x ^= x); + assertEquals(0, x %= (2835024997.4447937)); + assertEquals(0, x <<= x); + assertEquals(0, x >>= (tmp = 1109824126, tmp)); + assertEquals(0, x <<= (3013043386)); + assertEquals(206825782.74659085, x -= (-206825782.74659085)); + assertEquals(-645346761227699500, x *= (-3120243292)); + assertEquals(6825462, x >>= ((tmp = 1457908135, tmp)<<x)); + assertEquals(-612366097.9189918, x -= (619191559.9189918)); + assertEquals(-612306090.9189918, x -= ((2328676543.893506)>>x)); + assertEquals(0, x ^= (x>>(((x>>>(1856200611.2269292))&(tmp = 2003217473, tmp))%((((((-107135673)+(((3062079356.170611)<<(tmp = -676928983, tmp))>>((tmp = -1487074941.2638814, tmp)|((-1601614031)/(1317006144.5025365)))))+x)*(((1163301641)>>>(448796567))/((x%((tmp = 72293197.34410787, tmp)+(-2304112723)))/((455610361)%(-2799431520)))))>>>(-217305041.09432888))<<(x-(tmp = -2168353649, tmp)))))); + assertEquals(0, x >>= x); + assertEquals(-Infinity, x -= (((-1651597599.8950624)+(1780404320))/x)); + assertEquals(0, x <<= (tmp = 2246420272.4321294, tmp)); + assertEquals(0, x *= ((2793605382)-(tmp = -272299011, tmp))); + assertEquals(0, x *= x); + assertEquals(0, x <<= x); + assertEquals(0, x >>= (tmp = 2556413090, tmp)); + assertEquals(0, x >>= ((tmp = -1784710085, tmp)%x)); + assertEquals(0, x %= (tmp = -1929880813, tmp)); + assertEquals(0, x *= (2586983368)); + assertEquals(0, x &= x); + assertEquals(0, x <<= (-2144588807)); + assertEquals(0, x ^= ((x<<(((((((-596537598)+((x-(((((((tmp = -3179604796, tmp)/((tmp = 1156725365.3543215, tmp)>>>(tmp = -2762144319, tmp)))%(x<<x))&((tmp = 1750241928.1271567, tmp)&(x/((tmp = 1781306819, tmp)|x))))+((((2893068644)/((tmp = -576164593.9720252, tmp)<<((2724671.48995471)&(tmp = -573132475, tmp))))%(tmp = -1355625108, tmp))&(tmp = -302869512.5880568, tmp)))+x)<<x))>>((tmp = -2569172808, tmp)/x)))^x)-(tmp = -1174006275.2213159, tmp))&x)&(((((((-2303274799)>>(tmp = -814839320, tmp))/(tmp = 183887306.09810615, tmp))>>(((tmp = 1054106394.3704875, tmp)|x)>>>x))-(x-(tmp = 1313696830, tmp)))-((tmp = 2373274399.0742035, tmp)|((((tmp = -3163779539.4902935, tmp)*(tmp = -3056125181.726942, tmp))&(((x^(x^(x/((tmp = -576441696.6015451, tmp)<<(tmp = -26223719.920306206, tmp)))))>>(tmp = -2332835940, tmp))|((-146303509.41093707)&(tmp = -2676964025, tmp))))/((((x*(tmp = 1059918020, tmp))|((((2341797349)|(tmp = -744763805.1381104, tmp))<<x)+((2991320875.552578)^(2920702604.701831))))^(-1721756138))^(((tmp = -2794367554, tmp)>>((-2671235923.2097874)<<(x&((((tmp = -621472314.0859051, tmp)-(((x*x)+x)>>>((tmp = 1834038956, tmp)+x)))*x)^(tmp = -2090567586.321468, tmp)))))<<(321395210))))))>>>(tmp = -1207661719, tmp)))+(-2877264053.3805156)))/(x%(tmp = -2226991657.709366, tmp)))); + assertEquals(0, x *= (tmp = 986904991.061398, tmp)); + assertEquals(0, x -= (x%(650819306.6671969))); + assertEquals(0, x >>>= (905893666.2871252)); + assertEquals(0, x += (((tmp = 2501942710.4804144, tmp)&x)/((tmp = -851080399.1751502, tmp)-(-1168623992)))); + assertEquals(-0, x *= (tmp = -2014577821.4554045, tmp)); + assertEquals(0, x &= (tmp = 1995246018, tmp)); + assertEquals(0, x %= (1724355237.7031958)); + assertEquals(-954696411, x += (((-2825222201)+(((1662353496.1795506)>>>(x-x))|(tmp = 225015046, tmp)))^(x&x))); + assertEquals(-2158427339993389800, x *= (2260852052.1539803)); + assertEquals(19559, x >>>= (-862409169.4978967)); + assertEquals(-0.000012241163878671237, x /= (x^(tmp = 2697144215.160239, tmp))); + assertEquals(0, x -= x); + assertEquals(1448177644, x |= (tmp = 1448177644.624848, tmp)); + assertEquals(1448177644, x %= (((-1497553637.4976408)+(402228446))<<x)); + assertEquals(2304640553, x -= (-856462909)); + assertEquals(152436736, x &= ((766686903)*(((tmp = 660964683.1744609, tmp)|((((tmp = 297369746, tmp)-(x+((tmp = -2677127146, tmp)/x)))>>(((((((x%(x<<x))-(((((529254728)|((x|(-1407086127.6088922))&(tmp = -1968465008.5000398, tmp)))/(x%x))&((((-2761805265.92574)-x)*(x^(tmp = 110730179, tmp)))%((177220657.06030762)*(((2532585190.671373)/x)+(-1465143151)))))<<((tmp = -3008848338, tmp)<<(-2475597073))))|((-192996756.38619018)|((((1445996780)|(x>>>((((tmp = -2482370545.791443, tmp)*(tmp = -270543594, tmp))^x)*((1346780586)/(tmp = -625613363.885356, tmp)))))-(x<<(x/(-562307527))))&(-125701272))))*((x&x)%(tmp = 752963070, tmp)))>>>(tmp = 17419750.79086232, tmp))*x)^(x^((-157821212.04674292)-(tmp = 503849221.598824, tmp)))))-(tmp = 1479418449, tmp)))>>>((((((-78138548.2193842)<<(((2319032860.806689)-(tmp = -1564963892.5137577, tmp))>>>(-73673322.28957987)))<<((1797573493.3467085)*x))>>(tmp = 759994997, tmp))>>>(-1066441220))&(((((((tmp = 1972048857, tmp)*(((x&((-1347017320.0747669)>>>x))*(-2332716925.705054))%(-376976019.24362826)))>>>((tmp = -466479974, tmp)+x))&(-2282789473.3675604))|(((((((((269205423.7510414)-(tmp = 21919626.105656862, tmp))*((x-(tmp = -378670528, tmp))>>(tmp = -1045706598, tmp)))>>(tmp = -3062647341.234485, tmp))>>>x)|(tmp = -285399599.9386575, tmp))%(tmp = 2731214562, tmp))|((((tmp = 837093165.3438574, tmp)|(tmp = -2956931321, tmp))+((1871874558.3292787)<<((x|((tmp = -3169147427, tmp)%(((x^x)%(1479885041))%((1769991217)%(tmp = -1899472458, tmp)))))*(tmp = -837098563.71806, tmp))))>>(tmp = -1866722748, tmp)))-(2037734340.8345597)))>>((tmp = -1262019180.5332131, tmp)+(x*(1274173993.9800131))))*(tmp = 2336989321.855402, tmp)))))); + assertEquals(4, x >>= (tmp = -2577728327, tmp)); + assertEquals(16, x *= (x<<((2622323372.580596)*(tmp = -1947643367, tmp)))); + assertEquals(33554432, x <<= (tmp = -2938370507, tmp)); + assertEquals(-2399497018.987414, x -= (tmp = 2433051450.987414, tmp)); + assertEquals(1, x /= x); + assertEquals(2, x <<= x); + assertEquals(0, x >>= (x&x)); + assertEquals(0, x <<= x); +} +f(); diff --git a/src/3rdparty/v8/test/mjsunit/numops-fuzz.js b/src/3rdparty/v8/test/mjsunit/numops-fuzz.js deleted file mode 100644 index bd7e4fa..0000000 --- a/src/3rdparty/v8/test/mjsunit/numops-fuzz.js +++ /dev/null @@ -1,4609 +0,0 @@ -// Copyright 2011 the V8 project authors. All rights reserved. -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following -// disclaimer in the documentation and/or other materials provided -// with the distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived -// from this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -function f() { - var x = 0; - var tmp = 0; - assertEquals(0, x /= (tmp = 798469700.4090232, tmp)); - assertEquals(0, x *= (2714102322.365509)); - assertEquals(0, x *= x); - assertEquals(139516372, x -= (tmp = -139516372, tmp)); - assertEquals(1, x /= (x%(2620399703.344006))); - assertEquals(0, x >>>= x); - assertEquals(-2772151192.8633175, x -= (tmp = 2772151192.8633175, tmp)); - assertEquals(-2786298206.8633175, x -= (14147014)); - assertEquals(1509750523, x |= ((1073767916)-(tmp = 919311632.2789925, tmp))); - assertEquals(2262404051.926751, x += ((752653528.9267509)%x)); - assertEquals(-270926893, x |= (tmp = 1837232194, tmp)); - assertEquals(0.17730273401688765, x /= ((tmp = -2657202795, tmp)-(((((x|(tmp = -1187733892.282897, tmp))-x)<<(556523578))-x)+(-57905508.42881298)))); - assertEquals(122483.56550261026, x *= ((((tmp = 2570017060.15193, tmp)%((-1862621126.9968336)>>x))>>(x>>(tmp = 2388674677, tmp)))>>>(-2919657526.470434))); - assertEquals(0, x ^= x); - assertEquals(0, x <<= (tmp = 2705124845.0455265, tmp)); - assertEquals(0, x &= (-135286835.07069612)); - assertEquals(-0, x *= ((tmp = -165810479.10020828, tmp)|x)); - assertEquals(248741888, x += ((735976871.1308595)<<(-2608055185.0700903))); - assertEquals(139526144, x &= (tmp = -1454301068, tmp)); - assertEquals(-0.047221345672746884, x /= (tmp = -2954726130.994727, tmp)); - assertEquals(0, x <<= (x>>x)); - assertEquals(0, x >>>= ((x+(912111201.488966))-(tmp = 1405800042.6070075, tmp))); - assertEquals(-1663642733, x |= (((-1663642733.5700119)<<(x^x))<<x)); - assertEquals(-914358272, x <<= ((((-308411676)-(-618261840.9113789))%(-68488626.58621716))-x)); - assertEquals(-1996488704, x &= (-1358622641.5848842)); - assertEquals(-345978263, x += (1650510441)); - assertEquals(3, x >>>= (-1106714178.701668)); - assertEquals(1, x %= (((x>>(x>>(tmp = -3052773846.817114, tmp)))*(tmp = 1659218887.379526, tmp))&x)); - assertEquals(-943225672, x += (-943225673)); - assertEquals(-0.41714300120060854, x /= (tmp = 2261156652, tmp)); - assertEquals(0, x >>>= ((3107060934.8863482)<<(tmp = 1902730887, tmp))); - assertEquals(0, x &= x); - assertEquals(1476628, x |= ((tmp = -2782899841.390033, tmp)>>>(2097653770))); - assertEquals(0.0008887648921591833, x /= ((tmp = 1661438264.5253348, tmp)%((tmp = 2555939813, tmp)*(-877024323.6515315)))); - assertEquals(0, x <<= (tmp = -2366551345, tmp)); - assertEquals(0, x &= (tmp = 1742843591, tmp)); - assertEquals(0, x -= x); - assertEquals(4239, x += ((-3183564176.232031)>>>(349622674.1255014))); - assertEquals(-67560, x -= ((2352742295)>>>x)); - assertEquals(-67560, x &= x); - assertEquals(-0.00003219917807302283, x /= (2098190203.699741)); - assertEquals(0, x -= x); - assertEquals(0, x >>= ((((tmp = -869086522.8358297, tmp)/(187820779))-(tmp = -2000970995.1931965, tmp))|(1853528755.6064696))); - assertEquals(0, x >>= (-3040509919)); - assertEquals(0, x %= (((tmp = -2386688049.194946, tmp)<<(tmp = -669711391, tmp))|x)); - assertEquals(0, x %= (tmp = -298431511.4839926, tmp)); - assertEquals(0, x /= (2830845091.2793818)); - assertEquals(0, x /= ((((-2529926178)|x)^((tmp = 2139313707.0894063, tmp)%((-1825768525.0541775)-(-952600362.7758243))))+x)); - assertEquals(NaN, x /= x); - assertEquals(NaN, x -= x); - assertEquals(NaN, x /= (tmp = -432944480, tmp)); - assertEquals(0, x <<= (((((x^((-1777523727)+(2194962794)))>>>(((((-590335134.8224905)%(x*(2198198974)))|(tmp = -2068556796, tmp))/(1060765637))*(-147051676)))/((tmp = -477350113.92686677, tmp)<<((x/(2018712621.0397925))^((tmp = 491163813.3921983, tmp)+(((x|((((x%(1990073256.812654))%((-2024388518.9599915)>>((tmp = 223182187, tmp)*(-722241065))))>>>(tmp = 2517147885.305745, tmp))%(1189996239.11222)))&x)%(-306932860))))))&((tmp = 1117802724.485684, tmp)+((-1391614045)-x)))%((((x>>((2958453447)*x))^(((410825859)|(((tmp = -1119269292.5495896, tmp)>>>(((((((x%(tmp = 648541746.6059314, tmp))*((-2304508480)<<((((x^(1408199888.1454597))|((251623937)|x))/((-382389946.9984102)|(tmp = -2082681143.5893767, tmp)))-(((tmp = 631243472, tmp)>>>(1407556544))/(((x>>>x)>>>(tmp = -6329025.47865057, tmp))>>>(tmp = 948664752.543093, tmp))))))/((((-183248880)>>x)&x)&x))>>x)&(((-978737284.8492057)%(tmp = 2983300011.737006, tmp))&(tmp = 2641937234.2954116, tmp)))<<x)>>(2795416632.9722223)))%((((tmp = -50926632, tmp)/x)&(((tmp = -2510786916, tmp)/x)/(-699755674)))|((((tmp = 1411792593, tmp)>>(924286570.2637128))>>((1609997725)>>(2735658951.0762663)))*(tmp = 726205435, tmp)))))<<(tmp = -2135055357.3156831, tmp)))/(tmp = 1408695065, tmp))^(tmp = -1343267739.8562133, tmp)))); - assertEquals(0, x %= (-437232116)); - assertEquals(-2463314518.2747326, x -= (2463314518.2747326)); - assertEquals(109, x >>= (2401429560)); - assertEquals(-2687641732.0253763, x += (-2687641841.0253763)); - assertEquals(-2336375490019484000, x *= (tmp = 869303174.6678596, tmp)); - assertEquals(5.458650430363785e+36, x *= x); - assertEquals(0, x |= ((((-1676972008.797291)*x)*((tmp = 2606991807, tmp)-x))<<x)); - assertEquals(0, x &= ((-3053393759.3496876)+(-1431008367))); - assertEquals(-856728369, x |= (x-(((((764337872)/x)<<((x|(((tmp = 1409368192.1268077, tmp)+(tmp = -848083676, tmp))|(-2797102463.7915916)))^x))/x)^(tmp = 856728369.0589117, tmp)))); - assertEquals(-0, x %= x); - assertEquals(1116550103, x ^= (-3178417193)); - assertEquals(1116550103, x %= (tmp = -1482481942, tmp)); - assertEquals(133, x >>>= x); - assertEquals(-1.381429241671034e-7, x /= ((tmp = -962771116.8101778, tmp)^x)); - assertEquals(-1092268961, x |= ((tmp = 3202672531, tmp)-((x-(tmp = 845529357, tmp))>>(tmp = -868680593, tmp)))); - assertEquals(-1092268961, x %= (tmp = 2670840415.304719, tmp)); - assertEquals(-122794480, x %= (tmp = 969474481, tmp)); - assertEquals(-297606521542193600, x *= (2423614820)); - assertEquals(72460064, x >>>= (tmp = -1230798655, tmp)); - assertEquals(-203714325373689600, x *= (-2811401400)); - assertEquals(2154914048, x >>>= (((2241377026.001436)/x)+x)); - assertEquals(1177864081, x ^= (tmp = -968513903, tmp)); - assertEquals(35947664, x &= (-2086226758.2704995)); - assertEquals(20795732539020670, x += (x*(578500247))); - assertEquals(-892004992, x >>= x); - assertEquals(-7023661.354330708, x /= ((((((1740714214)%((tmp = -459699286, tmp)+(tmp = -1700187400, tmp)))>>(tmp = -3170295237, tmp))+(tmp = -497509780, tmp))+((1971976144.6197853)+(661992813.6077721)))>>>(-1683802728))); - assertEquals(-1634205696, x <<= x); - assertEquals(-7, x >>= (-3187653764.930914)); - assertEquals(-5.095345981491203, x -= ((tmp = 748315289, tmp)/(tmp = -392887780, tmp))); - assertEquals(1486531570, x &= (1486531570.9300508)); - assertEquals(5670, x >>= (((tmp = -2486758205.26425, tmp)*(732510414))|x)); - assertEquals(5670, x >>= (((-1811879946.2553763)%(1797475764))/(((tmp = -2159923884, tmp)|x)+(tmp = -1774410807, tmp)))); - assertEquals(38, x %= (x>>>x)); - assertEquals(-151134215, x ^= (((tmp = -2593085609.5622163, tmp)+((tmp = -814992345.7516887, tmp)-(534809571)))|(tmp = -232678571, tmp))); - assertEquals(-234881024, x <<= x); - assertEquals(-234881024, x <<= (x>>>x)); - assertEquals(55169095435288580, x *= x); - assertEquals(0, x >>= (tmp = 1176612256, tmp)); - assertEquals(0, x <<= (1321866341.2486475)); - assertEquals(0, x %= (x-(-602577995))); - assertEquals(0, x >>>= (((((tmp = -125628635.79970193, tmp)^(tmp = 1294209955.229382, tmp))&(((tmp = -2353256654.0725203, tmp)|((-1136743028.9425385)|((((950703429.1110399)-(x>>>x))/((((x%(-252705869.21126103))/((tmp = 886957620, tmp)<<(x%((tmp = -1952249741, tmp)*(tmp = -1998149844, tmp)))))|(tmp = 1933366713, tmp))|((tmp = -2957141565, tmp)>>>(tmp = 1408598804, tmp))))+(((((((-2455002047.4910946)%(tmp = -528017836, tmp))&((-2693432769)/(tmp = 2484427670.9045153, tmp)))%(-356969659))-((((((tmp = 3104828644.0753174, tmp)%(x>>>(tmp = 820832137.8175925, tmp)))*((tmp = 763080553.9260503, tmp)+(3173597855)))<<(((-510785437)^x)<<(x|(((x*(x%((tmp = -1391951515, tmp)/x)))-x)|(x-((-522681793.93221474)/((2514619703.2162743)*(2936688324))))))))|x)>>>(-2093210042)))&(763129279.3651779))&x))))-x))%(((-1331164821)&(tmp = 1342684586, tmp))<<(x<<(tmp = 2675008614.588005, tmp))))>>((2625292569.8984914)+(-3185992401)))); - assertEquals(0, x *= (tmp = 671817215.1147974, tmp)); - assertEquals(-1608821121, x ^= ((tmp = 2686146175.04077, tmp)>>>x)); - assertEquals(-0, x %= x); - assertEquals(-0, x /= ((tmp = 286794551.0720866, tmp)|(x%x))); - assertEquals(0, x <<= (x|(tmp = 1095503996.2285218, tmp))); - assertEquals(443296752, x ^= (443296752)); - assertEquals(110824188, x >>= ((184708570)>>(x&x))); - assertEquals(0.7908194935161674, x /= ((((167151154.63381648)&((tmp = -1434120690, tmp)-(tmp = 2346173080, tmp)))/(56656051.87305987))^(140138414))); - assertEquals(-0.9027245492678485, x *= ((tmp = 1724366578, tmp)/(((2979477411)<<(((897038568)>>(tmp = 348960298, tmp))%(281056223.2037884)))^((((-1383133388)-(((-1379748375)-((x>>(x&(tmp = 2456582046, tmp)))>>>(-2923911755.565961)))&x))<<(-2825791731))^(tmp = -1979992970, tmp))))); - assertEquals(0, x &= (2482304279)); - assertEquals(-0, x *= (-2284213673)); - assertEquals(0, x <<= ((2874381218.015819)|x)); - assertEquals(0, x *= (x>>>(tmp = 2172786480, tmp))); - assertEquals(0, x &= (-1638727867.2978938)); - assertEquals(0, x %= ((tmp = -2213947368.285817, tmp)>>x)); - assertEquals(0, x >>>= (tmp = -531324706, tmp)); - assertEquals(0, x %= (tmp = -2338792486, tmp)); - assertEquals(0, x <<= (((tmp = 351012164, tmp)<<(x|((tmp = -3023836638.5337825, tmp)^(-2678806692))))|x)); - assertEquals(0, x %= (x-(tmp = -3220231305.45039, tmp))); - assertEquals(0, x <<= (-2132833261)); - assertEquals(0, x >>>= x); - assertEquals(0, x %= ((2544970469)+(((-2633093458.5911965)&(644108176))-(x>>>(tmp = -949043718, tmp))))); - assertEquals(-2750531265, x += (-2750531265)); - assertEquals(0, x >>= x); - assertEquals(0, x *= ((tmp = 1299005700, tmp)-x)); - assertEquals(0, x >>= x); - assertEquals(-1785515304, x -= (((((-806054462.5563161)/x)>>>x)+(1785515304))|((tmp = 2937069788.9396844, tmp)/x))); - assertEquals(-3810117159.173689, x -= (2024601855.1736891)); - assertEquals(-6.276064139320051, x /= (607087033.3053156)); - assertEquals(134217727, x >>>= (((x%(tmp = 924293127, tmp))^x)|((x>>>(x&((((tmp = -413386639, tmp)/(x>>(tmp = 599075308.8479941, tmp)))^(tmp = -1076703198, tmp))*((tmp = -2239117284, tmp)>>(655036983)))))-x))); - assertEquals(134217727, x %= (tmp = 2452642261.038778, tmp)); - assertEquals(-569504740360507, x *= ((tmp = -1086243941, tmp)>>(tmp = 1850668904.4885683, tmp))); - assertEquals(113378806, x >>>= (tmp = -2558233435, tmp)); - assertEquals(979264375, x -= (((x>>(1950008052))%((2917183569.0209)*(tmp = 1184250640.446752, tmp)))|((((tmp = -691875212, tmp)-(-2872881803))>>(tmp = 44162204.97461021, tmp))^(tmp = 865885647, tmp)))); - assertEquals(-1127813632, x <<= ((((tmp = -2210499281, tmp)>>>x)-(tmp = 2359697240, tmp))-x)); - assertEquals(-1707799657, x ^= (653518231.3995534)); - assertEquals(2916579668449318000, x *= x); - assertEquals(2916579669254640600, x += (x&(tmp = 2986558026.399422, tmp))); - assertEquals(870995175, x ^= (2598813927.8991632)); - assertEquals(870995175, x %= (-2857038782)); - assertEquals(1869503575895591000, x *= (x|(x|(((tmp = 2478650307.4118147, tmp)*((tmp = 2576240847.476932, tmp)>>>x))<<x)))); - assertEquals(-134947790, x |= ((tmp = 1150911808, tmp)*((2847735464)/(-2603172652.929262)))); - assertEquals(-137053182, x -= ((tmp = 2155921819.0929346, tmp)>>>(x-(((-1960937402)-(-1907735074.2875962))%((1827808310)^(tmp = -2788307127, tmp)))))); - assertEquals(-134824702, x |= (((2912578752.2395406)^(x%(((-2585660111.0638976)<<(((((tmp = 747742706, tmp)%(-1630261205))&((((x|(x|(-2619903144.278758)))|((2785710568.8651934)>>((-968301967.5982246)<<(x&x))))>>((x>>>((x>>>(tmp = -1402085797.0310762, tmp))*((tmp = -323729645.2250068, tmp)<<(tmp = 2234667799, tmp))))>>>(-167003745)))>>((924665972.4681011)<<x)))>>>x)<<((((x+x)+x)-(((tmp = 2399203431.0526247, tmp)-(-2872533271))-(((tmp = 914778794.2087344, tmp)-(tmp = 806353942.9502392, tmp))|(((tmp = 262924334.99231672, tmp)&x)|(tmp = -460248836.5602243, tmp)))))/x)))%((-1681000689)/(tmp = -2805054623.654228, tmp)))))*(tmp = 957346233.9619625, tmp))); - assertEquals(-3274838, x %= ((((tmp = 3155450543.3524327, tmp)>>>x)<<(tmp = 2103079652.3410985, tmp))>>x)); - assertEquals(-3274838, x |= ((((tmp = 2148004645.639173, tmp)>>>(tmp = -1285119223, tmp))<<(((((-711596054)>>>(tmp = -2779776371.3473206, tmp))^(((((tmp = -1338880329.383915, tmp)<<((-1245247254.477341)>>x))*(tmp = -2649052844.20065, tmp))>>((1734345880.4600453)%(x/(2723093117.118899))))*(1252918475.3285656)))<<(2911356885))^x))<<(-1019761103))); - assertEquals(1703281954, x &= (((tmp = 1036570471.7412028, tmp)+((tmp = 3043119517, tmp)%(2374310816.8346715)))%(tmp = -2979155076, tmp))); - assertEquals(1741588391, x |= ((tmp = 1230009575.6003838, tmp)>>>(-1247515003.8152597))); - assertEquals(72869474.64782429, x %= (tmp = 1668718916.3521757, tmp)); - assertEquals(770936242.104203, x += (698066767.4563787)); - assertEquals(-0.2820604726420833, x /= (tmp = -2733230342, tmp)); - assertEquals(403480578, x |= ((969730374)&(tmp = 1577889835, tmp))); - assertEquals(-1669557233, x ^= ((-1616812135)+(tmp = -456209292, tmp))); - assertEquals(-1630427, x >>= ((2327783031.1175823)/(226947662.4579488))); - assertEquals(131022, x >>>= ((tmp = -1325018897.2482083, tmp)>>(x&((((((-1588579772.9240348)<<(tmp = -1775580288.356329, tmp))<<(tmp = -1021528325.2075481, tmp))>>((tmp = 2373033451.079956, tmp)*(tmp = 810304612, tmp)))-((tmp = -639152097, tmp)<<(tmp = 513879484, tmp)))&(2593958513))))); - assertEquals(1, x >>= ((3033200222)-x)); - assertEquals(-561146816.4851823, x += (tmp = -561146817.4851823, tmp)); - assertEquals(-4.347990105831158, x /= ((((-1270435902)*x)%((tmp = 637328492.7386824, tmp)-(x>>(-749100689))))%(x+x))); - assertEquals(-1, x >>= x); - assertEquals(1, x *= x); - assertEquals(111316849706694460, x += ((966274056)*(x|(115202150)))); - assertEquals(-1001883840, x >>= x); - assertEquals(-1001883840, x &= x); - assertEquals(-3006880758, x += ((((-2275110637.4054556)/((x+(tmp = -1390035090.4324536, tmp))>>(-5910593)))&(tmp = 378982420, tmp))|(tmp = 2289970378.568629, tmp))); - assertEquals(314474, x >>>= (x>>((tmp = -228007336.31281257, tmp)%(tmp = 1127648013, tmp)))); - assertEquals(-17694827, x ^= ((tmp = 2095133598.1849852, tmp)|(-1978322311))); - assertEquals(1, x /= x); - assertEquals(1, x %= (-2323617209.7531185)); - assertEquals(0, x >>>= (x*(tmp = -1574455400.489434, tmp))); - assertEquals(0, x >>= (3131854684)); - assertEquals(2853609824, x += ((-231012098)-(tmp = -3084621922, tmp))); - assertEquals(8143089027629311000, x *= x); - assertEquals(313052685, x ^= (tmp = 2962303501, tmp)); - assertEquals(4776, x >>= (tmp = 2271457232, tmp)); - assertEquals(0.000002812258572702285, x /= (tmp = 1698279115, tmp)); - assertEquals(0, x >>>= (tmp = 1698465782.0927145, tmp)); - assertEquals(0, x <<= x); - assertEquals(0, x |= ((x<<((-1824760240.3040407)<<(2798263764.39145)))&(tmp = 1795988253.0493627, tmp))); - assertEquals(1782206945, x ^= (-2512760351.7881565)); - assertEquals(7610569113843172000, x *= (((tmp = -44415823.92972565, tmp)&(tmp = 1402483498.9421625, tmp))+(tmp = 2909778666, tmp))); - assertEquals(15221138227873292000, x += (x-(tmp = -186948658.394145, tmp))); - assertEquals(0, x -= x); - assertEquals(-2238823252, x -= ((tmp = 2238823252, tmp)+x)); - assertEquals(0, x -= x); - assertEquals(0, x >>= (2976069570)); - assertEquals(0, x >>= ((tmp = -2358157433, tmp)/x)); - assertEquals(-949967713, x ^= (tmp = -949967713, tmp)); - assertEquals(-1, x >>= x); - assertEquals(-1522291702.1977966, x *= (1522291702.1977966)); - assertEquals(-1522291702, x >>= ((((2290279800)|x)|(1793154434.6798015))&((-1161390929.0766077)>>>x))); - assertEquals(83894274, x &= (tmp = 1571058486, tmp)); - assertEquals(43186847.90522933, x += ((tmp = -1131332988.0947707, tmp)%x)); - assertEquals(0, x >>= (tmp = -1968312707.269359, tmp)); - assertEquals(0, x &= (2507747643.26175)); - assertEquals(0, x %= (tmp = 3190525303.366887, tmp)); - assertEquals(-1968984602, x ^= (((x/(x|(-1607062026.5338054)))<<(tmp = 2207669861.8770065, tmp))+(tmp = 2325982694.956348, tmp))); - assertEquals(554, x >>>= (((tmp = -2302283871.993821, tmp)>>>(-3151835112))|(((((x%(-1534374264))/((731246012)<<(((883830997.1194847)<<(((-1337895080.1937215)/(tmp = 3166402571.8157315, tmp))^(tmp = -1563897595.5799441, tmp)))>>(tmp = -556816951.0537591, tmp))))>>(-2682203577))<<(x/((1654294674.865079)+x)))/((x^(-2189474695.4259806))/(-475915245.7363057))))); - assertEquals(1372586111, x ^= (1372586581)); - assertEquals(1166831229, x -= ((-834168138)&(762573579))); - assertEquals(2333662456, x -= ((x>>x)-x)); - assertEquals(-1961304840, x &= x); - assertEquals(-2130143128, x &= (2982852718.0711775)); - assertEquals(1073741824, x <<= (-1446978661.6426942)); - assertEquals(2097152, x >>>= ((-1424728215)-(((127872198)%(tmp = -2596923298, tmp))&x))); - assertEquals(2097152, x >>>= x); - assertEquals(0, x &= (x/(tmp = -518419194.42994523, tmp))); - assertEquals(0, x >>= ((x/(-1865078245))%(tmp = 2959239210, tmp))); - assertEquals(-0, x *= ((x|(-1721307400))|(-3206147171.9491577))); - assertEquals(0, x >>>= ((-694741143)&(tmp = -2196513947.699142, tmp))); - assertEquals(0, x <<= x); - assertEquals(0, x &= ((tmp = 2037824385.8836646, tmp)+((tmp = 1203034986.4647732, tmp)/(x>>>(((-1374881234)/(899771270.3237157))+((-2296524362.8020077)|(-1529870870))))))); - assertEquals(0, x >>= (tmp = 2770637816, tmp)); - assertEquals(0, x ^= x); - assertEquals(-1861843456, x |= ((632402668)*((x|(tmp = -1032952662.8269436, tmp))|(tmp = 2671272511, tmp)))); - assertEquals(-1861843456, x >>= (((x>>>x)+x)<<(-1600908842))); - assertEquals(-58182608, x >>= (x-(tmp = -2496617861, tmp))); - assertEquals(-3636413, x >>= (tmp = -400700028, tmp)); - assertEquals(-7272826, x += x); - assertEquals(-1, x >>= ((tmp = -3184897005.3614545, tmp)-((-1799843014)|(tmp = 2832132915, tmp)))); - assertEquals(-121800925.94209385, x *= (121800925.94209385)); - assertEquals(-30450232, x >>= (-979274206.6261561)); - assertEquals(-30450232, x >>= (tmp = -1028204832.5078967, tmp)); - assertEquals(-30450232, x |= x); - assertEquals(965888871, x ^= (((((-2157753481.3375635)*((tmp = -1810667184.8165767, tmp)&((tmp = 2503908344.422232, tmp)|x)))>>(x>>(1601560785)))<<x)^(tmp = 943867311.6380403, tmp))); - assertEquals(7546006, x >>>= x); - assertEquals(7546006, x <<= ((tmp = 1388931761.780241, tmp)*(x-(tmp = -1245147647.0070577, tmp)))); - assertEquals(12985628, x += (x&(-1520746354))); - assertEquals(12985628, x &= x); - assertEquals(12985628, x %= (tmp = 308641965, tmp)); - assertEquals(685733278, x |= ((tmp = -1275653544, tmp)-((tmp = -1956798010.3773859, tmp)%(tmp = 2086889575.643448, tmp)))); - assertEquals(679679376, x &= (2860752368)); - assertEquals(1770773904, x |= (x<<(3200659207))); - assertEquals(1224886544, x &= (-585733767.6876519)); - assertEquals(1224886544, x %= ((tmp = -114218494, tmp)-x)); - assertEquals(1208109328, x &= (tmp = 1854361593, tmp)); - assertEquals(18434, x >>>= x); - assertEquals(-349394636955256100, x *= (x*(-1028198742))); - assertEquals(-519536600.7713163, x %= (-1054085356.9120367)); - assertEquals(-1610612736, x ^= ((tmp = -3126078854, tmp)&x)); - assertEquals(-2637321565906333700, x *= (1637464740.5658746)); - assertEquals(-2637321568051070500, x -= ((tmp = -1006718806, tmp)<<(3005848133.106345))); - assertEquals(368168695, x ^= (x^(tmp = 368168695.6881037, tmp))); - assertEquals(43, x >>>= x); - assertEquals(-2081297089, x |= ((167169305.77248895)+(-2248466405.3199244))); - assertEquals(-2474622167, x -= (tmp = 393325078, tmp)); - assertEquals(-135109701, x %= (-1169756233)); - assertEquals(0, x ^= x); - assertEquals(0, x >>= (((((tmp = -164768854, tmp)/(tmp = -1774989993.1909926, tmp))+x)-((-921438912)>>(tmp = -191772028.69249105, tmp)))-(tmp = 558728578.22033, tmp))); - assertEquals(0, x %= (tmp = 2188003745, tmp)); - assertEquals(0, x <<= (((tmp = -999335540, tmp)>>((((325101977)/(tmp = -3036991542, tmp))<<(tmp = -213302488, tmp))+x))|(tmp = -1054204587, tmp))); - assertEquals(0, x &= ((2844053429.4720345)>>>x)); - assertEquals(NaN, x %= x); - assertEquals(NaN, x -= (-1481729275.9118822)); - assertEquals(NaN, x *= (tmp = 1098314618.2397528, tmp)); - assertEquals(-1073741824, x ^= ((tmp = 1718545772, tmp)<<(((tmp = -81058910, tmp)-(2831123087.424368))+(tmp = 576710057.2361784, tmp)))); - assertEquals(-2921155898.4793186, x -= (1847414074.4793184)); - assertEquals(-1295646720, x <<= (2178621744)); - assertEquals(-0.8906779709597907, x /= ((tmp = -2840292585.6837263, tmp)<<(x&((tmp = 892527695.6172305, tmp)>>>x)))); - assertEquals(0, x <<= (((tmp = 3149667213.298993, tmp)>>(tmp = 1679370761.7226725, tmp))^(115417747.21537328))); - assertEquals(0, x |= x); - assertEquals(0, x %= ((-1112849427)>>(-1245508870.7514496))); - assertEquals(0, x &= x); - assertEquals(0, x |= x); - assertEquals(0, x >>>= ((3144100694.930459)>>>(tmp = 2408610503, tmp))); - assertEquals(0, x <<= ((tmp = 2671709754.0318713, tmp)%x)); - assertEquals(0, x >>>= (x|((tmp = -3048578701, tmp)-(674147224)))); - assertEquals(NaN, x %= x); - assertEquals(0, x &= ((tmp = -2084883715, tmp)|(((((-3008427069)+(875536047.4283574))>>>x)%(tmp = -450003426.1091652, tmp))%(((-2956878433.269356)|(x/((((x%((((((x<<(((tmp = -1581063482.510351, tmp)^x)-(tmp = 1364458217, tmp)))^((tmp = 1661446342, tmp)+(1307091014)))/(342270750.9901335))>>>(x&((1760980812.898993)&((tmp = 2878165745.6401143, tmp)/(((tmp = -981178013, tmp)/(-2338761668.29912))>>(-958462630))))))*((1807522840)^((tmp = 1885835034, tmp)^(-2538647938))))*(1673607540.0854697)))%x)>>x)<<x)))<<(853348877.2407281))))); - assertEquals(0, x >>>= x); - assertEquals(-1162790279, x -= (1162790279)); - assertEquals(-1162790279, x >>= (((-490178658)*x)/((((((tmp = -1883861998.6699312, tmp)/(tmp = -2369967345.240594, tmp))+(3142759868.266447))&(508784917.8158537))&x)>>(-2129532322)))); - assertEquals(-1360849740.9829152, x -= (x+(1360849740.9829152))); - assertEquals(1928392181, x ^= (-602670783)); - assertEquals(19478708.898989897, x /= (((-2617861994)>>(tmp = 797256920, tmp))%(-1784987906))); - assertEquals(-8648903.575540157, x *= (((tmp = 673979276, tmp)/(-1517908716))%(x/x))); - assertEquals(-8648903.575540157, x %= ((((643195610.4221292)>>>(tmp = 2342669302, tmp))>>>(tmp = -1682965878, tmp))^((tmp = -208158937.63443017, tmp)>>((907286989)&(x<<(448634893)))))); - assertEquals(1399288769, x ^= (tmp = -1407486728, tmp)); - assertEquals(0, x &= (((1999255838.815517)/(tmp = 564646001, tmp))/(-3075888101.3274765))); - assertEquals(0, x ^= ((-78451711.59404826)%x)); - assertEquals(-1351557131, x |= (2943410165)); - assertEquals(1715626371, x -= (-3067183502)); - assertEquals(71434240, x &= ((-1800066426)<<(((((x<<(-324796375))+x)<<(tmp = 2696824955.735132, tmp))^x)%(tmp = 444916469, tmp)))); - assertEquals(71434240, x >>>= (((x&((x%x)|x))+(tmp = 2226992348.3050146, tmp))<<(-305526260))); - assertEquals(0, x -= (x%(tmp = 582790928.5832802, tmp))); - assertEquals(0, x *= ((x%(1865155340))>>>((x<<(2600488191))^(-308995123)))); - assertEquals(0, x >>= (x&(-3120043868.8531103))); - assertEquals(0, x |= x); - assertEquals(-0, x *= (tmp = -172569944, tmp)); - assertEquals(0, x <<= (-1664372874)); - assertEquals(1377713344.6784928, x += (tmp = 1377713344.6784928, tmp)); - assertEquals(1377713344, x |= x); - assertEquals(-232833282, x |= (tmp = 2685870654, tmp)); - assertEquals(84639, x -= (((((2778531079.998492)%(2029165314))>>>(tmp = -468881172.3729558, tmp))^x)|((x>>>((((x%(3044318992.943596))&(1996754328.2214756))^(1985227172.7485228))%(tmp = -1984848676.1347625, tmp)))|((tmp = 2637662639, tmp)<<x)))); - assertEquals(0, x ^= x); - assertEquals(1237720303, x -= (-1237720303)); - assertEquals(2, x >>= (-2148785379.428976)); - assertEquals(2, x &= (tmp = -3087007874, tmp)); - assertEquals(0, x %= x); - assertEquals(0, x >>>= x); - assertEquals(0, x >>>= x); - assertEquals(0, x += x); - assertEquals(0, x &= (2055693082)); - assertEquals(-1349456492, x += (x^(-1349456492.315998))); - assertEquals(671088640, x <<= (x>>(-2030805724.5472062))); - assertEquals(-417654580004782100, x *= (tmp = -622353822, tmp)); - assertEquals(1538160360, x |= (195983080.56698656)); - assertEquals(733, x >>>= (tmp = 661085269, tmp)); - assertEquals(657, x &= (-1611460943.993404)); - assertEquals(431649, x *= x); - assertEquals(863298, x += x); - assertEquals(0, x &= ((1899423003)/((472439729)>>((tmp = 2903738952, tmp)+(tmp = 2164601630.3456993, tmp))))); - assertEquals(0, x &= (x>>>(tmp = 1939167951.2828958, tmp))); - assertEquals(1557813284, x |= (x-(-1557813284))); - assertEquals(72876068, x &= (662438974.2372154)); - assertEquals(0.6695448637501589, x /= (tmp = 108844189.45702457, tmp)); - assertEquals(0, x -= x); - assertEquals(2944889412, x += (2944889412)); - assertEquals(3787980288, x -= ((((tmp = -2003814373.2301111, tmp)<<x)>>>(tmp = -3088357284.4405823, tmp))-(843090884))); - assertEquals(1, x >>>= (729274079)); - assertEquals(1, x %= (-148002187.33869123)); - assertEquals(3073988415.673201, x *= (tmp = 3073988415.673201, tmp)); - assertEquals(4839166225.673201, x += (tmp = 1765177810, tmp)); - assertEquals(4529373898.673201, x += (-309792327)); - assertEquals(3097903.090496063, x %= (-150875866.51942348)); - assertEquals(1270874112, x <<= ((((((tmp = -960966763.1418135, tmp)>>((((-3208596981.613482)>>>(tmp = 746403937.6913509, tmp))>>>(-2190042854.066803))/(2449323432)))*(-1272232665.791577))<<(-99306767.7209444))^((-1942103828)/((1570981655)/(tmp = 2381666337, tmp))))+(tmp = -1946759395.1558368, tmp))); - assertEquals(1273845956, x |= (tmp = -3197282108.6120167, tmp)); - assertEquals(159230744, x >>= (((tmp = -1036031403.8108604, tmp)>>>(((3084964493)>>((x*x)^x))+(((2980108409.352001)^x)-(tmp = -2501685423.513927, tmp))))&(326263839))); - assertEquals(-370091747145550100, x *= (tmp = -2324248055.674161, tmp)); - assertEquals(143384219.54999557, x /= (tmp = -2581119096, tmp)); - assertEquals(1843396287, x |= (tmp = 1842718767, tmp)); - assertEquals(2.4895593465813803, x /= (740450831)); - assertEquals(2.4895593465813803, x %= ((((((((-3175333618)>>>((tmp = -1403880166, tmp)<<(tmp = -134875360, tmp)))>>>(2721317334.998084))<<(x&(tmp = 2924634208.1484184, tmp)))*((((x>>(tmp = -200319931.15328693, tmp))-(tmp = -495128933, tmp))+((-788052518.6610589)*((((tmp = 107902557, tmp)&(1221562660))%(x<<(((3155498059)*(((tmp = -1354381139.4897022, tmp)^(tmp = 3084557138.332852, tmp))*((((tmp = 1855251464.8464525, tmp)/((-1857403525.2008865)>>x))|x)-(-2061968455.0023944))))*(1917481864.84619))))^(x-(-508176709.52712965)))))+((((x%(-1942063404))+(x%(tmp = 855152281.180481, tmp)))|(-522863804))>>x)))>>>((tmp = -2515550553, tmp)&(((((-801095375)-(tmp = -2298729336.9792976, tmp))^x)/(tmp = 2370468053, tmp))>>(x|(tmp = -900008879, tmp)))))>>>(((tmp = -810295719.9509168, tmp)*((tmp = -1306212963.6226444, tmp)/(((tmp = 3175881540.9514832, tmp)|(-1439142297.819246))+((tmp = -134415617, tmp)|((-245801870)+x)))))>>(tmp = 1889815478, tmp)))-(((tmp = 597031177, tmp)%(858071823.7655672))+((tmp = 2320838665.8243756, tmp)|((938555608)<<(2351739219.6461897)))))); - assertEquals(6.197905740150709, x *= x); - assertEquals(1, x /= x); - assertEquals(0, x >>= (-1639664165.9076233)); - assertEquals(0, x >>= (-3135317748.801177)); - assertEquals(0, x &= (3185479232.5325994)); - assertEquals(-0, x *= ((-119759439.19668174)/(tmp = 2123964608, tmp))); - assertEquals(0, x /= (-1183061929.2827876)); - assertEquals(0, x <<= (-1981831198)); - assertEquals(0, x >>= ((((x<<(((((((-2133752838)&((tmp = -3045157736.9331336, tmp)>>>(x%x)))>>x)%(tmp = 3082217039, tmp))&(tmp = 270770770.97558427, tmp))|((-2212037556)^((((((2089224421)|(tmp = 360979560, tmp))<<x)%((tmp = -1679487690.6940534, tmp)+((173021423)|((tmp = 560900612, tmp)+((244376267.58977115)^x)))))<<(tmp = 2534513699, tmp))^x)))>>>(2915907189.4873834)))+(x*x))%(1637581117))%(tmp = 2363861105.3786244, tmp))); - assertEquals(0, x &= ((-2765495757.873004)&(1727406493))); - assertEquals(NaN, x -= (((((-1419667515.2616255)|x)-(150530256.48022234))%((((x|x)<<x)>>>(x^x))+x))-((-1216384577.3749187)*(495244398)))); - assertEquals(NaN, x += (x^((tmp = 2472035493, tmp)+x))); - assertEquals(NaN, x %= ((tmp = -1753037412.885754, tmp)|((tmp = 2507058310, tmp)<<(1475945705)))); - assertEquals(-1008981005, x |= ((tmp = -1140889842.6099494, tmp)-(tmp = -131908837, tmp))); - assertEquals(999230327.5872104, x -= (tmp = -2008211332.5872104, tmp)); - assertEquals(975810, x >>= (((-1211913874)*x)>>>((-2842129009)>>(x&(tmp = -1410865834, tmp))))); - assertEquals(7623, x >>= ((tmp = -1051327071, tmp)-(((tmp = -237716102.8005445, tmp)|((2938903833.416546)&x))|(((-1831064579)^x)/((tmp = 2999232092, tmp)-(981996301.2875179)))))); - assertEquals(0, x -= x); - assertEquals(0, x %= (x|(tmp = -666201160.5810485, tmp))); - assertEquals(-1347124100, x |= (-1347124100)); - assertEquals(-0, x %= (x&x)); - assertEquals(-661607963, x ^= (tmp = -661607963.3794863, tmp)); - assertEquals(3465, x >>>= (-828119020.8056595)); - assertEquals(-268431991, x -= (((tmp = -1386256352, tmp)^((tmp = 743629575, tmp)%((x*((tmp = -1719517658, tmp)>>(2019516558)))<<((2637317661)|x))))<<(tmp = -51637065, tmp))); - assertEquals(1578876380, x += ((tmp = 1847308371, tmp)&(((((((tmp = 1487934776.1893163, tmp)%(tmp = 1423264469.3137975, tmp))|(((2653260792.5668964)/(-2417905016.043802))>>>(2097411118.4501896)))^x)^(((tmp = -71334226, tmp)|x)>>>(tmp = -2771758874.7696714, tmp)))^((tmp = -1464849031.3240793, tmp)%(tmp = 2349739690.6430283, tmp)))/x))); - assertEquals(3269293934, x += (1690417554)); - assertEquals(4025392608.031957, x -= (((tmp = 268501120.7225704, tmp)<<(tmp = 2841620654.8903794, tmp))+((tmp = 1606704462.8455591, tmp)/((-2601879963)/(tmp = 2966620168.989736, tmp))))); - assertEquals(7, x >>>= (x^(-1913800035))); - assertEquals(1.4326776816275493e-8, x /= ((((tmp = -2703417892, tmp)/x)^((-2693772270.396241)>>>((x-(tmp = 615999818.5666655, tmp))>>((((2308121439.3702726)<<((-1794701502)>>(x+(tmp = -2253406035.972883, tmp))))<<((tmp = -197103799.0624652, tmp)|(629975898)))>>>x))))>>>((tmp = 2833656803, tmp)^(x^(tmp = -1580436025, tmp))))); - assertEquals(0, x >>>= (tmp = 1525372830.2126007, tmp)); - assertEquals(0, x %= ((2354010949.24469)>>>(x<<x))); - assertEquals(0, x ^= (((1112335059.6922574)*(tmp = -1874363935, tmp))&(((((2154894295.8360596)<<x)&(tmp = -270736315.13505507, tmp))&x)>>>(-2205692260.552064)))); - assertEquals(0, x >>>= (x<<((1488533932)*(tmp = 1707754286, tmp)))); - assertEquals(0, x >>= (((tmp = 1232547376.463387, tmp)%((x>>(711691823.1608362))>>>x))>>(((895039781.7478573)*(((((-334946524)&x)*(tmp = -1214529640, tmp))^(tmp = -1586820245, tmp))*(1062595445)))+x))); - assertEquals(0, x *= (1863299863.2631998)); - assertEquals(0, x /= (tmp = 1858428705.1330547, tmp)); - assertEquals(0, x &= x); - assertEquals(611788028, x += (x^(611788028.1510412))); - assertEquals(1, x /= x); - assertEquals(0, x >>= ((tmp = -1617320707.1784317, tmp)-((-2139400380)-(-1402777976)))); - assertEquals(0, x >>= (415866827.34665)); - assertEquals(-1990811897, x -= (tmp = 1990811897, tmp)); - assertEquals(-1990811895, x += ((x>>>(tmp = -2175453282.769696, tmp))&(tmp = -1459450498.7327478, tmp))); - assertEquals(-2377017935.149517, x += (-386206040.1495173)); - assertEquals(1946129845, x |= (tmp = -2890956796.936539, tmp)); - assertEquals(0, x %= x); - assertEquals(0, x <<= (1616188263)); - assertEquals(-1081213596, x ^= (tmp = 3213753700, tmp)); - assertEquals(3213753700, x >>>= (tmp = -3211181312, tmp)); - assertEquals(-1081213596, x &= x); - assertEquals(-1081213583, x ^= (((tmp = 1599988273.4926577, tmp)>>((((-1061394954.6331315)^x)+((-1835761078)*x))+(x%(tmp = -696221869, tmp))))/((tmp = -1156966790.3436491, tmp)^x))); - assertEquals(0, x ^= x); - assertEquals(NaN, x /= x); - assertEquals(NaN, x += (-1257400530.9263027)); - assertEquals(NaN, x /= (753062089)); - assertEquals(NaN, x *= ((tmp = 305418865.57012296, tmp)^(((-2797769706)+((((tmp = -33288276.988654375, tmp)%(tmp = 1242979846, tmp))|(-316574800))-((tmp = -1766083579.4203427, tmp)*(((x*(tmp = -2400342309.2349987, tmp))>>(tmp = 2632061795, tmp))^(tmp = -1001440809, tmp)))))^((((x-(tmp = -1469542637.6925495, tmp))-x)-(3184196890))%(((((((633226688)*((tmp = -2692547856, tmp)>>(((tmp = -1244311756, tmp)>>>x)+((1746013631.405202)>>>(941829464.1962085)))))%(x-x))+(995681795))-(tmp = -3047070551.3642616, tmp))/(1968259705))-((-2853237880)^(tmp = -2746628223.4540343, tmp))))))); - assertEquals(0, x >>= x); - assertEquals(0.5713172378854926, x += (((x+(((x+x)/(tmp = 2642822318, tmp))*(-2590095885.4280834)))|(tmp = -1769210836, tmp))/(tmp = -3096722308.8665104, tmp))); - assertEquals(-0.000002311097780334994, x /= ((2269858877.9010344)>>(-2992512915.984787))); - assertEquals(-0.000002311097780334994, x %= (-1139222821)); - assertEquals(-0.000004622195560669988, x += x); - assertEquals(1, x /= x); - assertEquals(1, x >>>= (((3002169429.6061807)/(-3068577366))>>>((tmp = -1844537620, tmp)%((((tmp = 2087505119, tmp)>>>x)+x)&(2179989542))))); - assertEquals(-534213071, x *= (-534213071)); - assertEquals(-534213077.3716287, x -= (((tmp = -2390432951.154034, tmp)^x)/(-290501980))); - assertEquals(1836305, x >>>= (x&x)); - assertEquals(1836305, x %= ((x|((3070123855)^(49986396)))+((-1863644960.4202995)>>>((tmp = 1886126804.6019692, tmp)^x)))); - assertEquals(28692, x >>>= ((2561362139.491764)>>(((((tmp = -1347469854.7413375, tmp)/(((x|(x+x))^((x^(tmp = -2737413775.4595394, tmp))^x))<<(((tmp = 225344844.07128417, tmp)&x)&(tmp = 145794498, tmp))))*x)<<(1424529187))/((-2924344715)/(tmp = -2125770148, tmp))))); - assertEquals(-2089419535.2717648, x += (-2089448227.2717648)); - assertEquals(18957929, x ^= (tmp = 2186590872, tmp)); - assertEquals(-708972800, x -= (727930729)); - assertEquals(-4198593, x |= (799483455.1885371)); - assertEquals(-1, x >>= (-2330654693.6413193)); - assertEquals(-1, x |= (((tmp = -116877155, tmp)>>>((((tmp = -1677422314.1333556, tmp)/(tmp = -3108738499.0798397, tmp))%((x&(x/x))%((tmp = -695607185.1561592, tmp)-(tmp = 2302449181.622259, tmp))))^(((-1482743646.5604773)^((897705064)>>>x))-(tmp = -2933836669, tmp))))%(((tmp = -2991584625, tmp)|(((x>>x)+(-1101066835))-x))>>(-33192973.819939613)))); - assertEquals(-1, x &= x); - assertEquals(-524288, x <<= (-1177513101.3087924)); - assertEquals(1978770334.9189441, x += (tmp = 1979294622.9189441, tmp)); - assertEquals(901783582, x &= ((-368584615)^(((((-478030699.2647903)<<x)<<x)+(tmp = 708725752, tmp))^((tmp = -3081556856, tmp)/(tmp = 1149958711.0676727, tmp))))); - assertEquals(-1480333211.8654308, x += (tmp = -2382116793.865431, tmp)); - assertEquals(956930239.6783283, x *= ((tmp = 956930239.6783283, tmp)/x)); - assertEquals(1277610.4668602513, x /= ((tmp = 1571029828, tmp)>>(tmp = 2417481141, tmp))); - assertEquals(-1077333228, x ^= (tmp = 3218755006, tmp)); - assertEquals(-50218, x |= (tmp = -1044436526.6435988, tmp)); - assertEquals(-1, x >>= (-154655245.18921852)); - assertEquals(0.00006276207290978003, x *= (((tmp = 2234286992.9800305, tmp)>>(tmp = 2132564046.0696363, tmp))/((((tmp = -2565534644.3428087, tmp)>>>(tmp = 2622809851.043325, tmp))>>>((tmp = 311277386, tmp)&x))-(tmp = -2003980974, tmp)))); - assertEquals(0, x %= x); - assertEquals(1282114076, x += ((((422838227)>>>((tmp = 1024613366.1899053, tmp)-((368275340)<<(((tmp = -3066121318, tmp)+(-2319101378))&x))))^(x>>(tmp = 1920136319.803412, tmp)))^(1282264803.3968434))); - assertEquals(-277097604, x |= (-283585688.9123297)); - assertEquals(553816692, x &= (x&(tmp = 554082036.676608, tmp))); - assertEquals(658505728, x <<= x); - assertEquals(658505728, x &= (x%(2846071230))); - assertEquals(39, x >>= (334728536.5172192)); - assertEquals(0, x -= x); - assertEquals(0, x += x); - assertEquals(0, x &= (tmp = -335285336, tmp)); - assertEquals(0, x <<= (tmp = 1255594828.3430014, tmp)); - assertEquals(0, x %= (-630772751.1248167)); - assertEquals(NaN, x /= ((((x&(tmp = -1576090612, tmp))%x)>>>x)*((-1038073094.2787619)>>>x))); - assertEquals(NaN, x += x); - assertEquals(NaN, x -= (((tmp = -2663887803, tmp)&((x+(-1402421046))/x))/(-2675654483))); - assertEquals(NaN, x %= (x&(tmp = 672002093, tmp))); - assertEquals(0, x |= x); - assertEquals(-2698925754, x += (tmp = -2698925754, tmp)); - assertEquals(-2057748993, x += ((tmp = -2263466497, tmp)^x)); - assertEquals(1, x /= x); - assertEquals(-2769559719.4045835, x -= (2769559720.4045835)); - assertEquals(-1.3964174646069973, x /= (tmp = 1983332198, tmp)); - assertEquals(-2140716624.3964174, x += (tmp = -2140716623, tmp)); - assertEquals(0, x <<= ((2589073007)-(-816764911.8571186))); - assertEquals(-2837097288.161354, x -= (tmp = 2837097288.161354, tmp)); - assertEquals(-1445059927.161354, x += (tmp = 1392037361, tmp)); - assertEquals(155197984, x &= (tmp = -2694712730.924674, tmp)); - assertEquals(155197984, x |= (x>>>(tmp = 69118015.20305443, tmp))); - assertEquals(155197984, x >>>= (((x^(-1353660241))*x)<<(((((x%(tmp = -1905584634, tmp))>>>(tmp = -860171244.5963638, tmp))&(-1084415001.7039547))+(x-(((tmp = 298064661, tmp)>>x)>>((tmp = 378629912.383446, tmp)-(x%x)))))+(((3212580683)/(((((x^x)>>(tmp = -1502887218, tmp))<<x)%(-142779025))|(((tmp = 1361745708, tmp)*(((((tmp = 1797072528.0673332, tmp)+x)%(tmp = 167297609, tmp))%(-287345856.1791787))^(((((((x*(tmp = -640510459.1514752, tmp))<<(x^(tmp = 1387982082.5646644, tmp)))>>(tmp = 2473373497.467914, tmp))^((234025940)*x))+(tmp = 520098202.9546956, tmp))*(x*(tmp = -362929250.1775775, tmp)))^(-2379972900))))*(tmp = -1385817972, tmp))))+(-1788631834))))); - assertEquals(0, x >>= ((tmp = -18671049, tmp)/((tmp = 651261550.6716013, tmp)>>(-58105114.70740628)))); - assertEquals(0, x *= ((((x>>(tmp = 2256492150.737681, tmp))<<(x<<(((-2738910707)&x)<<(1892428322))))*(tmp = 1547934638, tmp))>>((((319464033.7888391)|(((((tmp = 2705641070, tmp)<<((tmp = 1566904759.36666, tmp)*((-682175559.7540412)&(-691692016.3021002))))%(tmp = 1118101737, tmp))|(902774462))<<x))^((tmp = -388997180, tmp)<<(x<<((((((-88462733)+(x>>>x))%x)*(tmp = -20297481.556210756, tmp))>>>(1927423855.1719701))-((2047811185.6278129)-(tmp = 2952219346.72126, tmp))))))|(-1685518403.7513878)))); - assertEquals(0, x /= (tmp = 1858074757.563318, tmp)); - assertEquals(-1351623058, x ^= (-1351623058.4756806)); - assertEquals(1, x /= x); - assertEquals(0, x ^= x); - assertEquals(0, x -= (x&(997878144.9798675))); - assertEquals(-0, x /= (-2769731277)); - assertEquals(0, x >>>= ((-2598508325)>>(-1355571351))); - assertEquals(0, x >>>= x); - assertEquals(0, x -= (x&(tmp = 1672810223, tmp))); - assertEquals(-924449908.1999881, x -= (924449908.1999881)); - assertEquals(-0, x %= x); - assertEquals(-0, x /= (tmp = 2007131382.059545, tmp)); - assertEquals(-0, x += x); - assertEquals(225132064, x += ((((tmp = -2422670578.1260514, tmp)|x)+x)^(1660142894.7066057))); - assertEquals(Infinity, x /= (x-x)); - assertEquals(0, x ^= x); - assertEquals(0, x <<= x); - assertEquals(-2455424946.732606, x -= (2455424946.732606)); - assertEquals(1208029258, x &= ((tmp = 1823728509, tmp)+x)); - assertEquals(1.3682499724725645, x /= ((((tmp = 1267938464.3854322, tmp)%((tmp = 2510853574, tmp)+(((2979355693.866435)-(tmp = 1989726095.7746763, tmp))<<x)))%((-1382092141.1627176)+(((-901799353)+((-2936414080.8254457)>>>(2515004943.0865674)))-(2532799222.353197))))<<(tmp = -2168058960.2694826, tmp))); - assertEquals(0.13799826710735907, x %= ((-1090423235)/(tmp = 2659024727, tmp))); - assertEquals(0, x >>= (1688542889.082693)); - assertEquals(0, x <<= x); - assertEquals(NaN, x %= ((((tmp = 1461037539, tmp)<<((x<<(tmp = 2101282906.5302017, tmp))>>(-2792197742)))%(((x%x)^(((tmp = 1399565526, tmp)^(tmp = 643902, tmp))-((tmp = -1449543738, tmp)|x)))/x))*(x<<(471967867)))); - assertEquals(0, x &= ((tmp = -2121748100.6824129, tmp)>>(tmp = -2817271480.6497793, tmp))); - assertEquals(0, x &= (3169130964.6291866)); - assertEquals(-0, x /= (-2303316806)); - assertEquals(0, x <<= (tmp = 120185946.51617038, tmp)); - assertEquals(449448375, x ^= ((((tmp = -836410266.014014, tmp)/x)&((x>>>(tmp = -2602671283, tmp))+x))+(tmp = 449448375, tmp))); - assertEquals(202003841790140640, x *= x); - assertEquals(202003840800829020, x += (((tmp = -1339865843, tmp)+(tmp = 350554234.15375435, tmp))<<((((((tmp = -1798499687.8208885, tmp)>>(((x-(x^x))|((tmp = 463627396.23932934, tmp)/(2714928060)))&(tmp = 3048222568.1103754, tmp)))&(-3127578553))<<(tmp = -2569797028.8299003, tmp))&x)<<((tmp = 2104393646, tmp)/((tmp = 2314471015.742891, tmp)<<((2704090554.1746845)>>(((tmp = 1935999696, tmp)*(((1348554815)>>>x)>>>(146665093.82445252)))%x))))))); - assertEquals(202003841764125400, x -= (tmp = -963296372.2846234, tmp)); - assertEquals(-413485056, x <<= (tmp = -2474480506.6054573, tmp)); - assertEquals(-3171894580.186845, x += ((tmp = -1261111102, tmp)+(tmp = -1497298422.1868448, tmp))); - assertEquals(17136, x >>= (tmp = 3055058160, tmp)); - assertEquals(17136, x %= (tmp = 1706784063.3577294, tmp)); - assertEquals(17136, x >>= ((tmp = 2161213808, tmp)*x)); - assertEquals(-17136, x /= ((((tmp = -1492618154, tmp)>>x)|(1381949066))>>(tmp = 2014457960, tmp))); - assertEquals(-34272, x += x); - assertEquals(-1498690902, x += (-1498656630)); - assertEquals(-1168674482, x ^= (486325220)); - assertEquals(-1168674482, x <<= ((x^x)*x)); - assertEquals(794521557347068000, x *= (-679848469)); - assertEquals(1.3330392590424505e+26, x *= (tmp = 167778866, tmp)); - assertEquals(0, x <<= (tmp = -2501540637.3664584, tmp)); - assertEquals(0, x >>>= (x-(x*(-890638026.1825848)))); - assertEquals(0, x %= ((-285010538.2813468)&(1314684460.7634423))); - assertEquals(0, x -= x); - assertEquals(0, x *= x); - assertEquals(NaN, x %= (x*(x<<x))); - assertEquals(NaN, x %= (x<<(((tmp = -1763171810.601149, tmp)&(-138151449.18303752))^(x|x)))); - assertEquals(0, x |= (x>>x)); - assertEquals(0, x &= (tmp = 1107152048, tmp)); - assertEquals(0, x >>= (1489117056.8200984)); - assertEquals(518749976, x ^= (518749976.20107937)); - assertEquals(356718654, x += (tmp = -162031322, tmp)); - assertEquals(356718654, x %= (((x>>>((tmp = -373747439.09634733, tmp)*(tmp = 563665566, tmp)))*(tmp = 2853322586.588251, tmp))*((1303537213)%(-2995314284)))); - assertEquals(5573728, x >>= (tmp = -2095997978, tmp)); - assertEquals(5573728, x <<= x); - assertEquals(5573728, x >>= (((((tmp = 1745399178.334154, tmp)<<(tmp = 2647999783.8219824, tmp))^(tmp = 1571286759, tmp))%x)/(2166250345.181711))); - assertEquals(10886, x >>>= ((682837289)+(x*x))); - assertEquals(170, x >>>= x); - assertEquals(169.95167497151652, x -= (((tmp = 527356024.19706845, tmp)+((tmp = 1263164619.2954736, tmp)|(tmp = 2942471886, tmp)))/((3017909419.131321)+(tmp = 2137746252.8006272, tmp)))); - assertEquals(-1915170061, x ^= (tmp = -1915170214, tmp)); - assertEquals(206045792, x &= (((tmp = 887031922, tmp)>>>x)-((-1861922770)|(9633541)))); - assertEquals(-1940321674, x |= (tmp = -2012149162.1817405, tmp)); - assertEquals(-1940321674, x &= x); - assertEquals(1128412272.160699, x += (tmp = 3068733946.160699, tmp)); - assertEquals(0.47486363523180236, x /= (tmp = 2376286976.807289, tmp)); - assertEquals(-1.4931079540252477e-10, x /= (tmp = -3180370407.5892467, tmp)); - assertEquals(0, x |= (((1220765170.5933602)*(884017786))*((x%(tmp = -2538196897.226384, tmp))<<(x^x)))); - assertEquals(-525529894, x += (tmp = -525529894, tmp)); - assertEquals(1621426184, x &= ((3046517714)*(((((-162481040.8033898)+(x/((x&(1489724492))/((x|(tmp = 943542303, tmp))>>>((-1840491388.1365871)<<(2338177232))))))+(((-2268887573.2430763)>>>(((tmp = 2919141667, tmp)+((tmp = 1326295559.692003, tmp)<<(-2256653815)))>>>(((((tmp = 1602731976.7514615, tmp)*(856036244.3730336))^x)>>>((((2846316421.252943)&(915324162))%(tmp = 1144577211.0221815, tmp))%x))*(x*x))))%(tmp = -2641416560, tmp)))*(x+(x>>>x)))>>x))); - assertEquals(1621426184, x %= (tmp = 1898223948, tmp)); - assertEquals(-3.383396676504762, x /= ((tmp = 2211088034.5234556, tmp)^x)); - assertEquals(7120923705.122882, x *= (((((tmp = 2632382342.914504, tmp)/(-615440284.1762738))&(2162453853.6658797))<<(-849038082.5298986))|(tmp = -2104667110.5603983, tmp))); - assertEquals(-1469010887, x &= x); - assertEquals(850767635866964700, x *= (tmp = -579143179.5338116, tmp)); - assertEquals(0, x %= x); - assertEquals(-571457, x |= ((2849326490.8464212)|(tmp = 1450592063, tmp))); - assertEquals(-571457, x &= x); - assertEquals(-0.00018638416434019244, x /= (3066016912.021368)); - assertEquals(0, x <<= (2058262829)); - assertEquals(NaN, x %= ((x|((x%x)>>>x))%((tmp = -2970314895.6974382, tmp)+x))); - assertEquals(NaN, x *= (-698693934.9483855)); - assertEquals(NaN, x += (-100150720.64391875)); - assertEquals(NaN, x %= x); - assertEquals(NaN, x -= (-530301478)); - assertEquals(NaN, x /= (1507673244)); - assertEquals(0, x <<= (x%(tmp = 2977838420.857235, tmp))); - assertEquals(0, x <<= (tmp = 3200877763, tmp)); - assertEquals(0, x <<= (tmp = -2592127060, tmp)); - assertEquals(NaN, x -= (((((((1930632619)*(3018666359))<<((tmp = 2676511886, tmp)&(-2786714482.25468)))%x)-(-633193192))<<((tmp = 403293598, tmp)*(-2765170226)))%x)); - assertEquals(530062092, x |= (tmp = 530062092, tmp)); - assertEquals(129409, x >>>= x); - assertEquals(-152430382316341.78, x *= (-1177896300.229055)); - assertEquals(-304860764632683.56, x += x); - assertEquals(0, x ^= x); - assertEquals(0, x %= (tmp = -63071565.367660046, tmp)); - assertEquals(0, x &= ((((tmp = -1007464338, tmp)<<(x<<((x^(tmp = -726826835, tmp))|x)))>>>x)*(((tmp = 469293335.9161849, tmp)<<(((((tmp = 1035077379, tmp)*(tmp = -555174353.7567515, tmp))&(3109222796.8286266))-(((((x-(tmp = 1128900353.6650414, tmp))|(tmp = 3119921303, tmp))&((-1353827690)&(x%((-924615958)&x))))>>>x)+(tmp = 1167787910, tmp)))+x))%((605363594)>>(1784370958.269381))))); - assertEquals(0, x %= (2953812835.9781704)); - assertEquals(0, x -= x); - assertEquals(0, x <<= x); - assertEquals(-901209266, x += (-901209266)); - assertEquals(-901209266, x &= x); - assertEquals(404, x >>>= (-3195686249)); - assertEquals(824237108, x ^= (824237472)); - assertEquals(497790936.1853996, x /= ((tmp = 1253776028, tmp)/(757207285))); - assertEquals(497790936, x >>>= ((tmp = -2212598336, tmp)<<(x^(1335355792.9363852)))); - assertEquals(0, x %= x); - assertEquals(-2659887352.6415873, x += (tmp = -2659887352.6415873, tmp)); - assertEquals(1635079945, x |= ((x&(1234659380))>>((((tmp = 2694276886.979136, tmp)|x)^((tmp = 132795582, tmp)<<((-1089828902)>>>x)))<<((((tmp = -2098728613.0310376, tmp)<<(x/(tmp = -2253865599, tmp)))*((x+(x>>>((48633053.82579231)-(385301592))))*(tmp = -1847454853.333535, tmp)))/((-540428068.8583717)+x))))); - assertEquals(1, x /= x); - assertEquals(33554432, x <<= ((((2803140769)<<x)|(tmp = -1965793804, tmp))>>>(tmp = -2273336965.575082, tmp))); - assertEquals(67108864, x += x); - assertEquals(9007199254740992, x *= (x+((x>>x)%(2674760854)))); - assertEquals(55369784, x %= (x|(-170725544.20038843))); - assertEquals(55369784, x %= (-1186186787)); - assertEquals(0, x ^= x); - assertEquals(0, x <<= x); - assertEquals(NaN, x /= ((-2968110098)-((x/(x|(((((x|((x&((-130329882)>>>(((-135670650)|(x<<(tmp = 1280371822, tmp)))^x)))-(-1183024707.2230911)))&(-1072829280))>>>(-340696948.41492534))>>>(tmp = 436308526.4938295, tmp))<<(((tmp = 3113787500, tmp)*((2038309320)>>>(-1818917055)))&((2808000707)/(774731251))))))%x))); - assertEquals(0, x |= (x*(tmp = -843074864, tmp))); - assertEquals(0, x &= (tmp = -752261173.8090212, tmp)); - assertEquals(0, x >>>= (tmp = 1532349931.7517128, tmp)); - assertEquals(0, x <<= ((tmp = -8628768, tmp)-((((tmp = 225928543, tmp)%(x>>>(x+x)))^((tmp = -2051536806.5249376, tmp)-x))-((tmp = -2274310376.9964137, tmp)%(tmp = 2251342739, tmp))))); - assertEquals(0, x >>= (1011388449)); - assertEquals(0, x += x); - assertEquals(0, x >>>= x); - assertEquals(-0, x *= ((-1781234179.8663826)>>(((1514201119.9761915)>>(((((1174857164.90042)^(tmp = 1124973934, tmp))^x)+((-1059246013.8834443)<<(2997611138.4876065)))%(((798188010)*(-1428293122))>>>(tmp = -3087267036.8035297, tmp))))<<x))); - assertEquals(1752554372, x ^= (tmp = -2542412924, tmp)); - assertEquals(1752554372, x %= (tmp = 3037553410.2298307, tmp)); - assertEquals(1859383977, x -= (x^(2446603103))); - assertEquals(1183048193, x &= ((tmp = -962336957, tmp)/(x/x))); - assertEquals(67738157, x %= ((((tmp = -1813911745.5223546, tmp)+x)<<(x-(((-1980179168)^x)|x)))|(1913769561.1308007))); - assertEquals(67698724, x &= ((1801574998.3142045)*((tmp = -2057492249, tmp)/((1713854494.72282)>>x)))); - assertEquals(0, x -= x); - assertEquals(-25232836, x -= ((tmp = 25232836, tmp)|x)); - assertEquals(-49, x >>= (x+((tmp = 2201204630.2897243, tmp)|(-1929326509)))); - assertEquals(-1605632, x <<= x); - assertEquals(-165965313, x += (tmp = -164359681, tmp)); - assertEquals(9.220413724941365e-10, x /= (((((tmp = 2579760013.0808706, tmp)*(tmp = -2535370639.9805303, tmp))>>((tmp = 2138199747.0301933, tmp)-(tmp = -2698019325.0972376, tmp)))*(tmp = -425284716, tmp))/((-1951538149.6611228)/(x^(2632919130))))); - assertEquals(0, x &= x); - assertEquals(0, x &= ((-645189137)/(tmp = 800952748, tmp))); - assertEquals(0, x &= (tmp = -1773606925, tmp)); - assertEquals(0, x += x); - assertEquals(0, x >>>= (tmp = 211399355.0741787, tmp)); - assertEquals(0, x <<= ((-1317040231.5737965)/((((((tmp = 838897586.0147077, tmp)|((-1902447594)|(tmp = 404942728.83034873, tmp)))^(2462760692.2907705))%((((((x%(tmp = -2888980287, tmp))<<(-368505224.49609876))-((x>>>(532513369))&(((((((tmp = -1298067543, tmp)^(tmp = -3130435881.100909, tmp))>>x)/(tmp = -3041161992, tmp))>>(x|(-431685991.95776653)))^((tmp = 1031777777, tmp)^((-105610810)>>>((-631433779)>>(tmp = -2577780871.167671, tmp)))))%(tmp = -3170517650.088039, tmp))))-(((tmp = 2175146237.968785, tmp)-((384631158.50508535)>>((893912279.4646157)|(tmp = -1478803924.5338967, tmp))))%(x/(-1089156420))))<<(tmp = -2024709456, tmp))>>x))*(tmp = -1423824994.6993582, tmp))%(tmp = 1739143409, tmp)))); - assertEquals(-1799353648, x |= ((-1799353648.3589036)>>>((((x&(-923571640.1012449))%x)+((tmp = 971885508, tmp)>>((tmp = -2207464428.2123804, tmp)+(-3108177894.0459776))))-(-2048954486.7014258)))); - assertEquals(-3666808032.2958965, x -= (tmp = 1867454384.2958965, tmp)); - assertEquals(-260069478915415100, x *= (tmp = 70925305.23136711, tmp)); - assertEquals(1142096768, x &= (tmp = 1866401706.9144325, tmp)); - assertEquals(1, x >>>= (tmp = 2701377150.5717473, tmp)); - assertEquals(1865946805, x |= (tmp = -2429020492, tmp)); - assertEquals(1424222287, x ^= ((((tmp = 433781338, tmp)>>(x>>>((-2914418422.4829016)/(tmp = 1600920669, tmp))))|(tmp = 588320482.9566053, tmp))>>>((((((x+(tmp = -2556387365.5071325, tmp))+(tmp = -2381889946.1830974, tmp))/(3154278191))>>>(-1069701268.8022757))>>(((tmp = 182049089.28866422, tmp)>>x)>>>(tmp = -447146173, tmp)))/(x-(2103883357.0929923))))); - assertEquals(0, x ^= x); - assertEquals(0, x -= (x%(3036884806))); - assertEquals(0, x >>>= (tmp = -652793480.3870945, tmp)); - assertEquals(0, x += x); - assertEquals(304031003, x ^= ((tmp = -900156495, tmp)^(-666397014.0711515))); - assertEquals(1, x /= x); - assertEquals(-1974501681, x |= (x^(-1974501681.4628205))); - assertEquals(-1.3089278317616264, x /= (((-1723703186.962839)>>>x)|((2061022161.6239533)<<x))); - assertEquals(-1, x |= (tmp = -1987006457, tmp)); - assertEquals(-0.14285714285714285, x /= ((((((x|(-1767793799.7595732))-(-1391656680))<<x)|(x>>(tmp = -2301588485.2811003, tmp)))>>>(((tmp = 1812723993, tmp)>>>((x^(((tmp = -3154100157.951021, tmp)%((tmp = -1254955564.4553523, tmp)-(((x>>>(((-1762886343)*x)*x))*(x^(x*(-750918563.4387553))))*x)))|((x>>x)>>(x<<((((-1766797454.5634143)^(tmp = -2251474340, tmp))-(-787637516.5276759))<<((1390653368)^(-1937605249.245374)))))))|(((tmp = 1156611894, tmp)<<x)<<(x>>((((x+(tmp = 2170166060.881797, tmp))&(x>>>(tmp = -1749295923.1498983, tmp)))>>(((-1014973878)|x)&(1302866805.684057)))*(tmp = 560439074.4002491, tmp))))))|(-2758270803.4510045)))&x)); - assertEquals(0, x |= x); - assertEquals(0, x += ((x>>((x+(tmp = -2776680860.870219, tmp))-(((688502468)<<(((tmp = 475364260.57888806, tmp)<<x)+(329071671)))/(-1097134948))))*(tmp = -1281834214.3416953, tmp))); - assertEquals(0, x *= ((((1159762330)<<(tmp = -1892429200, tmp))%x)<<x)); - assertEquals(0, x >>>= (-770595225)); - assertEquals(NaN, x += (((x>>x)/(tmp = 281621135, tmp))/x)); - assertEquals(0, x >>= (1363890241)); - assertEquals(1639023942.9945002, x += (1639023942.9945002)); - assertEquals(-2568590958567747000, x *= (-1567146697)); - assertEquals(1793554700, x ^= (tmp = 3215813388.405799, tmp)); - assertEquals(437879, x >>= x); - assertEquals(1339485943, x |= (1339220210)); - assertEquals(1, x /= x); - assertEquals(512, x <<= (2509226729.1477118)); - assertEquals(512, x <<= ((x>>(1326274040.7181284))<<(tmp = -760670199, tmp))); - assertEquals(1, x /= (x<<(x^x))); - assertEquals(0, x >>>= (((((1382512625.8298302)&(x>>>x))*(tmp = -815316595, tmp))>>>x)-(-95538051))); - assertEquals(-544344229.3548596, x -= (tmp = 544344229.3548596, tmp)); - assertEquals(-1088688458.7097192, x += x); - assertEquals(-1022850479579041900, x *= (939525418.3104812)); - assertEquals(2069622661, x |= (-2632744187.7721186)); - assertEquals(-1353480538017756400, x -= ((tmp = 1308085980, tmp)*((x>>>(-629663391.5165792))&(tmp = 3182319856.674114, tmp)))); - assertEquals(1.3702811563654176e+27, x *= ((((3061414617.6321163)/(tmp = 2628865442, tmp))+(-1549548261))+(x&((tmp = 809684398, tmp)|(x^(tmp = 801765002, tmp)))))); - assertEquals(0, x >>>= ((-2988504159)&((tmp = -260444190.02252054, tmp)^(2178729442.260293)))); - assertEquals(-1518607002, x -= (tmp = 1518607002, tmp)); - assertEquals(724566016, x <<= (tmp = 1042915731.7055794, tmp)); - assertEquals(707584, x >>>= (-208959862.93305588)); - assertEquals(0, x >>>= (((tmp = 877181764, tmp)>>(-970697753.3318911))%x)); - assertEquals(0, x ^= x); - assertEquals(0, x += x); - assertEquals(0, x <<= x); - assertEquals(0, x /= (x^((x/(-2903618412.4936123))+(tmp = 1169288899, tmp)))); - assertEquals(0, x >>>= x); - assertEquals(-1302645245, x ^= ((1855892732.3544865)+(tmp = 1136429319.5633948, tmp))); - assertEquals(0, x ^= x); - assertEquals(0, x &= (-1384534597.409375)); - assertEquals(-0, x /= (tmp = -680466419.8289509, tmp)); - assertEquals(-0, x *= (318728599.95017374)); - assertEquals(NaN, x %= (x>>(2019695267))); - assertEquals(0, x >>= (tmp = 1280789995, tmp)); - assertEquals(0, x *= (tmp = 2336951458, tmp)); - assertEquals(0, x >>= ((2981466013.758637)%(731947033))); - assertEquals(0, x -= x); - assertEquals(0, x ^= x); - assertEquals(0, x /= ((((3068070149.1452317)>>x)%(((1448965452)*((tmp = -2961594129, tmp)+(1829082104.0681171)))>>(-2331499703)))>>>(tmp = -3206314941.2626476, tmp))); - assertEquals(0, x >>= (x%(1869217101.9823673))); - assertEquals(0, x <<= (x+x)); - assertEquals(0, x >>>= ((1202130282)>>>x)); - assertEquals(0, x += x); - assertEquals(2603245248.6273212, x += (tmp = 2603245248.6273212, tmp)); - assertEquals(-1691864471, x ^= (x>>>(2504513614.117516))); - assertEquals(136835305, x -= ((-1618979896)&(-746953306))); - assertEquals(-2568499564.1261334, x += (tmp = -2705334869.1261334, tmp)); - assertEquals(1038075700, x ^= (1530399136)); - assertEquals(2076151400, x += x); - assertEquals(-524018410.1751909, x -= ((2398973627.175191)-(-201196183))); - assertEquals(0.327110599608614, x /= ((3181340288.602796)&x)); - assertEquals(0.327110599608614, x %= (tmp = -2284484060, tmp)); - assertEquals(0, x |= x); - assertEquals(403217947.5779772, x += (tmp = 403217947.5779772, tmp)); - assertEquals(403217947, x |= x); - assertEquals(-Infinity, x *= ((58693583.845808744)+(((tmp = -1527787016, tmp)*x)/((((2532689893.3191843)/(tmp = 2781746479.850424, tmp))|(((((460850355.9211761)/((((tmp = 626683450, tmp)<<((tmp = 1349974710, tmp)-((tmp = -1349602292, tmp)/(-2199808871.1229663))))>>((x/(-3092436372.3078623))&(tmp = -1190631012.0323825, tmp)))^((-2907082828.4552956)-(tmp = 1858683340.1157017, tmp))))^(-1513755598.5398848))%x)/x))&(1147739260.136806))))); - assertEquals(0, x &= (tmp = -3047356844.109563, tmp)); - assertEquals(637934616, x -= (tmp = -637934616, tmp)); - assertEquals(-1553350083, x ^= (-2056266203.094929)); - assertEquals(-0.13467351026547192, x %= ((tmp = 824736251, tmp)/(2544186314))); - assertEquals(1, x /= x); - assertEquals(1, x |= x); - assertEquals(0, x >>>= (2166609431.9515543)); - assertEquals(0, x <<= (x|(tmp = 121899222.14603412, tmp))); - assertEquals(0, x *= (1300447849.6595674)); - assertEquals(0, x %= (tmp = -2360500865.3944597, tmp)); - assertEquals(0, x %= (tmp = -1693401247, tmp)); - assertEquals(0, x >>= x); - assertEquals(0, x /= (471265307)); - assertEquals(257349748, x ^= (257349748.689448)); - assertEquals(257349748, x &= x); - assertEquals(981, x >>>= (tmp = -1959001422, tmp)); - assertEquals(0, x >>= ((-79932778.18114972)/x)); - assertEquals(0, x <<= (((-2599621472)^(tmp = 662071103, tmp))%(tmp = -2675822640.7641535, tmp))); - assertEquals(0, x &= (tmp = 2582354953.878623, tmp)); - assertEquals(0, x /= ((-953254484)/((-2571632163.376176)-(tmp = -342034471, tmp)))); - assertEquals(0, x <<= ((x-(tmp = -3013057672, tmp))&(tmp = -3204761036, tmp))); - assertEquals(0, x ^= ((x&((515934453)>>>x))/x)); - assertEquals(1, x |= ((-1914707646.2075093)>>>(tmp = -1918045025, tmp))); - assertEquals(-2002844120.8792589, x += (tmp = -2002844121.8792589, tmp)); - assertEquals(573030794, x >>>= (tmp = 1707788162, tmp)); - assertEquals(1.917619109627369, x /= ((1909436830.484202)%((123114323)<<(tmp = -1288988388.6444468, tmp)))); - assertEquals(-1400358045, x |= (-1400358046)); - assertEquals(-2043022529.4273133, x += (tmp = -642664484.4273133, tmp)); - assertEquals(-81408068.86728716, x %= (tmp = -980807230.2800131, tmp)); - assertEquals(0.1436896445024992, x /= (((tmp = 3201789924.913518, tmp)%(tmp = -962242528.6008646, tmp))^((tmp = -338830119.55884504, tmp)*(tmp = -916120166, tmp)))); - assertEquals(0.1436896445024992, x %= (tmp = 2598469263, tmp)); - assertEquals(0, x *= (x-x)); - assertEquals(-1409286144, x += (((-111514798.64745283)|(2372059654))<<(tmp = 175644313, tmp))); - assertEquals(-2393905467.0073113, x += (-984619323.0073113)); - assertEquals(-835111172.0073113, x %= (x^(-765900532.5585573))); - assertEquals(-835111172.0073113, x %= (tmp = -946478116, tmp)); - assertEquals(-100, x >>= ((-1020515908)>>(((x&((x^(169474253.53811646))>>(-221739002)))+x)*((201939882.92880356)/(tmp = -50402570, tmp))))); - assertEquals(2131506964, x &= (tmp = -2163460268, tmp)); - assertEquals(1074275840, x &= ((-1561930379.8719592)*(tmp = -2871750052.876917, tmp))); - assertEquals(-954232605.5377102, x -= (tmp = 2028508445.5377102, tmp)); - assertEquals(-29, x >>= (-279577351.87217045)); - assertEquals(-232, x <<= x); - assertEquals(-70, x |= (215185578)); - assertEquals(-1, x >>= (x>>(-1691303095))); - assertEquals(1, x /= x); - assertEquals(3149465364.2236686, x *= (3149465364.2236686)); - assertEquals(3304787832.3790073, x += (tmp = 155322468.15533853, tmp)); - assertEquals(100068712.23500109, x %= (tmp = 3204719120.1440063, tmp)); - assertEquals(91628864, x &= (tmp = 629090241, tmp)); - assertEquals(-113202292046379710, x *= (-1235443583)); - assertEquals(122, x >>>= (tmp = 3196555256, tmp)); - assertEquals(122, x >>>= (((2226535734)-x)^(2248399036.393125))); - assertEquals(6.904199169070746e-8, x /= (tmp = 1767040564.9149356, tmp)); - assertEquals(-212687449.99999994, x += ((((2244322375)*(((2515994102)^x)>>x))<<(x-(-832407685.3251972)))^(2266670502))); - assertEquals(366515938514778750, x *= (tmp = -1723260768.3940866, tmp)); - assertEquals(366515938514778750, x += ((-1643386193.9159095)/(tmp = 425161225.95316494, tmp))); - assertEquals(654872716.4123061, x /= ((-1377382984)-(tmp = -1937058061.811642, tmp))); - assertEquals(654872716, x &= x); - assertEquals(-86260926.17813063, x -= (tmp = 741133642.1781306, tmp)); - assertEquals(1052176592, x >>>= x); - assertEquals(2020882856, x ^= (-3107796616)); - assertEquals(0, x <<= ((606939871.9812952)|(tmp = -3127138319.1557302, tmp))); - assertEquals(NaN, x -= ((x%((1120711400.2242608)%x))*(tmp = -930171286.7999947, tmp))); - assertEquals(NaN, x %= (3215044180)); - assertEquals(NaN, x %= (tmp = 2882893804.20102, tmp)); - assertEquals(NaN, x %= ((217170359.5778643)^x)); - assertEquals(0, x &= ((-1095125960.9903677)>>(x^(-2227981276)))); - assertEquals(-748549860, x += (-748549860)); - assertEquals(1816208256, x <<= (-610872411.3826082)); - assertEquals(201400576, x &= (((tmp = 1910394603.4836266, tmp)<<x)^x)); - assertEquals(0, x %= x); - assertEquals(NaN, x %= x); - assertEquals(0, x <<= (((((2670901339.6696005)%(2180020861))*((2134469504)/(2237096063.0680027)))*((tmp = 1203829756, tmp)>>((765467065)+(x|(2673651811.9494815)))))<<((-1463378514)|(((x/(tmp = -1075050081, tmp))-((-879974865)+x))>>>(tmp = 2172883926, tmp))))); - assertEquals(433013198, x ^= (433013198.2833413)); - assertEquals(0, x >>= ((((-2404431196)%(x%(tmp = 1443152875.8809233, tmp)))&(x|((1414364997.0517852)/((tmp = -435854369, tmp)+(tmp = 2737625141, tmp)))))|(((tmp = 2241746562.2197237, tmp)^(tmp = -1606928010.1992552, tmp))|((tmp = -3083227418.686173, tmp)>>(tmp = -2717460410, tmp))))); - assertEquals(0, x >>= x); - assertEquals(0, x *= ((tmp = 2302521322, tmp)>>>(((((((tmp = 344089066.9725498, tmp)%(tmp = 1765830559, tmp))-x)|x)^(((-2450263325)/(tmp = 371928405.17475057, tmp))>>>(1330100413.7731652)))^(((173024329)%(tmp = -2927276187, tmp))+(x>>>(-1042229940.308507))))|(((((tmp = 379074096, tmp)+((142762508)-((-2773070834.526266)-(x&((tmp = 57957493, tmp)<<(2189553500))))))+((36991093)+(tmp = 339487168.58069587, tmp)))*(-1257565451))&(tmp = 645233114, tmp))))); - assertEquals(-2644503151.1185284, x += (-2644503151.1185284)); - assertEquals(-5289006302.237057, x += x); - assertEquals(-4008773824.2370567, x -= (tmp = -1280232478, tmp)); - assertEquals(1975449413, x |= ((tmp = 1957832005.4285066, tmp)>>((1681236712.9715524)&(-675823978)))); - assertEquals(-146472960, x <<= (-648510672.5644083)); - assertEquals(-3, x |= (((((x>>>(tmp = 2271744104, tmp))+(tmp = -210058133.30147195, tmp))+(tmp = -2827493425, tmp))/(tmp = 765962538, tmp))%(tmp = 1048631551, tmp))); - assertEquals(1, x /= x); - assertEquals(0, x >>= (1070524782.5154183)); - assertEquals(0, x <<= (462502504)); - assertEquals(0, x %= (540589670.0730014)); - assertEquals(NaN, x %= x); - assertEquals(NaN, x /= ((-1268640098)%x)); - assertEquals(NaN, x %= (1741157613.744652)); - assertEquals(NaN, x += x); - assertEquals(NaN, x %= ((x|(tmp = 1992323492.7000637, tmp))*x)); - assertEquals(NaN, x /= ((tmp = -2271503368.0341196, tmp)>>((tmp = 1224449194, tmp)>>>(tmp = 2976803997, tmp)))); - assertEquals(NaN, x += (tmp = -1078313742.1633894, tmp)); - assertEquals(NaN, x += (-787923311)); - assertEquals(NaN, x %= x); - assertEquals(-1299878219, x ^= (2995089077)); - assertEquals(536887953, x &= ((625660571.2651105)&(x^(((tmp = 950150725.2319129, tmp)+(-2122154205.466675))/(tmp = 1754964696.974752, tmp))))); - assertEquals(4096, x >>>= x); - assertEquals(1, x /= x); - assertEquals(-82508517, x ^= (((-930231800)%(tmp = -423861640.4356506, tmp))+x)); - assertEquals(-82508517, x &= (x&x)); - assertEquals(-479519, x %= ((tmp = 1861364600.595756, tmp)|x)); - assertEquals(479518, x ^= (((x>>(-1539139751.6860313))>>(tmp = -456165734, tmp))|(-2786433531))); - assertEquals(959036, x += x); - assertEquals(29, x >>>= ((tmp = -1049329009.7632706, tmp)^(((((((1117739997)/(((-841179741.4939663)*(-1211599672))>>>((-413696355)%(tmp = -1753423217.2170188, tmp))))<<(tmp = 1599076219.09274, tmp))>>>(-1382960317))^(((x^(tmp = 515115394, tmp))>>>(tmp = -388476217, tmp))>>>(x/x)))^x)<<(136327532.213817)))); - assertEquals(24, x &= (2388755418)); - assertEquals(0, x >>>= (tmp = -405535917, tmp)); - assertEquals(0, x &= (tmp = -1427139674, tmp)); - assertEquals(NaN, x /= (x^((1530470340)%x))); - assertEquals(0, x |= ((x>>(-1429690909.8472774))*((((tmp = 2033516515, tmp)/(1314782862))>>>x)>>(tmp = 1737186497.6441216, tmp)))); - assertEquals(0, x -= x); - assertEquals(0, x %= (3115422786)); - assertEquals(-0, x *= (x+(tmp = -2558930842.267017, tmp))); - assertEquals(NaN, x %= x); - assertEquals(0, x &= (2695531252.254449)); - assertEquals(-613178182, x ^= (-613178182)); - assertEquals(54, x >>>= (x%(((tmp = 2277868389, tmp)^((((tmp = -1143932265.3616111, tmp)^((x&((x-((-2100384445.7850044)|(tmp = 908075129.3456883, tmp)))*x))+(((tmp = 1031013284.0275401, tmp)*((((tmp = -233393205, tmp)>>>(tmp = -111859419, tmp))*(-1199307178))|(tmp = -1998399599, tmp)))>>>((((-731759641.9036775)>>>(tmp = 2147849691, tmp))>>>(tmp = -2121899736, tmp))>>>(x>>>x)))))>>((1900348757.360562)^(tmp = 2726336203.6149445, tmp)))>>>((x*((tmp = -2697628471.0234947, tmp)%((x^(tmp = -2751379613.9474974, tmp))*x)))+(x>>(tmp = 42868998.384643435, tmp)))))+(598988941)))); - assertEquals(34, x &= ((tmp = 2736218794.4991407, tmp)%(2169273288.1339874))); - assertEquals(2.086197133417468, x /= ((tmp = 2176358852.297597, tmp)%x)); - assertEquals(2, x <<= (((tmp = -1767330075, tmp)|(-3107230779.8512735))&x)); - assertEquals(4194304, x <<= (tmp = 1061841749.105744, tmp)); - assertEquals(48609515, x ^= (44415211.320786595)); - assertEquals(48609515, x %= (1308576139)); - assertEquals(23735, x >>>= ((-324667786)-x)); - assertEquals(23735, x <<= ((-1270911229)<<(((((tmp = -882992909.2692418, tmp)+(tmp = 394833767.947718, tmp))-x)<<(702856751))/x))); - assertEquals(-31080872939240, x *= (tmp = -1309495384, tmp)); - assertEquals(-14625.31935626114, x /= ((668084131)+(1457057357))); - assertEquals(-14625.31935626114, x %= (266351304.6585492)); - assertEquals(-12577, x |= (-945583977.619837)); - assertEquals(-4097, x |= ((tmp = -2621808583.2322493, tmp)-(tmp = -2219802863.9072213, tmp))); - assertEquals(-1004843865, x &= ((-1004839768)+((tmp = 2094772311, tmp)/(-1340720370.275643)))); - assertEquals(-31401371, x >>= ((2035921047)>>>((tmp = -1756995278, tmp)>>>(-537713689)))); - assertEquals(1791746374.016472, x -= ((tmp = -1823147745, tmp)-(x/(tmp = -1906333520, tmp)))); - assertEquals(3.7289343120517406, x /= (tmp = 480498240, tmp)); - assertEquals(7.457868624103481, x += x); - assertEquals(234881024, x <<= (-781128807.2532628)); - assertEquals(67108864, x &= (tmp = -2060391332, tmp)); - assertEquals(-605958718, x -= (673067582)); - assertEquals(-605958718, x <<= ((x%x)&((tmp = 1350579401.0801518, tmp)|x))); - assertEquals(-109268090.4715271, x %= (tmp = -496690627.5284729, tmp)); - assertEquals(-109268090, x <<= (((-2004197436.8023896)%((x|((tmp = 271117765.61283946, tmp)-((1595775845.0754795)*(555248692.2512416))))/x))<<x)); - assertEquals(-652725370, x &= (-543590449)); - assertEquals(0.321858133298825, x /= (tmp = -2027990914.2267523, tmp)); - assertEquals(1959498446, x ^= (1959498446)); - assertEquals(1959498446, x &= (x%(tmp = 3155552362.973523, tmp))); - assertEquals(14949, x >>>= ((tmp = 586618136, tmp)>>>(tmp = 699144121.9458897, tmp))); - assertEquals(-28611391568319.285, x *= (tmp = -1913933478.3811147, tmp)); - assertEquals(1680557633, x &= (((tmp = 2606436319.199714, tmp)<<(1575299025.6917372))|((-1092689109)/(735420388)))); - assertEquals(1680361024, x &= ((tmp = 1860756552.2186172, tmp)|(-360434860.1699109))); - assertEquals(820488, x >>>= (1788658731)); - assertEquals(820488, x >>= (-1555444352)); - assertEquals(2104296413, x ^= (2103543509)); - assertEquals(16843328, x &= ((x<<((-2920883149)/(1299091676)))-(((((tmp = 3199460211, tmp)+(-237287821.61504316))&(tmp = -1524515028.3596857, tmp))-(tmp = -700644414.6785603, tmp))+(-180715428.86124516)))); - assertEquals(1326969834, x |= (tmp = -2968063574.793867, tmp)); - assertEquals(0, x %= (x>>>(tmp = 1350490461.0012388, tmp))); - assertEquals(0, x &= ((-2620439260.902854)+x)); - assertEquals(-1775533561, x |= ((-1775533561)|(((x>>>((861896808.2264911)>>>(970216466.6532537)))%x)%(tmp = 2007357223.8893046, tmp)))); - assertEquals(-1775533561, x &= x); - assertEquals(-23058877.415584415, x /= ((tmp = -3002439857, tmp)>>((((x-(tmp = 1583620685.137125, tmp))|x)%(-2568798248.6863875))^x))); - assertEquals(-577.4155844151974, x %= (((-1440361053.047877)+((tmp = 821546785.0910633, tmp)-(((tmp = 1023830881.1444875, tmp)/(-754884477))+(tmp = 651938896.6258571, tmp))))>>(tmp = 346467413.8959185, tmp))); - assertEquals(-1, x >>= (tmp = 2993867511, tmp)); - assertEquals(-1, x |= (tmp = 823150253.4916545, tmp)); - assertEquals(-0, x %= x); - assertEquals(-0, x /= ((tmp = 997969036, tmp)&((((tmp = 928480121, tmp)>>(((-2610875857.086055)>>>(tmp = -2251704283, tmp))|x))+(10781750))>>x))); - assertEquals(0, x >>>= ((tmp = -1872319523, tmp)>>>(-278173884))); - assertEquals(0, x |= (x/(x*x))); - assertEquals(0, x %= ((77912826.10575807)^(tmp = 2770214585.3019757, tmp))); - assertEquals(0, x &= (tmp = 722275824, tmp)); - assertEquals(-1417226266, x |= (tmp = 2877741030.1195555, tmp)); - assertEquals(0, x ^= x); - assertEquals(0, x %= (tmp = -1740126105, tmp)); - assertEquals(910709964, x |= (tmp = 910709964, tmp)); - assertEquals(-1744830464, x <<= (tmp = -2445932551.1762686, tmp)); - assertEquals(318767104, x >>>= (tmp = -2465332061.628887, tmp)); - assertEquals(301989888, x &= (-2771167302.022801)); - assertEquals(301989888, x |= x); - assertEquals(37748736, x >>= (tmp = -835820125, tmp)); - assertEquals(1474977371, x ^= (tmp = -2857738661.6610327, tmp)); - assertEquals(470467500, x += (-1004509871)); - assertEquals(0.30466562575942585, x /= (((tmp = 1515955042, tmp)<<(x+((1607647367)-(tmp = 1427642709.697169, tmp))))^x)); - assertEquals(1.0348231148499734e-10, x /= (tmp = 2944132397, tmp)); - assertEquals(0, x >>= (x>>>(tmp = -2847037519.569043, tmp))); - assertEquals(NaN, x /= x); - assertEquals(0, x >>>= (-1817784819.9058492)); - assertEquals(0, x >>= x); - assertEquals(-0, x *= ((tmp = -1387748473, tmp)|(x+(352432111)))); - assertEquals(-0, x *= (((-2591789329)/(tmp = -2144460203, tmp))>>(tmp = -568837912.5033123, tmp))); - assertEquals(0, x <<= (-2963600437.305708)); - assertEquals(0, x &= ((588720662)>>>x)); - assertEquals(1561910729, x += (1561910729)); - assertEquals(0, x ^= x); - assertEquals(-0, x *= (-2722445702)); - assertEquals(0, x &= (tmp = -2738643199.732308, tmp)); - assertEquals(0, x /= (((1859901899.227291)>>>((tmp = -1067365693, tmp)+((-1975435278)|x)))|((1844023313.3719304)&(tmp = -624215417.0227654, tmp)))); - assertEquals(NaN, x %= x); - assertEquals(NaN, x %= (-2852766277)); - assertEquals(0, x <<= (-1482859558)); - assertEquals(0, x >>= x); - assertEquals(-1196775786, x += (tmp = -1196775786, tmp)); - assertEquals(-68176201, x |= ((tmp = 2336517643, tmp)+x)); - assertEquals(0, x ^= x); - assertEquals(0, x <<= x); - assertEquals(0, x >>= (2969141362.868086)); - assertEquals(NaN, x %= x); - assertEquals(0, x >>= ((x-((((tmp = -905994835, tmp)|(tmp = 2850569869.33876, tmp))<<((-2405056608.27147)>>(tmp = 1280271785, tmp)))&(-1942926558)))*(tmp = 707499803.177796, tmp))); - assertEquals(0, x &= ((-697565829.8780258)+((2978584888.549406)%x))); - assertEquals(0, x >>= (748642824.4181392)); - assertEquals(0, x += x); - assertEquals(0, x >>>= (-1701028721)); - assertEquals(92042539, x -= ((-92042539)|(x*(x%(-293705541.00228095))))); - assertEquals(0, x %= x); - assertEquals(0, x >>= x); - assertEquals(0, x %= (-2278672472.458228)); - assertEquals(0, x %= (((-2374117528.0359464)/((tmp = -2809986062, tmp)|(tmp = 895734980, tmp)))&(tmp = 1564711307.41494, tmp))); - assertEquals(0, x >>>= x); - assertEquals(0, x += x); - assertEquals(-0, x /= ((tmp = -2749286790.3666043, tmp)<<(x^(-2966741582.324482)))); - assertEquals(0, x *= x); - assertEquals(0, x >>>= x); - assertEquals(-1882562314, x ^= (2412404982.782115)); - assertEquals(-806620, x %= (((tmp = 1527219936.5232096, tmp)*(-1139841417))>>>(tmp = 201632907.3236668, tmp))); - assertEquals(-1613240, x += x); - assertEquals(-1664766177387640, x *= (1031939561)); - assertEquals(-9.478083550117849e+23, x *= (tmp = 569334221.1571662, tmp)); - assertEquals(-8.462574598319509e+21, x /= ((x-(tmp = -2985531211.114498, tmp))>>(tmp = 174615992.91117632, tmp))); - assertEquals(1638924288, x <<= (((((x>>((-1823401733.4788911)+((tmp = 1362371590, tmp)>>>x)))^(tmp = -56634380, tmp))/(tmp = 2387980757.1540084, tmp))%((((tmp = -3175469977, tmp)^(tmp = -1816794042, tmp))+(232726694))*(tmp = 822706176, tmp)))/(tmp = 1466729893.836311, tmp))); - assertEquals(2686072821796307000, x *= x); - assertEquals(-1007977445.9812208, x /= (-2664814408.800125)); - assertEquals(-1007977445, x &= x); - assertEquals(322314656346249100, x *= (tmp = -319763758.54942775, tmp)); - assertEquals(197436885.26815608, x /= (tmp = 1632494637, tmp)); - assertEquals(-67191339, x |= ((-399580815.1746769)/((1335558363)/(tmp = 224694526, tmp)))); - assertEquals(1229588737, x &= (tmp = 1296763683.5732255, tmp)); - assertEquals(1229588737, x -= ((((1171546503)|((tmp = -2701891308, tmp)%(-2155432197.022206)))/(-306122816.85682726))>>x)); - assertEquals(4162606632, x -= (tmp = -2933017895, tmp)); - assertEquals(1.6487311395551163, x /= (2524733434.1748486)); - assertEquals(-1929308648.9913044, x += (-1929308650.6400356)); - assertEquals(-3858617297.982609, x += x); - assertEquals(788529152, x <<= (x^(1401824663))); - assertEquals(6160384, x >>>= ((((((x>>>x)>>((((x*(tmp = -1958877151, tmp))>>>(1310891043))-(tmp = 564909413.9962088, tmp))%(-175978438)))%x)|((tmp = -1193552419.7837512, tmp)*(tmp = 1508330424.9068346, tmp)))|(1428324616.3303494))-((1828673751)/(tmp = 1281364779, tmp)))); - assertEquals(6160384, x |= x); - assertEquals(1, x /= x); - assertEquals(1, x &= (tmp = -855689741, tmp)); - assertEquals(0, x >>>= x); - assertEquals(-1088569655.3528988, x -= (tmp = 1088569655.3528988, tmp)); - assertEquals(-1088569655, x >>= ((tmp = 2429646226.626727, tmp)<<((-1539293782.4487276)>>(x^((tmp = 1140855945.537702, tmp)+x))))); - assertEquals(-311, x %= ((x/x)<<x)); - assertEquals(1.2007722007722008, x /= (x|(tmp = 448796341.87655175, tmp))); - assertEquals(3, x |= (x+x)); - assertEquals(-9.32416092168023e-10, x /= (-3217447688)); - assertEquals(0, x >>= (615837464.0921166)); - assertEquals(0, x >>>= (tmp = -2993750670.683118, tmp)); - assertEquals(0, x >>>= (x%x)); - assertEquals(1610612736, x ^= ((-1322905256.6770213)<<(-2567950598))); - assertEquals(1693676493, x ^= (83063757.63660407)); - assertEquals(-758030371, x ^= (tmp = -1239274480, tmp)); - assertEquals(-758030371, x %= (tmp = 1961339006, tmp)); - assertEquals(-1509754528, x ^= (tmp = 1960027837, tmp)); - assertEquals(-1509754528, x <<= x); - assertEquals(-1509754528, x -= (((tmp = -50690205.33559728, tmp)/((tmp = -1364565380, tmp)<<(tmp = 2585052504, tmp)))<<(tmp = -2356889596, tmp))); - assertEquals(1, x >>>= (-3204164321)); - assertEquals(1, x *= x); - assertEquals(1114370230.591965, x *= ((tmp = 1114370229.591965, tmp)+x)); - assertEquals(-4.886305275432552, x /= ((-228059887.33344483)%(2841553631.3685856))); - assertEquals(2.358309397373389e-9, x /= (((x*(tmp = 203428818.08174622, tmp))&(x-(((510438355)*x)+x)))+x)); - assertEquals(0, x >>>= ((tmp = 1444810010, tmp)&(tmp = -3135701995.2235208, tmp))); - assertEquals(0, x /= (1865982928.6819582)); - assertEquals(0, x *= x); - assertEquals(2078726016.3772051, x -= (tmp = -2078726016.3772051, tmp)); - assertEquals(1580337898, x ^= ((tmp = -2714629398.447015, tmp)^x)); - assertEquals(1268363034, x -= ((x+((tmp = 1144068248.3834887, tmp)&(-954104940.155973)))<<(tmp = 1270573731.7828264, tmp))); - assertEquals(1744830464, x <<= (((1444869551.7830744)>>>((((x+(tmp = -904688528, tmp))<<x)-((tmp = 121151912.85873199, tmp)/(tmp = -2414150217.66479, tmp)))|(((-472906698)|(3215236833.8417764))+(907737193.9056952))))-((x&(-732223723))|(-221800427.7392578)))); - assertEquals(717338523283226600, x *= (x^(tmp = -2407450097.0604715, tmp))); - assertEquals(402653184, x >>= ((-3191405201.168252)*((tmp = -1941299639.695196, tmp)|(((x>>(((3215741220)>>>x)/(x+x)))^(((tmp = -2144862025.9842231, tmp)|((tmp = -1966913385, tmp)&x))%x))*((tmp = -1124749626.6112225, tmp)/(tmp = 837842574, tmp)))))); - assertEquals(402653184, x &= ((x|x)>>x)); - assertEquals(134217728, x &= ((2720231644.3849487)*x)); - assertEquals(134217726.75839183, x -= ((2438054684.738043)/(((((-984359711)*(x|((tmp = 177559682, tmp)^x)))/(-1253443505))/((2727868438.416792)*(x+((x<<(((tmp = 3023774345, tmp)&(-705699616.0846889))/x))<<x))))^(1963626488.548761)))); - assertEquals(1, x /= x); - assertEquals(245781494, x += ((tmp = 2551445099, tmp)^(2528486814))); - assertEquals(-1474427807, x ^= (-1497868393.342241)); - assertEquals(-1057271682, x += ((((((x>>x)%(-1556081693))|(x/(((1166243186.6325684)-(((tmp = 2870118257.1019487, tmp)/(x+(-69909960)))^(2270610694.671496)))/((1463187204.5849519)-x))))-x)-(x<<(-3077313003)))%x)); - assertEquals(-1065725846, x &= ((tmp = -1808223767, tmp)|(-481628214.3871765))); - assertEquals(-1065725846, x ^= (x&(((tmp = -1785170598, tmp)-(tmp = -2525350446.346484, tmp))/((((((-1783948056)^(tmp = 3027265884.41588, tmp))|((((tmp = 2195362566.2237773, tmp)<<(-2919444619))<<((tmp = -2507253075.2897573, tmp)^(x^((tmp = 1067516137, tmp)+((667737752)^(x*(tmp = -1187604212.7293758, tmp)))))))%(-617406719.5140038)))*(tmp = 511060465.6632478, tmp))*((tmp = 2580189800.752836, tmp)|((((tmp = 2357895660, tmp)%((-814381220)*(x-((x>>>(((x<<x)<<(tmp = 1919573020, tmp))-x))>>>((-2756011312.136148)>>(tmp = -1603458856, tmp))))))/((tmp = -1609199312, tmp)&(-3127643445)))%x)))<<(-2261731798))))); - assertEquals(1.6020307924030301, x /= (tmp = -665234308.2628405, tmp)); - assertEquals(-1120020556.697667, x *= (tmp = -699125486.2321637, tmp)); - assertEquals(-215875188, x -= (((((tmp = -1307845034, tmp)>>>((((-2820720421)^x)-(((x<<x)|(tmp = -3042092997.57406, tmp))+(((-1294857544)+((tmp = -668029108.1487186, tmp)>>(x<<x)))^(912144065.5274727))))^(389671596.2983854)))|(-2774264897.146559))%(x-((tmp = 1378085269, tmp)^x)))+((-1659377450.5247462)&(((1613063452.834885)>>>((-344896580.0694165)>>>((-13450558)+x)))^x)))); - assertEquals(1, x /= x); - assertEquals(0, x >>>= (2355750790)); - assertEquals(1969435421.4409347, x += (1969435421.4409347)); - assertEquals(0, x -= x); - assertEquals(0, x >>>= (((x*((-1022802960.6953495)<<(tmp = -2848428731.8339424, tmp)))^(-1630921485))%(1532937011))); - assertEquals(0, x <<= ((x+((x^(x^(tmp = 2017651860, tmp)))&(((x<<(((tmp = -1913317290.8189478, tmp)|(x-((((x%((tmp = -3035245210, tmp)+(-2270863807)))>>>((-2351852712)*(x^(-2422943296.0239563))))&((((-1578312517)%x)*x)*(-65592270.28452802)))>>>(tmp = 1104329727.2094703, tmp))))-(tmp = -1431159990.3340137, tmp)))&x)|((tmp = -2589292678.801344, tmp)&(x+((((tmp = -2557773457.456996, tmp)>>(451910805.309445))-x)>>(((tmp = -1937832765.7654495, tmp)^x)%x)))))))%x)); - assertEquals(0, x %= (tmp = -626944459, tmp)); - assertEquals(-732310021, x |= (tmp = -732310021, tmp)); - assertEquals(-732310021, x |= x); - assertEquals(671352839, x ^= (x-((-3087309090.7153115)|x))); - assertEquals(134479872, x &= (tmp = 2357183984, tmp)); - assertEquals(18084835973136384, x *= x); - assertEquals(0, x <<= ((1040482277)-(tmp = -357113781.82650447, tmp))); - assertEquals(74957, x |= ((((tmp = -70789345.7489841, tmp)%(tmp = 1415750131, tmp))&x)|((307027314)>>(2284275468)))); - assertEquals(9, x >>>= x); - assertEquals(0, x &= (x&((x*((x*(x%x))%(x>>x)))/x))); - assertEquals(-1872875060, x |= (2422092236.6850452)); - assertEquals(9, x >>>= (-382763684)); - assertEquals(4608, x <<= x); - assertEquals(40.480234260614935, x /= (((((((tmp = 814638767.5666755, tmp)&((tmp = 2081507162, tmp)^(x>>>(1460148331.2229118))))&(tmp = 1187669197.7318723, tmp))<<(412000677.93339765))^((tmp = 556111951, tmp)>>(tmp = -2232569601.292395, tmp)))&(-3006386864))/x)); - assertEquals(32, x &= (-3053435209.383913)); - assertEquals(418357217, x ^= (418357185)); - assertEquals(204275, x >>= ((-1188650337.9010527)^((51494580)%(-2544545273)))); - assertEquals(982392804, x += (((x+(((tmp = -982596937.9757051, tmp)+x)%(-2298479347)))^((((tmp = 1610297674.0732534, tmp)>>>x)*(((x>>(-2746780903.08599))&(-2376190704.247188))^(((20545353)/(tmp = 1468302977, tmp))-(x<<x))))>>(((-1434332028.0447056)/((tmp = 1983686888, tmp)&((tmp = 2324500847, tmp)%(394330230.6163173))))%(((-1129687479.2158055)+((-3127595161)*((-3066570223)&((tmp = 3192134577.4963055, tmp)/(-2697915283.3233275)))))+(-1112243977.5306559)))))|(x&(-2622725228)))); - assertEquals(-2735750653096133600, x *= (-2784782870.9218984)); - assertEquals(-1876329472, x |= ((((((2752866171)<<(-1681590319))/x)>>((tmp = 1451415208, tmp)>>>(1126858636.6634417)))+(((tmp = 2165569430.4844217, tmp)/x)^(((tmp = -1675421843.4364457, tmp)-(-2187743422.2866993))|x)))*x)); - assertEquals(3520612287495799000, x *= x); - assertEquals(-200278016, x |= ((((-2379590931)%((((-1558827450.833285)&x)>>(-665140792))-((tmp = -445783631.05567217, tmp)+(tmp = 93938389.53113222, tmp))))/(3103476273.734701))^x)); - assertEquals(-9178285062592.75, x *= ((2042671875.7211144)%(((tmp = 589269308.0452716, tmp)/x)<<(-130695915.9934752)))); - assertEquals(60048960, x |= (x<<x)); - assertEquals(60048960, x <<= ((((((tmp = -2793966650, tmp)/(-2882180652))&(((x<<((tmp = -384468710, tmp)+(2236162820.9930468)))>>>((((969371919)>>((tmp = -3153268403.2565875, tmp)-((((573811084)/x)^(tmp = -968372697.4844134, tmp))>>>(((-3096129189)>>x)/(tmp = 830228804.6249363, tmp)))))<<(((1243972633.3592157)|x)&((-1687610429)&(tmp = -1945063977.458529, tmp))))<<(((tmp = -217456781.37068868, tmp)-(400259171.68077815))^x)))>>>x))%(((2728450651.300167)/(((-2713666705.089135)%(tmp = 740472459, tmp))^x))|x))^x)*(-2463032364))); - assertEquals(60048960, x %= (tmp = -442107222.9513445, tmp)); - assertEquals(-1573781504, x <<= (960581227)); - assertEquals(1297, x >>>= (tmp = -1692919563, tmp)); - assertEquals(1297, x &= x); - assertEquals(-3113308397155.233, x *= (tmp = -2400391979.3024154, tmp)); - assertEquals(-3115513013486.233, x -= (2204616331)); - assertEquals(-3113809649082.233, x -= (-1703364404)); - assertEquals(0, x >>>= (((-1181206665)-(550946816.586771))|(tmp = -2346300456, tmp))); - assertEquals(0, x %= (tmp = 1649529739.2785435, tmp)); - assertEquals(0, x ^= ((tmp = -2452761827.2870226, tmp)%(((1090281070.5550141)/(tmp = 992149154.6500508, tmp))*(x<<((((((x>>>x)|((tmp = -2410892363, tmp)%(tmp = 2585150431.0231533, tmp)))/x)*(tmp = 1541294271, tmp))+x)&((97566561.77126992)&((((-640933510.1287451)&(((((x>>>((-1821077041)<<((tmp = -1138504062.093695, tmp)-(tmp = -181292160, tmp))))%x)-(x>>((x&(((tmp = 1067551355, tmp)/(x|(1004837864.8550552)))&(x-(-103229639.25084043))))&((tmp = 2064184671.210937, tmp)+((((tmp = -2245728052, tmp)|(1538407002.8365717))+(x<<((x>>((76549490)/(tmp = 628901902.6084052, tmp)))<<((x<<x)^(-1907669184)))))+(-1409123688))))))>>>((((-1911547456.933543)-((-512313175)+((tmp = -2620903017, tmp)^(tmp = 2148757592.244808, tmp))))<<((-1740876865)>>>x))+((tmp = 691314720.9488736, tmp)<<(614057604.4104803))))|(x^((tmp = -3040687.291528702, tmp)/(x^(((x+(-2899641915))^((tmp = -1220211746, tmp)/x))%x))))))^(tmp = 119850608, tmp))%(2091975696)))))))); - assertEquals(291273239, x -= (tmp = -291273239, tmp)); - assertEquals(2206394018, x += (1915120779)); - assertEquals(235641480, x <<= (x&(x&(-1810963865.1415658)))); - assertEquals(28764, x >>= ((tmp = -1927011875, tmp)^((tmp = -1986461808, tmp)|((-868139264.8399222)*((421956566)%(3068424525)))))); - assertEquals(-99780626900900, x *= ((tmp = -1512869526.3223472, tmp)+(tmp = -1956071751, tmp))); - assertEquals(51218520, x &= (((-2353401311)>>>x)-(2216842509))); - assertEquals(51218520, x >>>= ((tmp = -1534539302.6990812, tmp)<<x)); - assertEquals(-2147483648, x <<= (-292608644)); - assertEquals(-2147483648, x |= ((((((x<<((-2981292735)-x))>>((tmp = 2540545320.96558, tmp)&(tmp = -2343790880, tmp)))>>>((((((x^((-172697043.94487858)/((2627260337)>>(2879112814.1247935))))&(tmp = 3000943191, tmp))<<(tmp = 1094830905, tmp))-x)>>>x)>>((((tmp = 3095796200, tmp)^(x|(tmp = 1460377694, tmp)))<<(x^(tmp = -357546193, tmp)))/((2729539495)>>x))))%(tmp = 268894171.74961245, tmp))|(x>>(tmp = 2735650924, tmp)))/(-2197885357.09768))); - assertEquals(-2147483648, x |= x); - assertEquals(-1967162776824578000, x *= (tmp = 916031551, tmp)); - assertEquals(-2147483648, x &= x); - assertEquals(-457743917756973060, x *= (tmp = 213153622, tmp)); - assertEquals(0, x >>>= ((((tmp = 2930076928.480559, tmp)+(x^x))<<(tmp = -1349755597.1280541, tmp))|(x+(2865632849)))); - assertEquals(0, x <<= ((x>>x)-(x>>(-2629977861)))); - assertEquals(0, x <<= x); - assertEquals(NaN, x /= x); - assertEquals(0, x |= x); - assertEquals(0, x >>>= x); - assertEquals(749327478, x |= ((tmp = 749327478, tmp)^(x>>(tmp = 881107862, tmp)))); - assertEquals(1897869364, x += (1148541886)); - assertEquals(463347, x >>>= (tmp = -726431220, tmp)); - assertEquals(-395990542, x += (-396453889)); - assertEquals(-2824792585.1675367, x -= (2428802043.1675367)); - assertEquals(-2147483648, x <<= (tmp = -1420072385.9175675, tmp)); - assertEquals(8388608, x >>>= (-2211390680.488455)); - assertEquals(8388608, x >>= (((x/(x|(((x^(((tmp = -2175960170.8055067, tmp)|((tmp = -1964957385.9669886, tmp)/(tmp = -475033330, tmp)))&((x|((tmp = 1386597019.2014387, tmp)>>((tmp = -2406589229.8801174, tmp)+x)))<<(tmp = -844032843.8415492, tmp))))>>(x^x))|x)))-((x&((tmp = 1858138856, tmp)*(-3156357504)))%x))<<(((2046448340)+x)/(-2645926916)))); - assertEquals(8359470765396279, x *= ((tmp = 871437183.7888144, tmp)-(-125089387.17460155))); - assertEquals(0, x ^= x); - assertEquals(-303039014, x += ((tmp = -2475713214, tmp)|(-372871718.2343409))); - assertEquals(2655126577, x -= (-2958165591)); - assertEquals(1830332793, x ^= (tmp = -212161208, tmp)); - assertEquals(1830332793, x ^= (((2352454407.0126333)<<((((tmp = 3083552367, tmp)/x)-(-1243111279))-((tmp = -1669093976, tmp)%(((-757485455)-(tmp = -116051602, tmp))<<x))))>>(((((-2235071915.9536905)>>(tmp = -1284656185, tmp))-x)>>((-1807028069.7202528)>>>((x%((tmp = -3070857953.311804, tmp)+((tmp = 2759633693.441942, tmp)%((169489938)*(-1582267384)))))<<(x^((tmp = -787578860, tmp)<<x)))))>>((x/(x|(409464362)))-(tmp = -64033017, tmp))))); - assertEquals(397605933.90319204, x %= (tmp = 716363429.548404, tmp)); - assertEquals(186400, x &= (((x%(-1745754586))>>>x)<<(x&(x&((-2163627752)-((1784050895)+(((-2864781121.899456)>>>x)&x))))))); - assertEquals(186400, x %= (tmp = -423209729, tmp)); - assertEquals(186400, x <<= ((x<<(x+(1232575114.4447284)))*x)); - assertEquals(1386299, x ^= ((tmp = -1074209615, tmp)>>>(x>>>((tmp = -1456741008.2654872, tmp)>>((1724761067)>>(-2016103779.9084842)))))); - assertEquals(347302967.20758367, x -= (-345916668.20758367)); - assertEquals(1.9325619389304094, x /= (179711170.03359854)); - assertEquals(-3703324711.628227, x *= (tmp = -1916277371, tmp)); - assertEquals(-920980517031624800, x *= (tmp = 248690187.53332615, tmp)); - assertEquals(0, x &= (((tmp = -2753945953.082594, tmp)*x)-(172907186))); - assertEquals(-0, x /= (((((-2744323543.187253)>>((tmp = 2663112845, tmp)>>(((-121791600)+(x^x))*(2758944252.4214177))))|x)/(tmp = -2746716631.6805267, tmp))-x)); - assertEquals(0, x ^= ((tmp = 983113117, tmp)&((2638307333)+((((tmp = 3076361304.56189, tmp)<<(-2663410588.5895214))%((-1109962112)-(tmp = -2381021732, tmp)))%((tmp = 410559095, tmp)&x))))); - assertEquals(0, x <<= (tmp = 1510895336.5111506, tmp)); - assertEquals(0, x <<= (tmp = -1688348296.2730422, tmp)); - assertEquals(2269471424, x -= (-2269471424)); - assertEquals(-2022580224, x ^= (x%((tmp = 160999480.21415842, tmp)&x))); - assertEquals(-2077171712, x &= (tmp = 3032415014.3817654, tmp)); - assertEquals(270727, x >>>= (2973489165.1553965)); - assertEquals(270727, x |= x); - assertEquals(-1895894537, x |= ((tmp = -1895903118.129186, tmp)|x)); - assertEquals(-1895894537, x -= ((((((((3143124509)>>>(-2866190144.8724117))*((x>>((961021882)*(tmp = 2363055833.8634424, tmp)))/((2032785518)+((2713643671.3420825)>>((-447782997.0173557)*((tmp = 1174918125.3178625, tmp)*((((tmp = -541539365.548115, tmp)%(-359633101))|(1765169562.2880063))+(tmp = -2512371966.374508, tmp))))))))/x)>>(x*((((-847238927.6399388)&(857288850))%(-2427015402))^((2221426567)%(x+x)))))>>>x)<<((tmp = 2009453564.2808268, tmp)>>((2924411494)<<(x>>(tmp = -1240031020.8711805, tmp)))))%(tmp = 3118159353, tmp))); - assertEquals(0, x ^= x); - assertEquals(0, x %= (-30151583)); - assertEquals(-1035186736, x ^= ((tmp = -517593368, tmp)<<(tmp = 3216155585, tmp))); - assertEquals(49740, x >>>= x); - assertEquals(49740, x %= (640223506)); - assertEquals(388, x >>>= ((x>>(tmp = 3161620923.50496, tmp))+(2605183207))); - assertEquals(776, x += x); - assertEquals(-97905, x ^= ((((((tmp = 145447047.8783008, tmp)^(((x>>>(tmp = 3014858214.2409887, tmp))>>>(629911626.132971))>>(((x+((369309637.229408)-x))<<(-2661038814.9204755))*(x+(x%(3025191323.4780884))))))+x)*(-482550691))|(-632782135))/x)); - assertEquals(-97905, x %= ((((-492914681)-((-2508632959.269368)&(tmp = 1209318291, tmp)))>>(-723512989.459533))>>>(((-528429623.985692)&(x^(tmp = -925044503, tmp)))-(-1696531234)))); - assertEquals(9585389025, x *= x); - assertEquals(-715425728, x <<= ((583763091)<<(-1223615295))); - assertEquals(-520093696, x <<= ((tmp = -1891357699.671592, tmp)*(((tmp = 3206095739.5163193, tmp)+(-2908596651.798733))>>>((tmp = -2820415686, tmp)>>(x|((((tmp = -566367675.6250327, tmp)*(-959117054))>>((((-187457085.89686918)*x)*(tmp = -2394776877.5373516, tmp))>>>x))|(((tmp = 80478970.46290505, tmp)<<(tmp = 2173570349.493097, tmp))-(x/((-2896765964)-((x/((tmp = 198741535.7034216, tmp)%(436741457)))%(tmp = 2936044280.0587225, tmp))))))))))); - assertEquals(-2520.5909527086624, x /= ((211290893.06029093)>>(663265322))); - assertEquals(-2520.5909527086624, x %= (x^((1057915688)<<(tmp = 1914820571.1142511, tmp)))); - assertEquals(1, x >>>= (((894963408.7746166)+(tmp = -2888351666, tmp))|x)); - assertEquals(-1989841636629996300, x += ((1424670316.224575)*((-2144149843.0876865)|((((421479301.0983993)|((3082651798)^(tmp = -271906497, tmp)))>>x)+((tmp = -178372083, tmp)%x))))); - assertEquals(17935384255.088326, x /= (((((((tmp = 1168194849.2361898, tmp)>>>(-107316520.53815603))>>>(x^(((x%((x>>>(((-2456622387)/x)&((2124689803)|(((-1130151701)^(2796315158))>>x))))-((-884686033.5491502)>>>((-2371185318.5358763)&x))))+(tmp = 558422989, tmp))|((tmp = -420359120.0596726, tmp)/((-1820568437.0587764)&(2298602280.266465))))))>>(x-((tmp = -1164568978, tmp)^x)))^x)-x)+x)); - assertEquals(134233150, x &= ((x>>(((tmp = 98498118.13041973, tmp)-(804574397))/(tmp = -1564490985.7904541, tmp)))+x)); - assertEquals(4, x >>= (449610809)); - assertEquals(1912543790, x |= (1912543790)); - assertEquals(2487274263, x += (tmp = 574730473, tmp)); - assertEquals(-2140759118, x ^= (tmp = 338055333.9701035, tmp)); - assertEquals(311607367, x += (2452366485)); - assertEquals(9509, x >>= (372113647.84365284)); - assertEquals(-2001075684.1562128, x += (-2001085193.1562128)); - assertEquals(-638703280, x ^= (((tmp = 1096152237, tmp)&x)|((2707404245.0966487)-(((tmp = 1550233654.9691348, tmp)+(tmp = 2008619647, tmp))&((tmp = -2653266325, tmp)+(tmp = -280936332, tmp)))))); - assertEquals(-101811850, x |= (-2250090202)); - assertEquals(-13, x >>= ((-561312810.0218933)|(tmp = 79838949.86521482, tmp))); - assertEquals(-13, x >>= ((tmp = -936543584, tmp)/(1180727664.1746705))); - assertEquals(-1547, x *= (((tmp = 1005197689, tmp)>>>x)>>>(tmp = 34607588, tmp))); - assertEquals(2393209, x *= x); - assertEquals(2393209, x |= x); - assertEquals(0, x >>= (-2691279235.1215696)); - assertEquals(0, x *= (((896175510.4920144)*((((tmp = 1770236555.7788959, tmp)%(537168585.7310632))/x)&(tmp = 1094337576, tmp)))&(((x-x)-x)>>x))); - assertEquals(-1922620126, x ^= (-1922620126)); - assertEquals(3.43481396325761, x /= (tmp = -559745053.6088333, tmp)); - assertEquals(0, x >>= x); - assertEquals(0, x >>>= (tmp = 2106956255.6602135, tmp)); - assertEquals(-1339003770, x ^= ((tmp = 2955963526.960022, tmp)+x)); - assertEquals(-0, x *= ((((tmp = 368669994, tmp)>>>(x*x))<<(tmp = 2355889375, tmp))&(tmp = -2267550563.9174895, tmp))); - assertEquals(0, x >>= (753848520.8946902)); - assertEquals(0, x >>>= x); - assertEquals(0, x %= ((tmp = -2872753234.2257266, tmp)|x)); - assertEquals(NaN, x %= (x>>>(tmp = 890474186.0898918, tmp))); - assertEquals(NaN, x %= ((tmp = 1341133992.284471, tmp)&(tmp = -2979219283.794898, tmp))); - assertEquals(NaN, x += (-2865467651.1743298)); - assertEquals(NaN, x += ((-1424445677)%(x^(tmp = 1150366884, tmp)))); - assertEquals(0, x &= (x+((tmp = 1499426534, tmp)+x))); - assertEquals(0, x |= (((((tmp = -2413914642, tmp)<<((x>>>x)^(1218748804)))+((((-1085643932.2642736)-(-1199134221.533854))>>(tmp = 2148778719, tmp))-((tmp = 1589158782.0040946, tmp)/(tmp = -2485474016.1575155, tmp))))>>>(x>>x))/(2230919719))); - assertEquals(0, x %= ((tmp = -2576387170.517563, tmp)>>>((tmp = -2362334915.919525, tmp)>>>(((3096453582)-(700067891.4834484))^(2396394772.9253683))))); - assertEquals(-1798103432, x ^= (((((tmp = 2396144191, tmp)*(x>>>(1512158325)))&(((-1256228298.5444434)&(((-2963136043.434966)&((tmp = 2472984854, tmp)+(tmp = -454900927, tmp)))%(tmp = 484255852.65332687, tmp)))>>((x%x)-x)))&(tmp = 929723984, tmp))^(tmp = -1798103432.5838807, tmp))); - assertEquals(-2137913344, x &= ((((x|(-2970116473))&(((x/x)/((tmp = 2853070005, tmp)>>>x))%(((tmp = -3123344846, tmp)/((2224296621.6742916)-(tmp = -2246403296.455411, tmp)))+((x&(((x^(x*(2829687641)))+x)&(tmp = 988992521, tmp)))^x))))<<((((-820608336)^(tmp = 2851897085, tmp))>>(tmp = -402427624, tmp))>>>x))-(((x*(((-2287402266.4821453)%(tmp = -520664172.1831205, tmp))^(x/(1875488837))))<<(tmp = 402393637, tmp))&(tmp = 1576638746.3047547, tmp)))); - assertEquals(-2827557853031924000, x *= (tmp = 1322578326.6507945, tmp)); - assertEquals(6.424459501778244e+27, x *= (tmp = -2272087729.3065624, tmp)); - assertEquals(-1586887483, x |= (-1586887483)); - assertEquals(-567868980691736100, x *= (tmp = 357850816, tmp)); - assertEquals(1489101591, x ^= (x%(x|(421921075)))); - assertEquals(-801213804822328000, x *= (x|(-672326904.6888077))); - assertEquals(612257233.6612054, x /= (((tmp = -350127617, tmp)>>>(-1140467595.9752212))<<((x^x)+(-3117914887)))); - assertEquals(19097.231243331422, x /= ((x^(tmp = -570012517, tmp))>>>x)); - assertEquals(0, x >>= ((x%(((-2347648358)%((x-(tmp = -456496327, tmp))|(x^(-1977407615.4582832))))<<(x/(tmp = -2021394626.214082, tmp))))%(tmp = -949323000.2442119, tmp))); - assertEquals(0, x <<= x); - assertEquals(NaN, x %= (x^(x>>(((tmp = 597147546.7701412, tmp)&(((((-972400689.6267757)|(tmp = -2390675341.6367044, tmp))|(tmp = 1890069123.9831812, tmp))<<(((1606974563)-(tmp = -2211617255.8450356, tmp))&((((x+((2433096953)&(-2527357746.681596)))*(tmp = -313956807.55609417, tmp))|((tmp = -2146031047.968496, tmp)/(tmp = 2851650714.68952, tmp)))>>(((tmp = 2630692376.6265225, tmp)-(tmp = -3162222598, tmp))>>((tmp = 1915552466, tmp)*(x>>>(-2413248225.7536864)))))))&(x%((((1218471556)|x)+(tmp = -849693122.6355379, tmp))+x))))>>>(x/((tmp = 689889363, tmp)/x)))))); - assertEquals(0, x >>>= (45649573.23297)); - assertEquals(0, x >>>= (tmp = 1084439432.771266, tmp)); - assertEquals(NaN, x /= x); - assertEquals(NaN, x *= (tmp = 1642750077, tmp)); - assertEquals(0, x >>>= (tmp = -1944001182.0778434, tmp)); - assertEquals(1682573000, x |= (tmp = -2612394296.2858696, tmp)); - assertEquals(3041823595, x -= (((tmp = 720576773, tmp)|(x^(-1068335724.2253149)))>>(x*(-2501017061)))); - assertEquals(6083647190, x += x); - assertEquals(-6536258988089986000, x *= ((tmp = 632312939.6147232, tmp)|((-1621821634)+(((tmp = -2281369913.562131, tmp)&((tmp = -381226774, tmp)|x))&(664399051))))); - assertEquals(4.272268155938712e+37, x *= x); - assertEquals(733271152, x %= (-1345127171)); - assertEquals(847089925, x ^= (tmp = 432620917.57699084, tmp)); - assertEquals(1337073824, x <<= x); - assertEquals(-25810602, x ^= (tmp = 2982414838, tmp)); - assertEquals(-25282209, x |= ((tmp = -2927596922, tmp)>>>(-2404046645.01413))); - assertEquals(639190091919681, x *= x); - assertEquals(173568320, x &= ((((tmp = -718515534.4119437, tmp)&(tmp = 2989263401, tmp))<<x)|((tmp = 537073030.5331153, tmp)-(tmp = 883595389.314624, tmp)))); - assertEquals(0, x -= x); - assertEquals(0, x >>>= (tmp = -1844717424.917882, tmp)); - assertEquals(0, x >>= (tmp = -462881544.2225325, tmp)); - assertEquals(0, x >>= x); - assertEquals(-1868450038, x ^= (2426517258.6111603)); - assertEquals(1, x /= x); - assertEquals(1175936039.4202638, x += (tmp = 1175936038.4202638, tmp)); - assertEquals(-127916015, x ^= ((x/(1841969600.3012052))-(tmp = 1099467723, tmp))); - assertEquals(395713785658171900, x *= (-3093543726)); - assertEquals(395713787128560900, x += (((((-717204758)*(tmp = -588182129.6898501, tmp))-x)+(tmp = 20638023, tmp))^x)); - assertEquals(-962609355, x |= ((x^(-3118556619.912983))<<((tmp = 876126864, tmp)&x))); - assertEquals(-962609355, x %= (tmp = -2079049990, tmp)); - assertEquals(-114583755, x -= (((-2806715240)&(((1961136061.0329285)>>>((2087162059)*x))+((tmp = -1890084022.7631018, tmp)%(tmp = 2137514142.358262, tmp))))+(x<<(tmp = 2991240918, tmp)))); - assertEquals(-425721856, x <<= x); - assertEquals(3778560, x >>>= ((x|(3198503572))>>(1158434541.1099558))); - assertEquals(3778560, x %= (tmp = -2592585378.9592104, tmp)); - assertEquals(624640, x &= (tmp = 2261638192.9864054, tmp)); - assertEquals(1249280, x += x); - assertEquals(1048576, x &= ((tmp = -2144301819.9892588, tmp)^((x-x)<<x))); - assertEquals(2097152, x <<= (x/x)); - assertEquals(5069061551149729, x *= (tmp = 2417116904.8069615, tmp)); - assertEquals(1.4836296666029616e+25, x += ((tmp = 2926833006.7121572, tmp)*x)); - assertEquals(-256, x >>= ((-469330345.3589895)%((x^(((2554170843.4978285)/(2495676674.815263))>>>x))*(-918892963)))); - assertEquals(-134217728, x <<= (x|(((((1687450853.1321645)+(tmp = 2369533014.5803776, tmp))+(tmp = -2613779445, tmp))+(tmp = -2488826226.3733397, tmp))>>(tmp = -220646936.41245174, tmp)))); - assertEquals(704164545131708400, x *= ((-2632786741)+(-2613647956))); - assertEquals(9216, x >>>= (-1925405359.657349)); - assertEquals(4491403261551.008, x *= (tmp = 487348444.1787118, tmp)); - assertEquals(4490606381829.008, x -= (tmp = 796879722, tmp)); - assertEquals(-60294056, x >>= x); - assertEquals(-3193966580.494005, x += (tmp = -3133672524.494005, tmp)); - assertEquals(550500358, x >>>= ((tmp = -2779637628.390116, tmp)-((tmp = 29230786.984039664, tmp)%(tmp = -310649504.7704866, tmp)))); - assertEquals(68812544, x >>= (-1347584797)); - assertEquals(1.2120221595741834e-11, x /= ((2791020260)*((((1964870148.6358237)^x)|(-3082869417))-((x^x)&((1234292117.8790703)<<(-1792461937.2469518)))))); - assertEquals(1.2120221595741834e-11, x %= (x-(2780439348))); - assertEquals(-1421552183, x |= (tmp = -1421552183.5930738, tmp)); - assertEquals(-1420954119, x |= ((((-2547788562.5735893)<<x)%(435385623))>>(x|x))); - assertEquals(1, x /= x); - assertEquals(1, x >>= (x>>>(((2975715011.501709)-(tmp = -1473273552.981069, tmp))/(1654883913.042487)))); - assertEquals(-65382, x ^= ((x/((tmp = -2780026200, tmp)<<x))^(((-2683084424)<<x)>>(-1716245874)))); - assertEquals(1530921106, x &= (1530940914)); - assertEquals(1, x /= x); - assertEquals(0, x >>= x); - assertEquals(0, x /= (tmp = 773741434.1972584, tmp)); - assertEquals(0, x |= x); - assertEquals(0, x <<= (-67977514.99888301)); - assertEquals(0, x %= (2496550482.524729)); - assertEquals(-0, x /= (tmp = -515040417, tmp)); - assertEquals(0, x <<= (-1673460935.2858837)); - assertEquals(-2638209488, x += (-2638209488)); - assertEquals(-2400951839498683400, x *= (910068685)); - assertEquals(1600582036, x ^= (((-1247602308.4812562)>>(((-2393714444.179732)>>>x)%(-778140635.7165127)))+(-1933914727.2268424))); - assertEquals(0, x *= ((x-x)>>(-1270234575))); - assertEquals(0, x >>>= (tmp = 3193676327.493656, tmp)); - assertEquals(0, x ^= (x>>>(1148676785.389884))); - assertEquals(0, x >>= (tmp = -2269181763.8663893, tmp)); - assertEquals(0, x >>= (3149450221)); - assertEquals(0, x >>= (1069630750)); - assertEquals(-625009654, x ^= ((-2143499112)%(-759244728.6214335))); - assertEquals(3583943, x >>>= (-2942645558.1204453)); - assertEquals(1791971, x >>= (x/x)); - assertEquals(223996, x >>= x); - assertEquals(6999, x >>= (tmp = -1051883611.9443719, tmp)); - assertEquals(1459617792, x <<= (-1572314984)); - assertEquals(2622356453.269262, x -= (tmp = -1162738661.2692618, tmp)); - assertEquals(5103676461.269262, x += (2481320008)); - assertEquals(823989684.2692623, x %= (x^(((((1048362966)*((tmp = -2423040747.6233954, tmp)>>>x))*((tmp = 2330818588.4081, tmp)>>(tmp = 103312020.98346841, tmp)))+(tmp = 2264492857.144133, tmp))>>>((tmp = 2523442834, tmp)<<x)))); - assertEquals(0, x >>>= (tmp = -2018700898.531027, tmp)); - assertEquals(NaN, x /= x); - assertEquals(0, x <<= (tmp = -2489442223, tmp)); - assertEquals(0, x >>= ((3045836220)>>>x)); - assertEquals(-1156905149, x ^= (3138062147)); - assertEquals(-0, x %= x); - assertEquals(-3118433907.512866, x -= ((tmp = 1338611238, tmp)-(-1779822669.5128663))); - assertEquals(100679693, x &= (1040565279)); - assertEquals(10136400582574248, x *= x); - assertEquals(0, x %= x); - assertEquals(2400318405, x += (2400318405)); - assertEquals(1.0036190808578471, x /= (((tmp = -2313492253.9889445, tmp)|(x-((tmp = -205459123, tmp)>>x)))+x)); - assertEquals(0, x >>>= (tmp = 882343227.1675215, tmp)); - assertEquals(0, x &= ((tmp = 2307828832.2706165, tmp)^((((((1404388047)<<((807879382)-(-2862921873)))-x)*(tmp = -1897734732, tmp))>>(tmp = 1981888881.2306776, tmp))%x))); - assertEquals(0, x <<= x); - assertEquals(0, x *= (((x*x)*((((2764801384.171454)%(x>>>x))&(384818815))+(x>>(tmp = -1481683516, tmp))))&x)); - assertEquals(0, x >>= (tmp = -2202536436, tmp)); - assertEquals(0, x ^= x); - assertEquals(0, x &= (tmp = 15161124, tmp)); - assertEquals(-1586110900, x ^= (-1586110900)); - assertEquals(-1586127952, x -= ((tmp = 560737212, tmp)%((1349529668)>>>(tmp = -1956656528, tmp)))); - assertEquals(-1174945870, x -= ((1178456190)|x)); - assertEquals(1335167624.3422346, x -= (tmp = -2510113494.3422346, tmp)); - assertEquals(1329952126.3422346, x -= (x>>x)); - assertEquals(1, x >>= x); - assertEquals(3, x |= (x<<x)); - assertEquals(3, x -= (x-x)); - assertEquals(-1938525669, x |= (tmp = 2356441625.5128202, tmp)); - assertEquals(-1938525669, x ^= ((tmp = -197149141.3622346, tmp)/(2833823156))); - assertEquals(-2.6292393147661324, x /= (737295254.2254335)); - assertEquals(2925975987.370761, x -= (-2925975990)); - assertEquals(2925975987.370761, x %= (tmp = 3041184582.8197603, tmp)); - assertEquals(-1908068660, x ^= ((tmp = -1380575181, tmp)-(2375164084.8366547))); - assertEquals(-477017165, x >>= (tmp = 2420877826.353099, tmp)); - assertEquals(-477017165, x %= ((tmp = -2919204062.3683634, tmp)-(tmp = -2263328990, tmp))); - assertEquals(-2105539936, x &= ((tmp = -1630795440, tmp)-(x&((933423833)>>(-475069901))))); - assertEquals(-4979480720, x -= (tmp = 2873940784, tmp)); - assertEquals(-4190953472, x -= (x&(tmp = -645918862.9001305, tmp))); - assertEquals(17564091004468855000, x *= x); - assertEquals(-857277134, x |= (tmp = 2363948338, tmp)); - assertEquals(1015632515, x -= (-1872909649)); - assertEquals(-1150380043, x ^= (tmp = -2014853770, tmp)); - assertEquals(1607729152, x <<= ((2194449589)+(x|(tmp = -1470075256.4605722, tmp)))); - assertEquals(1608356496, x |= ((((x|(670426524))<<((-2415862218)>>(tmp = 1572561529.9213061, tmp)))^((-1989566800.3681061)|x))&(2170270618.3401785))); - assertEquals(-1836056576, x <<= (tmp = 2906301296.540217, tmp)); - assertEquals(-2952415961567723500, x *= (tmp = 1608020145, tmp)); - assertEquals(1435500544, x <<= x); - assertEquals(700928, x >>>= (tmp = 2924829771.1804566, tmp)); - assertEquals(0, x <<= ((x^(2410009094))|(((-164334714.18698573)%(x*x))|(tmp = 2182431441.2575436, tmp)))); - assertEquals(-143321285, x ^= (tmp = -143321285, tmp)); - assertEquals(-2, x >>= x); - assertEquals(-1, x >>= (x&(1109737404))); - assertEquals(1, x >>>= x); - assertEquals(0, x ^= x); - assertEquals(-2463707358.165766, x += (-2463707358.165766)); - assertEquals(1831259938, x >>= (((((x-(tmp = 1359448920.5452857, tmp))%(tmp = -104541523, tmp))/((3133289055.9780197)*x))>>x)%x)); - assertEquals(1858895646, x ^= ((tmp = 131424376, tmp)>>(tmp = -396761023, tmp))); - assertEquals(1, x >>= x); - assertEquals(-1888369021, x |= ((tmp = -2038869285.046599, tmp)^((tmp = -1318286592.4250565, tmp)-(tmp = 2825123496, tmp)))); - assertEquals(1036458508, x <<= ((tmp = 2722401450, tmp)/((tmp = 1090712291, tmp)>>((tmp = -2155694696.9755683, tmp)*(tmp = 1661107340, tmp))))); - assertEquals(1, x /= (x%((tmp = -1716050484, tmp)+(tmp = -1683833551.797319, tmp)))); - assertEquals(0, x >>= (tmp = -2899315628, tmp)); - assertEquals(0, x |= x); - assertEquals(0, x >>>= x); - assertEquals(0, x <<= x); - assertEquals(1546062911, x |= (1546062911)); - assertEquals(1546195271, x += ((tmp = -3210667091, tmp)>>(tmp = 1323121165, tmp))); - assertEquals(3092390542, x += x); - assertEquals(-1199626354, x |= (406783756)); - assertEquals(-3650317194584908300, x *= (tmp = 3042878461.625484, tmp)); - assertEquals(-7.650495675092354e+27, x *= (2095844078)); - assertEquals(0, x >>= (tmp = 342617880.3384919, tmp)); - assertEquals(22, x ^= (((tmp = 381409558.9104688, tmp)>>((2823172888.974557)>>x))>>x)); - assertEquals(736383550, x += (736383528)); - assertEquals(0, x %= x); - assertEquals(0, x += x); - assertEquals(-1553157831, x -= (1553157831)); - assertEquals(1838556960, x <<= (3158944357.262641)); - assertEquals(5503285699.188747, x *= ((tmp = 2437440276, tmp)/(814308583.8128904))); - assertEquals(5824889900.188747, x -= (((tmp = 1171445694, tmp)-(tmp = -1584666956, tmp))^(tmp = 1217545373, tmp))); - assertEquals(747032, x >>>= (-89332085)); - assertEquals(747032, x |= (x^(x^(x>>>x)))); - assertEquals(747032, x >>>= ((-1558482440)*((tmp = -2413907480, tmp)+(3003996862.384156)))); - assertEquals(7.747761349084291e+23, x += ((tmp = 518064022.64624584, tmp)*((tmp = 2001951702, tmp)*x))); - assertEquals(0, x <<= (2769324707.5640426)); - assertEquals(NaN, x %= (((((((-2458056470.7717686)&x)>>(tmp = -361831232.42602444, tmp))*(2611108609.6727047))>>>x)/(-1713747021.8431413))*(-1143281532))); - assertEquals(NaN, x %= ((x^((-613836813)*(tmp = -3180432597.0601435, tmp)))%x)); - assertEquals(NaN, x /= ((-1607092857)^x)); - assertEquals(0, x &= (-1190719534)); - assertEquals(0, x >>>= x); - assertEquals(0, x += (x>>(642177579.1580218))); - assertEquals(-3129552333, x += (-3129552333)); - assertEquals(1165414963, x &= x); - assertEquals(2222, x >>= (((tmp = 2606317568, tmp)|x)+(tmp = 1844107136, tmp))); - assertEquals(NaN, x %= ((x^x)<<(x/(((tmp = -1362148700, tmp)&((tmp = 76371048, tmp)<<x))>>>((x^(-2605741153))>>(((tmp = -2131608159.7634726, tmp)|(((2827792229.8004875)|(((-848439251)+(-2576768890.123433))|((tmp = -2617711776, tmp)-((-199980264)&((tmp = -46967951.76266599, tmp)/(-733253537))))))*(tmp = 1820087608, tmp)))>>>(tmp = -3118359396.4298744, tmp))))))); - assertEquals(NaN, x /= ((2144871731)*x)); - assertEquals(NaN, x *= x); - assertEquals(NaN, x %= (tmp = 234811462.08692443, tmp)); - assertEquals(0, x >>>= ((1121416685)|(x^(((tmp = -2905413334, tmp)<<(tmp = -3091554324.030834, tmp))<<x)))); - assertEquals(-55938048, x |= ((tmp = -55938048, tmp)+(x*(tmp = -1518809027.2695136, tmp)))); - assertEquals(-3.3234995678333864e-10, x /= (x*(tmp = -3008876576, tmp))); - assertEquals(0, x <<= (x/((((((-2168824234.2418427)>>(((tmp = 1976810951, tmp)%x)<<(x*(x>>(x%(3146266192))))))%(tmp = 1756971968.122397, tmp))>>>(-2859440157.8352804))/(-1001406.1919288635))>>>(-1358031926)))); - assertEquals(-0, x *= (tmp = -1756000533, tmp)); - assertEquals(-0, x %= (2522761446.869926)); - assertEquals(0, x >>>= (((1087690535)>>>(2741387979))^x)); - assertEquals(0, x -= x); - assertEquals(0, x >>= (-819422694.2188396)); - assertEquals(0, x ^= x); - assertEquals(NaN, x /= x); - assertEquals(0, x &= (tmp = 86627723, tmp)); - assertEquals(0, x += x); - assertEquals(0, x %= (tmp = -2317915475, tmp)); - assertEquals(Infinity, x += (((-3072799584)^(-2487458319))/(((tmp = -3050692353, tmp)&x)>>(-777977292.8500206)))); - assertEquals(Infinity, x += x); - assertEquals(Infinity, x -= (tmp = 484428269, tmp)); - assertEquals(Infinity, x *= x); - assertEquals(Infinity, x /= (2059586218.2278104)); - assertEquals(Infinity, x *= (tmp = 415918523.8350445, tmp)); - assertEquals(-1800869091, x |= (((-1800869091)>>>(x>>>(tmp = -2832575051, tmp)))>>>x)); - assertEquals(6196126991451132000, x *= ((-1467292383.8458765)+(-1973339154.7911158))); - assertEquals(6196126992684649000, x += (1233517421)); - assertEquals(1, x /= x); - assertEquals(-7153809722216516000, x -= (((-2984550787.146106)<<(tmp = 743743974, tmp))*((3155151275)/((-1771412568.8965073)%x)))); - assertEquals(-7153809721471491000, x -= (-745024056)); - assertEquals(5.117699353102001e+37, x *= x); - assertEquals(0, x >>= x); - assertEquals(-0, x *= ((-2651785447.666973)<<(-1124902998))); - assertEquals(-0, x /= (2119202944)); - assertEquals(1042673805.5205957, x -= ((x<<x)-(tmp = 1042673805.5205957, tmp))); - assertEquals(62, x >>>= (tmp = 2769597912.977452, tmp)); - assertEquals(34, x &= ((tmp = -61541150, tmp)%(x^(-943160469)))); - assertEquals(34, x ^= ((-2625482224.4605474)<<(-2277806338.3461556))); - assertEquals(536870912, x <<= ((-2373927426.4757633)^x)); - assertEquals(536870912, x &= x); - assertEquals(512, x >>>= ((-1626769708.310139)<<((tmp = 641796314, tmp)/(721629637.3215691)))); - assertEquals(0, x <<= (-113973033)); - assertEquals(NaN, x /= x); - assertEquals(NaN, x += (-1602711788.2390788)); - assertEquals(NaN, x *= (x%x)); - assertEquals(0, x &= (x<<(x|(x>>((x>>>(x%((1182960050)^(((-220896609)-((((tmp = 1518275435.360103, tmp)/(tmp = -88234820, tmp))^x)/x))>>(3169930777.548236)))))-(tmp = -2912668817.662395, tmp)))))); - assertEquals(0, x *= ((2323969408.7524366)/(((tmp = -3089229853, tmp)>>>((((tmp = -1012580544.5631487, tmp)>>(1138049418.9023373))>>x)&x))*(tmp = 626912001, tmp)))); - assertEquals(0, x >>>= x); - assertEquals(NaN, x /= (x%(-868024322))); - assertEquals(NaN, x /= (tmp = -1749532322, tmp)); - assertEquals(1861918711, x |= (-2433048585.853014)); - assertEquals(1861918711, x >>= (((102451747)>>>((((241651917.47259736)/((((((((1759022236)^(tmp = -2592022722, tmp))+((-1748044969)>>>(704597925)))/(-1639604842))%((1349846853.7345295)<<(-729695861)))/(x>>((tmp = -2654474404.7365866, tmp)>>x)))>>>(((-480356478)|(x%((tmp = -1668269244.6979945, tmp)+(tmp = -2441424458.565183, tmp))))^((1634981212.7598324)>>>(tmp = 122455570.22000062, tmp))))<<x))*((tmp = -1058636137.5037816, tmp)+((2794083757.138838)&((x/(50081370))&x))))/x))/((tmp = -243106636, tmp)<<((x*((tmp = -648475219.5971704, tmp)>>((tmp = -1568913034, tmp)-((tmp = 911458615, tmp)|x))))>>>(tmp = 2714767933.920696, tmp))))); - assertEquals(0, x ^= x); - assertEquals(-2080484602, x |= (((1544771831.4758213)|x)^(-538113039))); - assertEquals(696451072, x <<= (tmp = -1587032689, tmp)); - assertEquals(-162595645, x += (tmp = -859046717, tmp)); - assertEquals(516546456, x >>>= x); - assertEquals(623083588, x += ((-1371850352)^(tmp = -1469933252, tmp))); - assertEquals(92342412, x %= (tmp = -132685294, tmp)); - assertEquals(500272110, x |= ((tmp = 1616032506, tmp)%((tmp = 1589569590.4269853, tmp)|(-972791738.1829333)))); - assertEquals(3247086, x %= (((tmp = 1372216208, tmp)|(-638950076.3387425))&((-2619249161.849716)&(73957896)))); - assertEquals(0, x >>>= (tmp = -1482343462.6911879, tmp)); - assertEquals(1265125662, x ^= (tmp = -3029841634, tmp)); - assertEquals(4941897, x >>>= (-2039728632)); - assertEquals(206857, x &= (tmp = 226962365.45571184, tmp)); - assertEquals(1.0925018562586405e+24, x += ((tmp = 2687424146, tmp)*(((-1998020319)%x)*(-2080331363)))); - assertEquals(-1.755270751212437e+32, x *= (-160665242)); - assertEquals(0, x <<= (3152796521.6427975)); - assertEquals(0, x ^= ((((((tmp = -855001595, tmp)<<(2007525777))-(x-(x-x)))/(3036585090.9701214))&(1827983388))*((tmp = -915604789.0515733, tmp)&(((((tmp = -806628722.7820358, tmp)%x)/(tmp = -2773117447, tmp))|x)<<(((tmp = -2902300974.7300634, tmp)|x)/(-1608133440)))))); - assertEquals(0, x |= ((((((119024954)*(((x^(tmp = 2939514414, tmp))|x)^(x-(tmp = -1597415597.6795669, tmp))))+(((tmp = -182277816.14547157, tmp)<<(((-2983451324.3908825)^(tmp = 1572568307, tmp))+(-1165604960.8619013)))/(x>>((tmp = -2127699399, tmp)>>((x^(((((tmp = -1968667383, tmp)^(tmp = 3120052415.9964113, tmp))|(((x|(((x^((tmp = 2831505153, tmp)<<((-3150506831.547093)+((x%(tmp = 383761651, tmp))%(2856803457)))))+(((tmp = -2426953997, tmp)^(tmp = -2667954801.1010714, tmp))*(tmp = -2707801631, tmp)))&(tmp = 2082935238.794707, tmp)))^((tmp = 697573323.5349133, tmp)-x))%(tmp = 661936357, tmp)))/(-1717944600.261446))>>>((2423776015.0968056)^((-1410322010)|((x<<(tmp = 2935993226, tmp))/(tmp = -1533896392, tmp))))))*(tmp = -596675330, tmp))))))>>>(((2944268153)^(x&(144579050.93126357)))/(-2123810677.2619643)))>>>(1473040195.9009588))*x)); - assertEquals(0, x /= (2877666495)); - assertEquals(2174852514, x -= (tmp = -2174852514, tmp)); - assertEquals(543713128, x >>>= x); - assertEquals(2978128878.939105, x += (tmp = 2434415750.939105, tmp)); - assertEquals(3529591145844655600, x *= (tmp = 1185170719.3753138, tmp)); - assertEquals(659, x >>>= ((((((x<<(((((-425423078)/(((tmp = 160617689.20550323, tmp)&(-1524740325.5003028))%(tmp = -1869426475, tmp)))<<(((x^(-487449247))>>>(tmp = -1962893666.7754712, tmp))%x))*x)>>((tmp = 623413085, tmp)&(x+(((((-2200726309.083274)-(x-x))+x)&(-1304849509))|((((tmp = -431896184, tmp)>>>(x>>(-1932126133)))<<((1078543321.2196498)*(-10761352)))>>(tmp = -2681391737.5003796, tmp)))))))/x)-(tmp = -1768629117, tmp))/(((((tmp = -2320718566.0664535, tmp)%x)+(-2831503351.995921))>>>(-2695416841.3578796))*(943979723)))<<x)|((652520546.7651662)>>(1045534827.6806792)))); - assertEquals(531, x &= (tmp = -293707149, tmp)); - assertEquals(0, x >>= (tmp = -678056747.5701449, tmp)); - assertEquals(1184651529.8021393, x += (tmp = 1184651529.8021393, tmp)); - assertEquals(1721719611, x |= (tmp = 1645413178, tmp)); - assertEquals(-406880257, x |= (tmp = 2268544460, tmp)); - assertEquals(-4194304, x <<= (tmp = -109701322.43455839, tmp)); - assertEquals(17592186044416, x *= x); - assertEquals(0, x ^= (x&x)); - assertEquals(0, x <<= (tmp = 1715401127, tmp)); - assertEquals(-1793087394, x |= (tmp = -1793087394.730585, tmp)); - assertEquals(-2, x >>= x); - assertEquals(263607360.10747814, x += (tmp = 263607362.10747814, tmp)); - assertEquals(1073214955, x |= (893759979.3631718)); - assertEquals(703953930, x -= ((2738450011)%(x^(tmp = 679402836, tmp)))); - assertEquals(1, x >>= (tmp = 2262515165.6670284, tmp)); - assertEquals(0, x >>= (((tmp = 747896494, tmp)^((tmp = -1005070319, tmp)+x))|x)); - assertEquals(0, x >>= ((953612771)>>>(tmp = 3066170923.3875694, tmp))); - assertEquals(-314941454, x -= (x+(((314941454)%(((tmp = 2200222912.9440064, tmp)>>>(2534128736.805429))>>>(x|((747716234)%(((tmp = -252254528, tmp)%(-1553513480.1875453))&x)))))<<x))); - assertEquals(-535686958, x &= (-522809126)); - assertEquals(0.5480312086215239, x /= (tmp = -977475278, tmp)); - assertEquals(-1199953459.6090598, x *= ((-2189571393)+((3186862741.37774)>>(tmp = -2193090564.5026345, tmp)))); - assertEquals(-1199953459.6090598, x %= ((tmp = 2986532440, tmp)*(2685122845))); - assertEquals(-1199953459.6090598, x %= (1951182743.7399902)); - assertEquals(51262285383887820, x *= (-42720228)); - assertEquals(-424776752, x |= x); - assertEquals(166221344210236600, x *= (tmp = -391314598.6158786, tmp)); - assertEquals(-1883425600, x >>= (((tmp = -1020679296, tmp)^((-1416867718)+(-1412351617)))<<(-2743753169))); - assertEquals(0, x &= (x/(-2250026610))); - assertEquals(-1111956501, x ^= (tmp = 3183010795, tmp)); - assertEquals(2012059503, x ^= (tmp = -900369276, tmp)); - assertEquals(15719214, x >>>= (tmp = -3196277049, tmp)); - assertEquals(15719214, x |= x); - assertEquals(100779035, x -= ((-1245802025)^(-2964289852))); - assertEquals(0, x >>= x); - assertEquals(0, x &= (((x<<((2361941389.708063)%x))>>((328256762.09842086)>>>((((tmp = 3094192285, tmp)-(((x>>(tmp = -2920437464, tmp))<<(tmp = -2693021467, tmp))-(x>>>((2410065554)%(x%(tmp = 2487056196.689908, tmp))))))-(tmp = -866314146, tmp))^((1754098471)-((((((-2450740191)-(tmp = 1977885539.6785035, tmp))*((tmp = -1205431332, tmp)>>>x))>>(-870601854))>>(tmp = -301859264, tmp))|((tmp = -2308971516.8301244, tmp)/x))))))&((2307007357)-((tmp = -1518812934, tmp)+(2562270162))))); - assertEquals(0, x <<= x); - assertEquals(-1802124619, x |= (-1802124619)); - assertEquals(-1802124619, x %= ((1617132364.306333)+((1678465962.079633)|((516698570)%(((569813606)*(-1800804098.6270027))%((tmp = 1976706935, tmp)-((tmp = -1830228989.5488424, tmp)>>(((x^((tmp = 1015246068.3791624, tmp)>>x))^((-2171682812.246772)-(tmp = -398330350, tmp)))&x)))))))); - assertEquals(904564673.6237984, x -= (tmp = -2706689292.6237984, tmp)); - assertEquals(818237248768128900, x *= x); - assertEquals(254842325.2585001, x %= (1550087667.9657679)); - assertEquals(-1163919360, x <<= x); - assertEquals(-3.4644526843674166, x /= ((-446801454)+(x>>>(tmp = -2025151870, tmp)))); - assertEquals(0, x &= ((((((((-1739617728)&(x&(((tmp = -2946470036.552597, tmp)/x)*x)))^(-1130501404))>>>x)/((1870230831)>>>(840301398)))%x)/x)/(-2927537567))); - assertEquals(0, x >>= x); - assertEquals(0, x >>>= (x&(x&x))); - assertEquals(0, x &= ((-579614044)-(-756012505.4048488))); - assertEquals(-2970367642, x -= (tmp = 2970367642, tmp)); - assertEquals(-415129376, x ^= (tmp = 2847041926.060355, tmp)); - assertEquals(-1505681312, x &= (tmp = -1225184902.9215767, tmp)); - assertEquals(-3174471329.5807734, x += (-1668790017.5807734)); - assertEquals(-Infinity, x /= (x>>x)); - assertEquals(NaN, x -= x); - assertEquals(0, x ^= (x^(((-1407936301.5682082)<<((x^(((tmp = 3213446217.307076, tmp)|x)|((tmp = 3219810777.3171635, tmp)/(tmp = 1561807400, tmp))))>>>((tmp = 2449910203.0949173, tmp)|((((1954662538.7453175)>>(tmp = -1711636239.9916713, tmp))>>>(tmp = 406219731.214718, tmp))<<(((-907908634.4609842)^((((((tmp = 2408712345, tmp)*(tmp = 1740346634.5154347, tmp))>>(tmp = 715783991, tmp))^(tmp = -655628853.2821262, tmp))%(tmp = 2819143280.434571, tmp))/(-1240412852)))*x)))))/x))); - assertEquals(0, x >>>= x); - assertEquals(0, x <<= x); - assertEquals(0, x >>>= (((-3198075268.8543105)>>(((((x+((tmp = -133461401.50823164, tmp)-((x&(((((tmp = 2617977319, tmp)>>((tmp = -2704719576.8734636, tmp)|((tmp = -977362542.2423751, tmp)<<(x<<(tmp = 3054487697.1441813, tmp)))))>>>((-1635655471)%x))/(-2079513672))%(tmp = 1993563806, tmp)))<<(tmp = -1310524200.6106496, tmp))))%((((-2558804500.7722936)+(tmp = -1641265491, tmp))<<((tmp = -1309608349, tmp)>>>x))/((tmp = -2306644272, tmp)<<x)))*(-2009396162.3063657))+(267343314.3720045))-(-2212612983.661479)))|x)); - assertEquals(NaN, x %= x); - assertEquals(NaN, x *= x); - assertEquals(-824822309, x |= (-824822309)); - assertEquals(-807944741, x |= (((-598067403)*((x&(tmp = 2897778389, tmp))>>>(-1322468310.3699632)))|x)); - assertEquals(90004223.44097246, x /= (((tmp = -481122620, tmp)&x)%((tmp = 1109368524, tmp)/(((-3150568522.633032)<<(tmp = 2923396776, tmp))^(x-((x/x)&(x/(-287976185.1049104)))))))); - assertEquals(0.4521931751193329, x /= (tmp = 199039323, tmp)); - assertEquals(1.8110466604491368e-10, x /= (2496860986.492693)); - assertEquals(0, x |= x); - assertEquals(-1225944576, x += ((tmp = -807700791.631221, tmp)<<((-700782615.4781106)-((((-2954619897)>>>x)<<((tmp = 997657844, tmp)>>>(1227994596)))/((-1234591654.8495834)*((tmp = -191189053.70693636, tmp)+(tmp = -3027659304, tmp))))))); - assertEquals(-1225811383, x |= (-1866233271)); - assertEquals(3069155913, x >>>= (((x/(-99524153.40911508))%(x>>>((((tmp = 2985975640, tmp)/(tmp = 2781516546.2494454, tmp))&(((2234114508)|(((x/(tmp = -1224195047, tmp))<<x)^(x>>>((537884375.5698513)+x))))^((tmp = -2144817497.5089426, tmp)|(-498079183.8178189))))>>>((x+x)&(-3086080103.6460695)))))<<(((tmp = 2151157136, tmp)*x)/(((x/x)>>>(-1149734628.4364533))-((3025445835.654089)+(tmp = 530902725.91127443, tmp)))))); - assertEquals(-1733702568, x ^= (tmp = 776361489.423534, tmp)); - assertEquals(8981504, x &= ((tmp = 2902581847, tmp)*(x-(-2697760560)))); - assertEquals(1153166.8526612986, x -= ((x/(tmp = -1375025594.5027463, tmp))+((3043576689.1538706)%(x+x)))); - assertEquals(3389855, x |= (x+x)); - assertEquals(-488458393.17759943, x += (-491848248.17759943)); - assertEquals(40982867145206920, x *= ((3132857155)|(tmp = -218356553, tmp))); - assertEquals(688, x >>= (((((tmp = 403321821, tmp)+((tmp = 2536984658, tmp)%((tmp = 2759309029.8753624, tmp)|(((tmp = 1994203554.7417293, tmp)^((704660500.434877)*(tmp = 1536292958.2691746, tmp)))+(-164139788)))))/((1205950994.1255205)+x))^((((tmp = 975272146.0133443, tmp)-(150107797))/(-1764309514))^((x>>>(x^(x^x)))+(203250124))))>>>(tmp = 1864959239.512323, tmp))); - assertEquals(10, x >>= ((tmp = 1631996431.9620514, tmp)>>x)); - assertEquals(10, x %= (tmp = 2678904916, tmp)); - assertEquals(335544320, x <<= (tmp = -2759037415.6811256, tmp)); - assertEquals(-153389967, x |= ((tmp = -2411636565, tmp)+(tmp = -2305156154, tmp))); - assertEquals(-1171, x >>= x); - assertEquals(813080576, x &= (((tmp = -65428547, tmp)&(tmp = 3163266999, tmp))<<x)); - assertEquals(4346532303, x += ((tmp = -761515569.0707853, tmp)>>>(((tmp = 143240971.0661509, tmp)<<x)*(x^((tmp = -271697192.8471005, tmp)&x))))); - assertEquals(-863299035, x ^= ((((2663001827.1492147)>>>((x/(((tmp = 482665912, tmp)-(x>>(tmp = 354425840.784659, tmp)))>>((-2012932893)>>>x)))/((tmp = -1354385830.6042836, tmp)>>>(-2149023857))))^((tmp = 585746520, tmp)+(tmp = 756104608, tmp)))^(517529841.184085))); - assertEquals(-997654012, x &= (((tmp = -404836025.15326166, tmp)+((tmp = 3035650114.0402126, tmp)<<((-1308209196)>>(tmp = 693748480, tmp))))<<(((465774671.4458921)<<x)/(1971108057)))); - assertEquals(-320581507110848260, x *= ((x-(tmp = -2266777911.7123194, tmp))^(tmp = -2810021113.304348, tmp))); - assertEquals(-320581508271196300, x += ((-1195215841.5355926)|(x-((2715907107.4276557)+(((-843426980)>>(x&(x%(tmp = -1139279208.34768, tmp))))^x))))); - assertEquals(368031616, x &= x); - assertEquals(368031616, x %= (tmp = 1211767328, tmp)); - assertEquals(-67505614939510744, x *= (tmp = -183423412.56766033, tmp)); - assertEquals(959424552, x >>= ((tmp = -171120122.5083747, tmp)/x)); - assertEquals(30949179.096774194, x /= (((x-((((x&(tmp = -180770090, tmp))<<(((tmp = -2061363045.419958, tmp)*((655711531)^((1205768703)-(tmp = 2468523718.8679857, tmp))))+(-2746704581)))+((-853685888)*(tmp = -2299124234, tmp)))|(tmp = 2429502966, tmp)))|(((-985794986.0232368)>>>(2890862426))%x))>>(tmp = 1005542138.8415397, tmp))); - assertEquals(30949179, x |= x); - assertEquals(30949179, x %= (810126097.6814196)); - assertEquals(120895, x >>= (tmp = 3065886056.1873975, tmp)); - assertEquals(1934320, x <<= (1478650660.7445493)); - assertEquals(0, x >>= (1069658046.2191329)); - assertEquals(NaN, x %= x); - assertEquals(NaN, x %= (x*x)); - assertEquals(NaN, x *= ((((2148513916)+(tmp = -210070225.85489202, tmp))>>(975470028))+((-3060642402)>>x))); - assertEquals(NaN, x *= (2888778384)); - assertEquals(NaN, x -= (294531300.16350067)); - assertEquals(-465620423, x ^= (tmp = -465620423.5891335, tmp)); - assertEquals(1613303808, x &= (-2530649850.1952305)); - assertEquals(2045458658, x |= (tmp = 432158946.5708574, tmp)); - assertEquals(0, x >>>= (2277328255.770018)); - assertEquals(0, x &= (-64904722.41319156)); - assertEquals(0, x >>= x); - assertEquals(3109394857.361766, x += (3109394857.361766)); - assertEquals(1519021650, x ^= ((tmp = -2632472653, tmp)|(tmp = 2161964921.8225584, tmp))); - assertEquals(370854, x >>>= ((1486892931.4564312)-((tmp = 3017755741.9547133, tmp)>>>x))); - assertEquals(1333145110.39802, x -= ((-1051580495.39802)-(tmp = 281193761, tmp))); - assertEquals(0, x ^= x); - assertEquals(0, x |= x); - assertEquals(0, x <<= x); - assertEquals(0, x >>>= x); - assertEquals(799202788.1455135, x -= (tmp = -799202788.1455135, tmp)); - assertEquals(1539080192, x <<= (x%(((((x-x)|(((((x%(959993901))+(tmp = -2647575570.092733, tmp))/(tmp = -2040600976.5104427, tmp))*(x*(tmp = 2785252760, tmp)))>>(-377867259)))/((x&(1549738240.013423))>>>(tmp = -1502185618, tmp)))*x)%(1159283801.0002391)))); - assertEquals(0, x >>= (-268660225)); - assertEquals(-0, x /= (-2795206270.635887)); - assertEquals(0, x >>>= (1869556260.2489955)); - assertEquals(64202212, x ^= ((((tmp = -942983515.5386059, tmp)*(((1057759788)-x)*(tmp = 2038041858, tmp)))>>x)+(tmp = 64202212, tmp))); - assertEquals(2021126977, x -= ((tmp = -2009912898, tmp)^((2240062309)%x))); - assertEquals(4332348265459724000, x *= (tmp = 2143530968, tmp)); - assertEquals(1472, x >>>= ((283380755)<<x)); - assertEquals(-1672370407872, x *= (tmp = -1136121201, tmp)); - assertEquals(338573318, x ^= (tmp = 2329579078.4832354, tmp)); - assertEquals(2377388772.1662374, x -= (tmp = -2038815454.1662374, tmp)); - assertEquals(-1.264761712403516, x /= ((((tmp = -2106209534, tmp)>>((((((tmp = 626190172, tmp)/x)>>>(-824270996.8545206))/((1258369810.9498723)-(tmp = -2947556209, tmp)))^((((366784589.24711144)|(1462064104.828938))-(1571045395.777879))<<(444685689.60103726)))>>(tmp = -2757110357.410516, tmp)))/(x>>>((tmp = 829226010, tmp)>>>(629512715))))|x)); - assertEquals(-2905481691.264762, x -= (2905481690)); - assertEquals(-1710543566.1481905, x -= (-1194938125.1165714)); - assertEquals(-3421087132.296381, x += x); - assertEquals(-884178944, x <<= ((-1820881235)|x)); - assertEquals(-884178944, x &= (x%(tmp = -2298828530, tmp))); - assertEquals(1516503040, x <<= ((tmp = -3039882653, tmp)+((tmp = 1956034508, tmp)<<(x>>(tmp = 280388051, tmp))))); - assertEquals(3033006080, x += x); - assertEquals(846431222.321887, x %= (x+(-1939718651.1609435))); - assertEquals(-846431224, x ^= ((-1742116766.54132)/x)); - assertEquals(1157918728, x &= (tmp = 1966568030, tmp)); - assertEquals(1157918728, x >>>= ((((((tmp = -2392096728.184257, tmp)*(x&(-3051259597.301086)))>>>(((tmp = 1712991918.071982, tmp)*(tmp = -714525951, tmp))-((-1784801647)>>((-1270567991)%(((214272558)/(((-3110194570)|(tmp = 2558910020, tmp))&(-1266294955.717899)))*((2654922400.609189)>>>(tmp = 370485018, tmp)))))))*(((tmp = -2621203138.1838865, tmp)%(858913517))*((tmp = -1564229442.2596471, tmp)>>((tmp = 1898557618, tmp)|(-1282356275)))))*(tmp = -1253508468, tmp))+((-361964404.75944185)|x))); - assertEquals(961668975, x += (-196249753)); - assertEquals(1, x >>= (tmp = 890453053, tmp)); - assertEquals(1, x >>= (((((tmp = 871309275, tmp)/(x>>>((tmp = 2033022083, tmp)&(tmp = -1393761939, tmp))))%((437488665.104565)^(tmp = 2808776860.4572067, tmp)))-((tmp = -359283111.49483967, tmp)<<((tmp = 2985855945, tmp)%(tmp = -596479825.9114966, tmp))))/(-1965528507))); - assertEquals(0, x >>= ((tmp = -1753776989, tmp)%(tmp = 322622654, tmp))); - assertEquals(84411424, x ^= (((x|(x|(tmp = -1617122265, tmp)))&(tmp = -313813263, tmp))&(1472888112.0258927))); - assertEquals(67633184, x &= ((1556833131.0776267)<<(x<<(1501219716.5575724)))); - assertEquals(68002293, x |= (((tmp = 188984203.0350548, tmp)>>>(tmp = 1356052777, tmp))%(x*(tmp = -2944960865, tmp)))); - assertEquals(67108864, x &= (((1046644783.9042064)<<x)+((-2796345632)>>>(((-1913290350.3687286)<<(((((tmp = -2223692353, tmp)>>x)&(x<<(x>>((((tmp = -976850020, tmp)%(tmp = 1379692507, tmp))>>>(1120103052.2077985))>>(tmp = 5592070.612784743, tmp)))))<<(x+((tmp = -3154037212.9764376, tmp)%(((x-(-1961060483.6965141))+(((1920670676)-(2852444470.7530622))/(((1445954602)>>((1353665887)>>(tmp = 111411560.64111042, tmp)))<<x)))+x))))<<((-1773130852.6651905)^((1216129132)>>(1511187313.2680469)))))|((tmp = -1107142147, tmp)|(tmp = -768165441.4956136, tmp)))))); - assertEquals(0, x -= x); - assertEquals(0, x %= (tmp = -1655707538.0778136, tmp)); - assertEquals(-184120712930843900, x += (x+((tmp = -3174410166, tmp)+((tmp = -301807453, tmp)*(tmp = 610060182.1666535, tmp))))); - assertEquals(-54598560, x >>= (-1365351357)); - assertEquals(-6763.94449950446, x /= (((-1953016847)<<((673287269.7002038)%(-558739761)))>>>(tmp = 1607754129, tmp))); - assertEquals(-1, x >>= x); - assertEquals(1, x >>>= x); - assertEquals(0, x >>>= x); - assertEquals(0, x >>= ((-384747983)+((((tmp = -949058352.381772, tmp)>>>(-1920744986))-(-882729639))^((x^((tmp = 2351364046, tmp)<<(((tmp = -3110165747, tmp)^(-1266489735))-((tmp = -371614326, tmp)>>((tmp = -2064968414, tmp)&(-2075036504.617934))))))&(((-2616501739)&(tmp = 2591437335.4029164, tmp))>>x))))); - assertEquals(0, x >>>= ((tmp = 2946468282, tmp)&((-2741453019)>>x))); - assertEquals(0, x -= ((x%(-134700915))&(-1955768279))); - assertEquals(NaN, x /= x); - assertEquals(NaN, x /= (x^(((((((tmp = 3185669685.772061, tmp)>>(tmp = -1973500738, tmp))-(tmp = -87401348.93002152, tmp))>>(tmp = -2813508730, tmp))&(tmp = -778957225, tmp))<<(x-(x&((-2821756608)+(((((tmp = 2475456548, tmp)/(tmp = 997998362, tmp))<<((tmp = -83043634, tmp)|x))%(636120329))%(tmp = -1910213427.7556462, tmp))))))%x))); - assertEquals(0, x &= x); - assertEquals(0, x <<= x); - assertEquals(0, x >>>= (x%x)); - assertEquals(0, x %= (745221113)); - assertEquals(0, x >>>= ((1467615554.7672596)|x)); - assertEquals(0, x /= (tmp = 735317995, tmp)); - assertEquals(-1513001460, x |= (2781965836)); - assertEquals(-1513001460, x |= (x%(1970577124.3780568))); - assertEquals(-0, x %= x); - assertEquals(1864972269, x ^= (-2429995027.840316)); - assertEquals(1226843341, x &= (tmp = -639621923.5135081, tmp)); - assertEquals(1226843339.3171186, x += ((1297620268.272113)/(-771070549))); - assertEquals(76677708, x >>>= (1009134980)); - assertEquals(0, x ^= x); - assertEquals(0, x ^= x); - assertEquals(NaN, x /= x); - assertEquals(716040787, x |= ((1851586229)-(1135545441.3502865))); - assertEquals(1385693184, x <<= x); - assertEquals(1321, x >>= (x^((tmp = -1576632297.0860603, tmp)>>>(405218605)))); - assertEquals(-1319012931, x |= (-1319014243)); - assertEquals(-1319012931, x >>= ((((1689898279.3580785)<<((((x^(x>>>((((tmp = 2635260332, tmp)*(tmp = 2053357650, tmp))*x)*(2856480122.339903))))>>x)&(-2382703000.077593))%(1183918594)))*(tmp = -1670081449, tmp))<<x)); - assertEquals(-528327581.7646315, x %= (tmp = -790685349.2353685, tmp)); - assertEquals(2073431790, x ^= (tmp = 2601800333, tmp)); - assertEquals(-6514722684180, x -= (((tmp = 824141806.0668694, tmp)>>>(((-1865885282.8723454)&(x&(x|((900188006.3757659)>>>(x&x)))))+(2227126244.0526423)))*x)); - assertEquals(1450593, x >>>= ((2157053647)>>(x+(-2934071355.418474)))); - assertEquals(576782336, x <<= ((1054640368.827202)&((tmp = -3182236876.434615, tmp)>>(tmp = 2129856634.0328193, tmp)))); - assertEquals(2950754326, x -= (tmp = -2373971990, tmp)); - assertEquals(738197504, x <<= (1188157369.5988827)); - assertEquals(0, x <<= (x+((tmp = -839533141, tmp)&((((((tmp = -1148768474.7306862, tmp)|(172650299))+(tmp = -2739838654, tmp))/(3132557129))%x)>>>(tmp = -1229961746.2466633, tmp))))); - assertEquals(0, x %= (tmp = -2974207636, tmp)); - assertEquals(0, x %= ((2323482163)>>>x)); - assertEquals(0, x &= (((x/(x+(x>>((tmp = 55935149, tmp)%x))))|((3109182235)>>>(tmp = 1217127738.8831062, tmp)))+((((tmp = -385114910, tmp)*((((((tmp = -2535158574.634239, tmp)&(x+x))<<(-2821692922.43476))&(-776804130.9457026))>>((-1374832535)^(tmp = 2175402162.701251, tmp)))%(-1646995095)))-(x*(tmp = -921556123, tmp)))^(79224621)))); - assertEquals(128935435, x |= ((tmp = 2279459038, tmp)%(tmp = -537630900.5271742, tmp))); - assertEquals(128935435, x /= ((((((x<<(2750024311))-((-1332480769.4784315)&(1418160003)))&(1551783357))<<(((((-2870460218.55027)|((-1958752193.7746758)&(2551525625)))>>>((((tmp = -1698256471, tmp)^(((((((((tmp = -830799466, tmp)+x)-(-111590590))+(tmp = -1105568112.3921182, tmp))/((tmp = -3058577907, tmp)|(((-1944923240.2965696)%(-2884545285))<<(tmp = -1993196044.1645615, tmp))))^(x>>(tmp = -2961488181.3795304, tmp)))&x)*x)|(((tmp = 97259132.88922262, tmp)<<((1601451019.343733)&x))*(x|x))))+((((x>>x)<<x)+(-868409202.2512136))/(((tmp = -2893170791, tmp)-((x|(-853641616))%(((tmp = 549313922, tmp)&(-768036601.6759064))%(tmp = -543862220.9338839, tmp))))-((tmp = 1639851636, tmp)+((2164412959)/(-273028039.941242))))))>>>((((-2382311775.753495)^(-2062191030.2406163))>>>(tmp = -1054563031, tmp))/(-862111938.7009578))))%x)+(-3103170117.625942)))%((tmp = -1144062234, tmp)>>x))>>>(tmp = 1216332814.00042, tmp))); - assertEquals(41.631074722901715, x /= (x&(-2542806180.962227))); - assertEquals(41.631074722901715, x %= (-14003386.556780577)); - assertEquals(8, x &= (x&((-2231622948)%(tmp = 488279963.9445952, tmp)))); - assertEquals(9.002961614252625e-9, x /= ((53802728.56204891)<<(((867697152.3709695)-(538719895.5707034))&(-631307825.4491808)))); - assertEquals(0, x >>= x); - assertEquals(-0, x *= (tmp = -785674989, tmp)); - assertEquals(-0, x += x); - assertEquals(0, x /= (-250703244)); - assertEquals(0, x <<= ((tmp = -661062581.5511999, tmp)|x)); - assertEquals(0, x &= (-1299482308)); - assertEquals(0, x &= ((-399690060)>>>(2448074202.385213))); - assertEquals(0, x &= (2574341201)); - assertEquals(0, x <<= ((x|(((tmp = 2458873162.645012, tmp)+(tmp = -1999705422.8188977, tmp))<<((x^(tmp = -392530472, tmp))>>>x)))&(((tmp = 2463000826.7781224, tmp)|(tmp = 3020656037, tmp))-x))); - assertEquals(1397603760, x += ((tmp = -1359413071, tmp)-(tmp = -2757016831, tmp))); - assertEquals(513823851, x -= (883779909)); - assertEquals(-1765712747, x ^= (2288060670.6797976)); - assertEquals(3117741504918286000, x *= x); - assertEquals(3117741506284045300, x += (1365759456)); - assertEquals(6035555595.597267, x /= (tmp = 516562470, tmp)); - assertEquals(104203275, x &= (tmp = 376835755.32434213, tmp)); - assertEquals(10858322520725624, x *= x); - assertEquals(59458951, x >>>= (153765028)); - assertEquals(49370856, x += ((tmp = -1291276092, tmp)>>x)); - assertEquals(0, x %= x); - assertEquals(0, x += x); - assertEquals(-1494589645, x -= (1494589645)); - assertEquals(-0, x %= x); - assertEquals(0, x <<= (x&((2730708043.467806)<<x))); - assertEquals(0, x /= ((tmp = -1483912394.153527, tmp)>>>((tmp = 1800568769, tmp)^((((((tmp = 1351568510, tmp)>>(tmp = -1337992543.2562337, tmp))>>>(tmp = 2602239360.40513, tmp))*x)%x)+(-2095840128.0700707))))); - assertEquals(-0, x /= ((2363946613)^(tmp = -2227868069, tmp))); - assertEquals(0, x &= ((((2634933507)<<(2798775374.140882))>>>x)>>>(((tmp = 1135200853.6396222, tmp)-(tmp = -1529829490.7007523, tmp))-(((((((((x^((x|(2135742668.591568))-(924230444.8390535)))%(tmp = -2459525610.51898, tmp))+(x&((tmp = 1177231743.809653, tmp)/(tmp = 1743270357.2735395, tmp))))|(((tmp = -1894305017, tmp)^((tmp = 1791704240, tmp)&x))%(-1569751461)))>>>(tmp = -2078321944, tmp))|x)*(((x*(tmp = -163239354, tmp))<<((tmp = 2859087562.694203, tmp)&(-657988325.9410558)))^(2508013840)))-((-243572350)+(x%((-1095206140)+((tmp = 3213566608.942816, tmp)*((2256442613)%((tmp = 1723751298, tmp)^(x-((-1145710681.2693722)|x)))))))))+(1556870627))))); - assertEquals(130883024.97423434, x -= (-130883024.97423434)); - assertEquals(0.046720352789736276, x /= (tmp = 2801413456, tmp)); - assertEquals(1806558189, x |= (tmp = 1806558189.157823, tmp)); - assertEquals(72.40475060062144, x /= (x%((1932591076.531628)>>(1982030182)))); - assertEquals(-1077558321.5975945, x += (tmp = -1077558394.002345, tmp)); - assertEquals(98187, x >>>= x); - assertEquals(97792, x &= (tmp = -1032487404, tmp)); - assertEquals(709197609, x |= (x^(709179177))); - assertEquals(11081212, x >>>= (tmp = 1412940006.169063, tmp)); - assertEquals(11081212, x &= x); - assertEquals(-1920311203, x -= ((tmp = 1931392415, tmp)<<((x%(tmp = -2873576383, tmp))%x))); - assertEquals(-1920311203, x |= (x&(-993884718.2172024))); - assertEquals(-4, x >>= (1409411613.0051966)); - assertEquals(-7947632484, x *= ((-2856731734)^((-1181032235.9132767)-((tmp = 780101930, tmp)+((tmp = -1732707132.6253016, tmp)^x))))); - assertEquals(-2016362769, x ^= (tmp = 2711125619.2455907, tmp)); - assertEquals(-61535, x >>= x); - assertEquals(-124771649, x ^= (tmp = 124726558, tmp)); - assertEquals(-1, x >>= x); - assertEquals(-0, x %= (x*x)); - assertEquals(0, x <<= x); - assertEquals(0, x /= (2444628112)); - assertEquals(0, x <<= ((-38968517.72504854)<<x)); - assertEquals(-1504619917, x |= (tmp = 2790347379, tmp)); - assertEquals(-1504619917, x &= x); - assertEquals(2790347379, x >>>= ((1825218368)<<(-1843582593.2843356))); - assertEquals(7786038495492170000, x *= x); - assertEquals(-11011696, x |= (((tmp = 2931644407.4936504, tmp)-(3077095016.001658))%(tmp = -1731851949, tmp))); - assertEquals(-107866, x %= ((-697845074.1661191)>>(772708134))); - assertEquals(356779149, x ^= (-356884949.503757)); - assertEquals(0, x %= x); - assertEquals(0, x *= ((tmp = 1542291783, tmp)^x)); - assertEquals(0, x += ((tmp = 1105314644.002441, tmp)&x)); - assertEquals(-1005882993, x ^= (-1005882993.0899806)); - assertEquals(-1301065066, x += (tmp = -295182073, tmp)); - assertEquals(-1454702592, x <<= ((-2440858737.390277)&(-1363565201.7888322))); - assertEquals(-201539012492525570, x *= ((((tmp = -1416268089, tmp)|x)-(tmp = 1669129769, tmp))&(x<<((x/(-2614041678.7423654))%x)))); - assertEquals(-2.1995276811535986e+25, x *= (x/(-1846667987.154371))); - assertEquals(0, x |= ((x*(((x>>>((tmp = 1044173034, tmp)>>>((x<<((tmp = -2906412863, tmp)%((tmp = -437401503, tmp)<<(((((x|(2167319070))<<((tmp = 2766179640.1840167, tmp)&(-2372076054)))*(tmp = -241617431.06416297, tmp))*((((((tmp = 2570465382.5574293, tmp)>>>(x/((-2851324509.354545)%x)))>>(((x+((tmp = -614687945, tmp)^x))^((((tmp = 1653437743, tmp)>>x)/(tmp = 3072995069, tmp))>>x))*(((((-290508242)>>((tmp = 2969511554, tmp)<<(tmp = 158176292.95642304, tmp)))<<(32376015))+(tmp = 2391895870.4562025, tmp))*x)))&((((x/(tmp = 365292078.53605413, tmp))>>x)/(1167322811.0008812))|(((tmp = 2487970377.365221, tmp)^x)<<((tmp = 2342607988.711308, tmp)/(((2276081555.340126)-(((tmp = -2571071930, tmp)>>(tmp = -248468735.76550984, tmp))>>>(tmp = -2862254985.608489, tmp)))^(-1312017395))))))<<x)&(2762717852.949236)))+((((-2492896493)&x)<<(-2756272781.4642315))/x)))))*(2405395452))))>>((-1433975206)/((tmp = -2064757738.6740267, tmp)<<((((tmp = -1563531255, tmp)-(-589277532.2110934))<<x)^(2249328237.0923448)))))-x))-(-225624231))); - assertEquals(0, x *= (tmp = 1657982666.2188392, tmp)); - assertEquals(86443387, x |= (tmp = 86443387.25165462, tmp)); - assertEquals(86443387, x %= (-1341731981.702294)); - assertEquals(172886774, x <<= ((-1799840391)&(1011948481.310498))); - assertEquals(-1115684864, x <<= x); - assertEquals(-2098253702059525600, x *= (1880686715.1865616)); - assertEquals(-2098253700213206300, x -= (tmp = -1846319435.0583687, tmp)); - assertEquals(570692096, x &= (((tmp = -1572055366.64332, tmp)%(tmp = 1720120910, tmp))%((x-(912386952.5959761))*(tmp = -1146251719.4027123, tmp)))); - assertEquals(603979776, x <<= ((-329752233.8144052)&(tmp = -368636559, tmp))); - assertEquals(603979776, x <<= x); - assertEquals(364791569817010200, x *= x); - assertEquals(0, x &= ((2074587775.983799)/(tmp = 438856632.76449287, tmp))); - assertEquals(0, x &= (((1509671758)*(tmp = -935801537.7325008, tmp))>>>(((tmp = -1752877566, tmp)<<x)%(tmp = -517163766, tmp)))); - assertEquals(-2031730599, x ^= ((2264285273)&(tmp = -1762662949.014101, tmp))); - assertEquals(-843578945, x %= (-1188151654)); - assertEquals(-2147483648, x <<= x); - assertEquals(-2147483648, x >>= (tmp = -3165079200.229641, tmp)); - assertEquals(-44086313.1323726, x %= ((x%(-254466243.48728585))-((x>>(-457411829.1063688))-((-2606923436.9333453)/x)))); - assertEquals(-44086313, x |= x); - assertEquals(1037812, x >>>= ((tmp = 342497258.9786743, tmp)+(1652928385.8150895))); - assertEquals(-2371695599678100, x *= (tmp = -2285284425, tmp)); - assertEquals(-2371697387004653, x += (tmp = -1787326553.0542095, tmp)); - assertEquals(0, x ^= x); - assertEquals(0, x >>= ((x^(tmp = 544039787, tmp))>>>x)); - assertEquals(0, x &= ((x%(((((((tmp = -424572417.1088555, tmp)|(-2381863189))/(tmp = -2007482475.1809125, tmp))&(((((tmp = 311016073, tmp)>>(tmp = -1548839845, tmp))+((-2557740399.7947464)<<(2399113209)))&x)>>>x))%(-297180308.7721617))-(tmp = 860906293, tmp))^x))%(-2740622304))); - assertEquals(4971841192462909000, x += ((tmp = -2723203837.572612, tmp)+((((-2909100706)+(-951999374))|(-3116735764))*(3087123539.422669)))); - assertEquals(-460, x >>= (1081807537.557404)); - assertEquals(2354165127.3906384, x += (tmp = 2354165587.3906384, tmp)); - assertEquals(357.8680960002211, x /= ((((x<<(((x&x)+(1113841407))|((x/(tmp = 384533564, tmp))>>>(-605853882))))%x)&((tmp = 2050375842, tmp)>>>x))>>(((2745147573)^x)<<(x-(900043292))))); - assertEquals(0, x *= (x>>>(-295974954.5058532))); - assertEquals(0, x *= ((-2448592125.815531)*(tmp = -94957474.8986013, tmp))); - assertEquals(0, x &= ((x>>x)^(tmp = -1335129180, tmp))); - assertEquals(395092065, x |= ((3081659156)^(tmp = -1608334475, tmp))); - assertEquals(395092065, x &= x); - assertEquals(-413337639, x += (x^(tmp = -664996071.3641524, tmp))); - assertEquals(-1604423637896759800, x *= (x>>>(tmp = 1242912352.955432, tmp))); - assertEquals(0, x &= ((((((tmp = 651293313, tmp)|(((2541604468.635497)>>>(tmp = 758815817.7145422, tmp))>>>((-1948795647)/x)))&x)/((tmp = -3161497100, tmp)+(782910972.3648237)))>>>x)%(834206255.5560443))); - assertEquals(0, x >>>= (tmp = 125945571, tmp)); - assertEquals(NaN, x -= (x%x)); - assertEquals(NaN, x %= (tmp = 282259853, tmp)); - assertEquals(NaN, x += (tmp = -2081332383, tmp)); - assertEquals(0, x >>>= (((x>>(-2298589097.7522116))|((((x>>>(x-(tmp = 755218194, tmp)))|x)%x)-(tmp = 2206031927, tmp)))>>>((((x&(x-x))^(tmp = 2836686653, tmp))*((x<<(tmp = -1624140906.4099245, tmp))>>>((2942895486)|((x>>>x)>>>(-1586571476)))))|((781668993)+(-1857786909))))); - assertEquals(0, x &= (tmp = -708084218.9248881, tmp)); - assertEquals(0, x %= (1645913394.5625715)); - assertEquals(0, x <<= ((x^((tmp = 1185413900, tmp)*((-2441179733.997965)*(tmp = 2554099020.066989, tmp))))%((1704286567.29923)/x))); - assertEquals(0, x += x); - assertEquals(0, x *= x); - assertEquals(0, x |= (x>>>(139138112.141927))); - assertEquals(0, x >>>= (tmp = 2142326564, tmp)); - assertEquals(0, x |= x); - assertEquals(-0, x /= ((((x+(2817799428))|x)%((1050079768)-(x>>>((1452893834.8981247)|((((tmp = -1737187310.889149, tmp)/(tmp = -362842139, tmp))%(1234225406))%(((x|x)*((-1055695643.739629)-((x-x)*(945954197.676585))))-(tmp = 786185315.346615, tmp)))))))<<(-173891691))); - assertEquals(0, x &= (-2842855092.319309)); - assertEquals(0, x &= ((-3188403836.570895)/x)); - assertEquals(0, x *= (x+x)); - assertEquals(NaN, x /= (x>>>(((tmp = 391037497.68871593, tmp)/((192754032)*(1382659402.5745282)))/((((-2187364928)>>>x)>>(tmp = 2563448665.7594023, tmp))^(tmp = 1500866009.7632217, tmp))))); - assertEquals(NaN, x /= ((tmp = -935036555.2500343, tmp)-(x/(((x&(x^(tmp = -3001352832.5034075, tmp)))^x)/((1122547613)>>x))))); - assertEquals(0, x >>= (tmp = -2951766379.0809536, tmp)); - assertEquals(-632945188, x ^= (-632945188.7188203)); - assertEquals(-632945188, x %= ((((((tmp = -3181527314.82724, tmp)&(2280175415))>>(x^(x|x)))^(tmp = -524233678.52970886, tmp))*x)|((tmp = 1782882786, tmp)>>>(tmp = -592607219, tmp)))); - assertEquals(404189184, x <<= ((tmp = -2761472127, tmp)^(36616299.88780403))); - assertEquals(872651572, x ^= (tmp = 739568436.6252247, tmp)); - assertEquals(13, x >>>= ((tmp = -1033843418.865577, tmp)%(x%(1247263629.0445533)))); - assertEquals(0, x >>>= x); - assertEquals(0, x >>= (3189175317)); - assertEquals(0, x &= (((2391973519.6142406)^((-2950058736.191456)|(x*x)))>>(tmp = 343822384.294345, tmp))); - assertEquals(0, x >>>= (tmp = -2306246544, tmp)); - assertEquals(-1572339598, x ^= ((tmp = 2991380083.337327, tmp)&(tmp = -1361507970, tmp))); - assertEquals(649, x >>>= ((1961407923.4950056)>>(x-(-872821523.7513013)))); - assertEquals(649, x ^= (((x&(tmp = -702931788, tmp))^(((x>>x)|(((tmp = 2710759269, tmp)/(x>>(x*((((((tmp = -2428445134.9555864, tmp)+(-1859938743))%(x<<x))*((236868604)+((tmp = -3066688385, tmp)/(787503572.8839133))))/(tmp = 3215629315, tmp))>>(-1315823020)))))%(1461368627.1293125)))>>>(tmp = -2921804417.5735087, tmp)))/(x>>>(((tmp = 2175260691.824617, tmp)/((-582958935.7628009)-((((((x>>x)|(2590503723.4810824))^(tmp = -1994324549, tmp))-(-684683327))/(tmp = -3133419531, tmp))|(tmp = -328974092.05095506, tmp))))>>(-447624639.4518213))))); - assertEquals(649, x %= ((((1854382717)|(((x+(tmp = 2568081234, tmp))-x)+((tmp = 1043086140, tmp)<<((tmp = 2979118595.0496006, tmp)+((x&(2669577199.852803))/(-2567808445.101112))))))<<((((tmp = -1471092047, tmp)&((-3099138855.21041)-((tmp = -798574377.526715, tmp)&((2255586141)<<(-1069867774)))))>>>(((x*(tmp = -2810255707.781517, tmp))/x)*(2706435744.054121)))^(394262253)))^((844325548.0612085)/(tmp = 1434691648, tmp)))); - assertEquals(823215943.1924392, x += (tmp = 823215294.1924392, tmp)); - assertEquals(536872706, x &= ((-334612686)%((1303605874)|x))); - assertEquals(-30666374.413486242, x += ((tmp = -567539080.4134862, tmp)%(tmp = -1655555936.3195171, tmp))); - assertEquals(-56438727096752984, x *= (tmp = 1840410814, tmp)); - assertEquals(-33200107.984488487, x %= (((tmp = 3007206509, tmp)-(3079337725.6659536))%(1819565202.5011497))); - assertEquals(-1214493182, x ^= (-3060193769)); - assertEquals(-1214493179.1335113, x -= ((-3218099496.595745)/(1122662554))); - assertEquals(-1214493179, x >>= ((-375364195)<<(((tmp = 619439637.8754326, tmp)>>(-1830023279.9486575))&(tmp = -1106180387.2448823, tmp)))); - assertEquals(-303623295, x >>= (-2109241374.3349872)); - assertEquals(-0, x %= x); - assertEquals(0, x |= x); - assertEquals(1917126206, x -= (-1917126206)); - assertEquals(2659779928, x -= (tmp = -742653722, tmp)); - assertEquals(-1635187368, x >>= ((tmp = -674385169, tmp)*((9848362.783326745)|(x*(55220544.00989556))))); - assertEquals(-1981113695, x ^= ((tmp = 392404985, tmp)>>(((x<<((2006207061)<<(tmp = 2558988218, tmp)))*((((tmp = 1789304307.1153054, tmp)/(2538061546))<<(tmp = 556026116, tmp))&((tmp = 1076457999.6424632, tmp)*(tmp = -1822378633.2489474, tmp))))%(((((-1117046924)&((-69013651)%(x&(((-2320327696)/(x&x))-(tmp = 2458222544, tmp)))))>>((-3092360983.0037227)/(-3171415636)))*(((tmp = 2520431213, tmp)<<(1066492762.6149663))+((tmp = 1272200889, tmp)^((1687693123.2295754)+x))))-(-1096823395))))); - assertEquals(-990556848, x >>= x); - assertEquals(981202869119695100, x *= x); - assertEquals(981202869119695100, x -= (x/x)); - assertEquals(0, x ^= (x>>x)); - assertEquals(NaN, x %= x); - assertEquals(0, x ^= x); - assertEquals(0, x *= ((((2980512718)>>>x)<<((x^(-1111233869))>>((2531466092.6036797)>>>(((tmp = -1791229364, tmp)*(-2210950307.206208))%((tmp = -806645443, tmp)<<((((((((tmp = 112334634.26187229, tmp)%(x|((((2154021796.1166573)+x)&((-1047293079.9686966)^(tmp = -1894127139, tmp)))+(tmp = 1910946653.2314827, tmp))))^(293142672.5016146))-x)<<(-1593533039.8718698))+x)>>(x<<(((46359706.50393462)&(tmp = 272146661, tmp))|(tmp = 2117690168, tmp))))%(tmp = -1784737092.4924843, tmp)))))))-(1465796246))); - assertEquals(0, x &= x); - assertEquals(NaN, x %= x); - assertEquals(0, x &= (x+(-1612418456))); - assertEquals(0, x &= ((tmp = -843964311, tmp)/x)); - assertEquals(NaN, x /= x); - assertEquals(NaN, x *= x); - assertEquals(NaN, x += (x>>>(54020240))); - assertEquals(489206868, x |= (489206868)); - assertEquals(489206868, x &= x); - assertEquals(489206848, x &= ((tmp = -1699133906.2361684, tmp)>>(tmp = 2658633814, tmp))); - assertEquals(489206848, x |= x); - assertEquals(1910559006, x -= (tmp = -1421352158, tmp)); - assertEquals(1, x >>= x); - assertEquals(0, x -= x); - assertEquals(0, x %= (x^(tmp = 2745376003.2927403, tmp))); - assertEquals(0, x %= (((tmp = 3199743302.1063356, tmp)^((-1905944176)&(x>>>(187247029.5209098))))<<((x*((-1394648387)*(1252234289)))-(3140049815)))); - assertEquals(0, x <<= (-2567872355)); - assertEquals(0, x %= (tmp = 1057707555.8604916, tmp)); - assertEquals(0, x %= ((tmp = -1877857405.0228279, tmp)>>>(((tmp = 423831184, tmp)*((tmp = -2106757468.324615, tmp)%(tmp = -1197717524.6540637, tmp)))>>(tmp = -93746263.46774769, tmp)))); - assertEquals(0, x |= x); - assertEquals(-0, x *= ((tmp = 1317609776.6323466, tmp)*(tmp = -26959885.89325118, tmp))); - assertEquals(0, x >>= (-1288116122.0091262)); - assertEquals(0, x &= ((370818172.92511404)%((tmp = -528319853.54781747, tmp)*(x/((tmp = -2839758076, tmp)^(x+(((-1258213460.041857)<<(tmp = 302017800.72064054, tmp))|((((tmp = -624254210, tmp)^((-338165065.97507)|((623392964)-x)))>>>x)%(tmp = 2767629843.0643625, tmp))))))))); - assertEquals(0, x >>>= x); - assertEquals(0, x >>>= x); - assertEquals(0, x |= ((-2001549164.1988192)*x)); - assertEquals(0, x -= x); - assertEquals(0, x *= (((((165836842.14390492)*(tmp = -3220002961, tmp))|(-2840620221.747431))%((x/(tmp = 3153915610, tmp))>>>(tmp = 2018941558, tmp)))>>>x)); - assertEquals(-0, x *= (-231994402.93764925)); - assertEquals(0, x <<= x); - assertEquals(0, x %= (tmp = 2702385056.1149964, tmp)); - assertEquals(0, x <<= (tmp = 378459323, tmp)); - assertEquals(0, x >>>= ((x&(x&(((-1014963013)<<(x&((tmp = -3110294840, tmp)|(x+(x<<(1129643420))))))+(1093795819.1853619))))+((((tmp = -2295103369.697398, tmp)&(((370501313.43019223)>>>(2465439579))/x))-x)>>x))); - assertEquals(0, x /= ((tmp = 1779625847, tmp)+(tmp = -662459654.6908865, tmp))); - assertEquals(0, x -= x); - assertEquals(0, x %= ((tmp = 2723291421, tmp)|(277246502.4027958))); - assertEquals(0, x ^= (((-2936270162)>>>((((tmp = -2019015609.1648235, tmp)|(47218153))*(-823685284))+x))&(x<<(x*(x|(((tmp = -941955398, tmp)^(tmp = -2365238993.5300865, tmp))-(778674685))))))); - assertEquals(0, x >>>= x); - assertEquals(NaN, x %= x); - assertEquals(0, x &= (-175235975.8858137)); - assertEquals(-2684493800.1062117, x += (tmp = -2684493800.1062117, tmp)); - assertEquals(-1290806265.6063132, x -= (-1393687534.4998984)); - assertEquals(-1290806265, x >>= (((x>>(tmp = -1710112056.4935386, tmp))*(586227650.2860553))<<(tmp = -2918251533.6052856, tmp))); - assertEquals(23470008, x >>>= x); - assertEquals(1668734969, x |= ((-295560682.9663689)^(x|((((tmp = -1183847364, tmp)&(3135327694))+(1679127747.1406744))-((-1895825528)%((tmp = -3180115006, tmp)+((tmp = 2373812187, tmp)|x))))))); - assertEquals(1744306169, x |= (1188503928.5009093)); - assertEquals(1744306169, x %= (tmp = -2723982401.4997177, tmp)); - assertEquals(3488612338, x += x); - assertEquals(3488612337, x += (((x/(-325849204))>>x)|(-1820624550.9149108))); - assertEquals(-1511119305, x ^= (tmp = 1778506182.2952862, tmp)); - assertEquals(-12211415, x %= (x^(tmp = -54943035, tmp))); - assertEquals(-12211415, x %= ((-1267051884)%(-643566443.0122576))); - assertEquals(-30.84976063258681, x /= (((1052047194)>>>x)&(1495698235.5117269))); - assertEquals(-61.69952126517362, x += x); - assertEquals(-244, x <<= (x^(x+(tmp = -2822258210.076373, tmp)))); - assertEquals(-6652, x &= ((tmp = 2593685093, tmp)>>((((2047688852.4609032)<<((x*(-611076291))*x))^(-2665364024.817528))>>>(165267874)))); - assertEquals(0, x -= x); - assertEquals(0, x /= (2454186758)); - assertEquals(0, x &= (tmp = -2226895206, tmp)); - assertEquals(0, x += x); - assertEquals(-21390701, x += ((-1369004846.0816503)>>(tmp = -2661552634.039692, tmp))); - assertEquals(-0.012568536912921919, x /= (1701924507.856429)); - assertEquals(7.09517966608176e-11, x /= (tmp = -177141911.8955555, tmp)); - assertEquals(0, x >>= (tmp = 231535697, tmp)); - assertEquals(1383687797, x ^= (tmp = -2911279499.568808, tmp)); - assertEquals(1383687797, x %= (tmp = -2258636646.5294995, tmp)); - assertEquals(1319, x >>= ((tmp = -2549411892.8426056, tmp)/(((((1532476676)^(153720871.82640445))+x)/(((2988190456.3206205)&(tmp = -2920873674, tmp))-(((((tmp = -1044518167.0581458, tmp)>>x)-((((tmp = -194701879.13505793, tmp)&(498352051))&((tmp = -2167339635.6529818, tmp)^(((x>>(tmp = 700159851, tmp))*(tmp = 2874921158, tmp))/x)))-((2856128689)|((-1876321441)>>>(2110732915)))))^((((tmp = -193379494.18825436, tmp)/(-3055182489.533142))<<x)+((tmp = -2286109605, tmp)>>(tmp = 698475484.3987849, tmp))))^(3182231653.500364))))|(((tmp = -194670835, tmp)>>>((786780139)%(((2114171416.2305853)^(1703145352.8143656))/x)))>>>((tmp = -3029462067, tmp)>>((67647572.02624655)&(x*(-2394283060)))))))); - assertEquals(13903855, x |= ((tmp = -2515306586, tmp)>>>x)); - assertEquals(54311, x >>>= ((-2413722658)-((tmp = -2159787584, tmp)^(tmp = 949937622.9744623, tmp)))); - assertEquals(108622, x += x); - assertEquals(1250717187, x ^= ((tmp = 842692148, tmp)+(((2649331689.694273)<<x)-(tmp = -2992181273, tmp)))); - assertEquals(4536777, x %= (tmp = 73304730, tmp)); - assertEquals(0, x -= x); - assertEquals(-580081499, x ^= ((tmp = -580081499.0170684, tmp)^(x%(tmp = -1542730817.88261, tmp)))); - assertEquals(-1382738784, x <<= x); - assertEquals(-1382738784, x <<= x); - assertEquals(2912228512, x >>>= (x*(x>>>x))); - assertEquals(-1076374105, x |= (2589443367)); - assertEquals(-0.2818750938197037, x /= (((tmp = -1559525732.9603848, tmp)|(-477068917.5483327))>>>((-688616257)*((((tmp = -1192490153.1226473, tmp)*(-502280624.0265591))<<(-442688727.4881985))%(x+(((((tmp = -2948836853.831935, tmp)-(tmp = -2850398330.910424, tmp))>>>(x>>>(-1947835558)))^x)+(x*x))))))); - assertEquals(2032826546, x |= (tmp = 2032826546.819327, tmp)); - assertEquals(3408404827.14316, x += (tmp = 1375578281.1431599, tmp)); - assertEquals(258183922.14315987, x %= (tmp = 350024545, tmp)); - assertEquals(479694848, x <<= (tmp = -481187157, tmp)); - assertEquals(-2147483648, x <<= (((tmp = -2956588045.472398, tmp)>>>(((tmp = -1838455399.1775856, tmp)&(((((tmp = -637547, tmp)/x)&(x^((-44876328.1767962)+(((-2059598286)-(1071496688))%(tmp = -1492254402, tmp)))))-(x%x))*(x|x)))>>(1226250760)))<<x)); - assertEquals(-2288163338.9020815, x -= (140679690.9020816)); - assertEquals(4954833118513997000, x *= (-2165419327.4906025)); - assertEquals(1578331238, x ^= (-2410854298.2270393)); - assertEquals(-810627292, x += (-2388958530)); - assertEquals(-810627292, x ^= ((1495296640.4087524)/(tmp = 1561790291, tmp))); - assertEquals(657116606535253200, x *= x); - assertEquals(0.675840332689047, x %= (((-1816548473)^(((tmp = -151918689.19451094, tmp)|(1819911186.535233))/((((((1514297447)+(tmp = 856485190.9684253, tmp))&(((1809369464.4363992)<<(493538496))*x))+((x*(x>>(x&(tmp = 222293461, tmp))))>>>(((784519621)|x)^((-580766922)>>(tmp = -947264116, tmp)))))>>>((((2794210354.22964)>>>(((2896952532.0183973)*((x+(tmp = -1813175940, tmp))<<(tmp = -1302618293, tmp)))&x))>>(x-(((x|((1456466890.1952953)*x))^(-169979758.19158387))-(x-x))))>>x))&(tmp = 2671604078.3026733, tmp))))/(-1701675745))); - assertEquals(0.675840332689047, x %= ((tmp = 2421871143, tmp)^x)); - assertEquals(NaN, x %= ((((tmp = 1175526323.433271, tmp)+(tmp = 2813009575.952405, tmp))%((tmp = -3112133516.3303423, tmp)&x))&((((((-424329392)^(tmp = 1430146361, tmp))+x)-(1533557337.268306))%((tmp = -3117619446, tmp)-(-3127129232)))>>>x))); - assertEquals(NaN, x += x); - assertEquals(0, x >>>= ((1710641057.7325037)%(104961723.56541145))); - assertEquals(0, x <<= (tmp = -970072906, tmp)); - assertEquals(0, x *= (87768668)); - assertEquals(-1464968122, x ^= (tmp = -1464968122, tmp)); - assertEquals(-1467983895, x ^= ((tmp = -1204896021, tmp)>>>(((91792661)&(x>>>(((-2364345606)>>>x)*x)))+x))); - assertEquals(2.991581508270506, x /= (-490704963.5591147)); - assertEquals(0, x >>>= x); - assertEquals(0, x >>= ((tmp = 639854873, tmp)%(tmp = 743486160.3597239, tmp))); - assertEquals(0, x <<= (tmp = 1045577245.3403939, tmp)); - assertEquals(0, x >>= ((tmp = -1932462290, tmp)|(tmp = 1629217987, tmp))); - assertEquals(517617438, x ^= ((tmp = 2737789043, tmp)%(tmp = -2220171604.135681, tmp))); - assertEquals(126371, x >>>= ((tmp = 205210223.69909227, tmp)-(tmp = 598118404, tmp))); - assertEquals(918548455, x |= ((918228734.8363427)+(x+x))); - assertEquals(918548455, x |= ((tmp = 599828198, tmp)>>((tmp = -851081330, tmp)|(tmp = -1152596996.8443217, tmp)))); - assertEquals(918548443.7739062, x -= ((tmp = 1497642976.2260938, tmp)%(x>>(tmp = -548469702.5849569, tmp)))); - assertEquals(0.7739062309265137, x %= (x&x)); - assertEquals(2317939163.8239403, x *= (tmp = 2995116296, tmp)); - assertEquals(1014415360, x <<= (-279972114)); - assertEquals(0, x &= ((296810932)/(x*(tmp = -2750499950, tmp)))); - assertEquals(0, x *= (x%((126285451.05086231)>>>(x*(tmp = -2789790532, tmp))))); - assertEquals(0, x >>>= ((975695102.5771483)%(x-((-1011726540)-((tmp = 2223194882, tmp)/x))))); - assertEquals(-1747794584, x |= (-1747794584.3839395)); - assertEquals(-543544679, x %= (tmp = -1204249905, tmp)); - assertEquals(-543544679, x %= (-881024001)); - assertEquals(1, x /= x); - assertEquals(-1879376393, x |= ((tmp = 161643764, tmp)|(tmp = 2281346499.9084272, tmp))); - assertEquals(1.321124264431369, x /= (-1422558379.7061746)); - assertEquals(1, x >>>= (x&(tmp = -963118950.4710281, tmp))); - assertEquals(3, x ^= ((x+x)/x)); - assertEquals(1, x /= x); - assertEquals(1, x &= (2090796073)); - assertEquals(-1284301873, x ^= (((-11041168.146357536)+(tmp = -1273260707.8134556, tmp))+x)); - assertEquals(292559045, x &= (x&((-2401110739)^((tmp = 630802904, tmp)^(((1012634447.0346229)+x)%((tmp = -1240091095, tmp)%(x/(-1483936527)))))))); - assertEquals(0, x %= x); - assertEquals(0, x /= (tmp = 613145428.3653506, tmp)); - assertEquals(0, x /= ((x-(tmp = 3116638456, tmp))*(-973300716))); - assertEquals(0, x %= (tmp = -1794741286.0464535, tmp)); - assertEquals(0, x &= x); - assertEquals(0, x >>= (-551370105.0746605)); - assertEquals(-1471996874, x ^= ((2822970422.2331414)-x)); - assertEquals(-277914313, x |= (tmp = -818980601.2544096, tmp)); - assertEquals(-34, x >>= x); - assertEquals(305422768, x -= (-305422802)); - assertEquals(-2406146240, x += (tmp = -2711569008, tmp)); - assertEquals(1073745408, x &= (tmp = -3046625618, tmp)); - assertEquals(1073745408, x <<= ((-1234108306.7646303)<<((-233519302)|x))); - assertEquals(1073745408, x %= (tmp = 1898831268, tmp)); - assertEquals(1073745408, x <<= (((tmp = 3089406038, tmp)/x)&(-2960027680))); - assertEquals(65536, x >>>= (2858188366)); - assertEquals(128, x >>>= ((-2640257239.857275)%((tmp = -3185405235.3177376, tmp)*x))); - assertEquals(128, x >>>= x); - assertEquals(128, x -= (x&(x-(tmp = -247588018, tmp)))); - assertEquals(81616906825.07776, x *= (tmp = 637632084.57092, tmp)); - assertEquals(78860097686.07776, x -= (((1507215684)^((709254783)+(((x<<x)*((-2890828152.667641)%(2537817529.2041526)))^x)))+(3114024487))); - assertEquals(-2920545695.721283, x += (((tmp = -2555437435, tmp)>>>x)-((2920546109.72129)+x))); - assertEquals(-2879412281.721283, x += ((-1662428756)>>>(tmp = -1928491386.6926208, tmp))); - assertEquals(67403845, x &= (tmp = 2921644117, tmp)); - assertEquals(16850961, x >>>= (((-1039328365)>>>(tmp = -768615112, tmp))<<((1037261855)*(tmp = -2906902831.4797926, tmp)))); - assertEquals(0, x ^= x); - assertEquals(0, x *= ((-2729056530)/((-1776175111)%(1493002300.4604707)))); - assertEquals(0, x *= (tmp = 370696035.22912216, tmp)); - assertEquals(0, x ^= x); - assertEquals(0, x |= ((((((tmp = -1541196993, tmp)^x)/(854730380.1799632))/(2879117705.492209))+((((-2892068577)^(-2460614446.1044483))>>>((743413943)<<(-1285280084.4220598)))/(tmp = -1719994579.5141463, tmp)))%(((((tmp = 2522797851.088227, tmp)<<(tmp = 2257160597.1538725, tmp))/(-680406007))&((x>>>(tmp = -260350730, tmp))^(tmp = 1920522110.852598, tmp)))>>(-697620442)))); - assertEquals(0, x &= x); - assertEquals(-591399642.958673, x += (x-(tmp = 591399642.958673, tmp))); - assertEquals(27, x >>>= (tmp = -726721317.2109983, tmp)); - assertEquals(-2043736843, x -= (2043736870)); - assertEquals(-3991674, x >>= (tmp = 1098126089, tmp)); - assertEquals(-997919, x >>= ((x%(((x*(((-1497329257.1781685)%(2334511329.2690516))/(-3072526140.6635056)))+(-1843998852))-(tmp = 240300314.34070587, tmp)))+(714080860.6032693))); - assertEquals(-0, x %= x); - assertEquals(NaN, x /= x); - assertEquals(0, x >>= (tmp = 538348328.5363884, tmp)); - assertEquals(0, x *= (800317515)); - assertEquals(0, x -= x); - assertEquals(0, x >>= (984205514)); - assertEquals(857282491, x += (tmp = 857282491, tmp)); - assertEquals(587792897, x &= (tmp = 2951307845.164059, tmp)); - assertEquals(595301269, x |= (tmp = 24285588.90314555, tmp)); - assertEquals(1190602538, x += x); - assertEquals(0, x -= x); - assertEquals(-442423060, x |= ((x^((x-(tmp = 2342497475.637024, tmp))%(-1900074414.7678084)))|((tmp = 1932380130, tmp)%(x%(2291727569.817062))))); - assertEquals(-442423060, x %= (((tmp = 703479475.545413, tmp)>>(x-x))<<(2435723056.753845))); - assertEquals(1, x /= x); - assertEquals(0, x >>= x); - assertEquals(-1265317851, x |= (tmp = -1265317851, tmp)); - assertEquals(-2, x >>= (-2015895906.8256726)); - assertEquals(-0, x %= x); - assertEquals(-0, x %= (((1219237746)+(284683029))*(((tmp = 2288119628, tmp)|(-404658161.2563329))*(-265228691.74142504)))); - assertEquals(1039509109, x -= (-1039509109)); - assertEquals(2079018218, x += x); - assertEquals(-1979.9362673719077, x /= ((3219723500)>>x)); - assertEquals(-62, x >>= ((x/(326466691))*(tmp = -607654070, tmp))); - assertEquals(-45, x |= (tmp = -2954888429.549882, tmp)); - assertEquals(-1180929712, x &= (3114037588.570232)); - assertEquals(815550480, x &= (-2302684143.3378315)); - assertEquals(815550480, x %= (-2177479570)); - assertEquals(815550480, x %= (tmp = 2895822167, tmp)); - assertEquals(815550480, x %= (-1247621230.5438688)); - assertEquals(283929811, x -= ((tmp = 251831053.17096448, tmp)|((tmp = 1140463506.004994, tmp)+(tmp = -743224673.546309, tmp)))); - assertEquals(1825767424, x <<= (((tmp = 1732353599, tmp)^(tmp = 658726044, tmp))>>>((-2827889370.932477)%(tmp = 1950139204.3291233, tmp)))); - assertEquals(1828450414, x |= (tmp = 1618538606, tmp)); - assertEquals(0, x <<= (-2411670689.045702)); - assertEquals(0, x <<= (-27744888.428537607)); - assertEquals(-0, x /= (tmp = -1597552450, tmp)); - assertEquals(0, x >>>= (((2165722776.7220936)>>>(tmp = 1233069931, tmp))>>>(-1120420811))); - assertEquals(-0, x *= ((tmp = -1505252656, tmp)>>((((3035637099.6156535)&((467761577.7669761)>>(-361034537)))^(tmp = -2347994840.6541123, tmp))*(tmp = -2191739821, tmp)))); - assertEquals(0, x &= (795727404.0738752)); - assertEquals(-0, x *= (tmp = -3125944685.3991394, tmp)); - assertEquals(-0, x *= (x&x)); - assertEquals(0, x >>= ((tmp = -2045709233, tmp)^x)); - assertEquals(NaN, x /= (x>>(x/(3102894071)))); - assertEquals(NaN, x += ((tmp = 2149079756.8941655, tmp)-(tmp = 810121645.305179, tmp))); - assertEquals(0, x >>>= (-859842989)); - assertEquals(0, x >>>= (tmp = 2530531143.9369526, tmp)); - assertEquals(0, x >>= (((-932981419.6254237)|(tmp = 1591591715, tmp))>>>(x+((3149795006)>>>(tmp = 613352154, tmp))))); - assertEquals(-4294967295, x -= ((((-2289331668)%(-282648480.0078714))>>(-1373720705.5142756))>>>((tmp = 15511563.517014384, tmp)/(360279080)))); - assertEquals(1, x &= x); - assertEquals(0, x >>= (x^(-2791872557.5190563))); - assertEquals(0, x &= ((tmp = 336466956.7847167, tmp)>>((1235728252.053619)|(x<<((1828176636.13488)%x))))); - assertEquals(-0, x *= (-364042830.8894656)); - assertEquals(0, x >>>= x); - assertEquals(-1675298680, x |= ((2323049541.321387)+(296619075))); - assertEquals(-0, x %= x); - assertEquals(-1583048579.4420977, x += (-1583048579.4420977)); - assertEquals(0, x -= x); - assertEquals(-2, x ^= ((603171992.0545617)/(((-271888695.718297)%(tmp = -400159585, tmp))^((((tmp = 1536123971, tmp)-(tmp = -2310418666.6243773, tmp))|((tmp = 2242779597.1219435, tmp)<<(tmp = 1758127684.4745512, tmp)))/x)))); - assertEquals(-2, x &= (x&x)); - assertEquals(0, x &= ((tmp = -1098806007.4049063, tmp)/(((2862384059.3229523)/((((tmp = -92960842, tmp)-(x>>(tmp = 1244068344.2269042, tmp)))&x)*(tmp = -1919148313, tmp)))<<(-2486665929)))); - assertEquals(0, x &= x); - assertEquals(-1441272634.582818, x -= (1441272634.582818)); - assertEquals(-3, x >>= (tmp = 3186393693.7727594, tmp)); - assertEquals(-1206855850, x ^= (((tmp = 607979495.303539, tmp)-(tmp = -2480131951, tmp))^(x*((tmp = 1324153477, tmp)/((1248126288)+(x|(1917331780.0741704))))))); - assertEquals(-1206855853, x ^= (x>>>(653288765.1749961))); - assertEquals(-1206857725, x &= (3149461539.6019173)); - assertEquals(3088109571, x >>>= (x*(x<<(tmp = 1543540084, tmp)))); - assertEquals(536903680, x &= (tmp = 644851760, tmp)); - assertEquals(536903674.312194, x += (((-3183290076)-((tmp = 40738191.12097299, tmp)-x))/((x>>>(3151371851.9408646))^(tmp = 472698205.22445416, tmp)))); - assertEquals(2127424750.0506563, x -= (tmp = -1590521075.7384624, tmp)); - assertEquals(2127424750.0506563, x %= (tmp = 3027273433.361373, tmp)); - assertEquals(0, x >>= (x>>(1445204441.702043))); - assertEquals(NaN, x %= (x<<x)); - assertEquals(0, x ^= ((tmp = -2903841152.136344, tmp)-(x%(2938662860)))); - assertEquals(0, x <<= (x<<x)); - assertEquals(0, x >>>= (tmp = -979481631.33442, tmp)); - assertEquals(0, x >>= x); - assertEquals(0, x &= (((x%((((((tmp = 1657446354.6820035, tmp)>>(-1916527001.2992697))/x)>>(tmp = 1450467955, tmp))&(277676820))+(x/(-945587805))))/((tmp = -690095354, tmp)^x))+(tmp = -2651195021, tmp))); - assertEquals(0, x <<= (752343428.2934296)); - assertEquals(0, x /= (tmp = 3022310299, tmp)); - assertEquals(0, x >>= (x%((388245402)>>>x))); - assertEquals(NaN, x %= x); - assertEquals(NaN, x %= ((tmp = 1205123529.8649468, tmp)>>>(-2848300932))); - assertEquals(0, x >>= ((x>>>x)<<(tmp = 487841938, tmp))); - assertEquals(0, x *= (((273436000.9463471)|(tmp = 141134074.27978027, tmp))^(tmp = 1220326800.7885802, tmp))); - assertEquals(1525600768, x |= (((x^(-2674777396))-(tmp = 1966360716.3434916, tmp))<<(794782595.9340223))); - assertEquals(761927595, x %= (tmp = -763673173, tmp)); - assertEquals(1.1353588586934338, x /= ((x&((-1897159300.4789193)*(-348338328.0939896)))&(978680905.6470605))); - assertEquals(8.631173314966319e-10, x /= (1315416592)); - assertEquals(0, x >>= ((tmp = -2581239435, tmp)-((-628818404.1122074)<<x))); - assertEquals(0, x -= x); - assertEquals(0, x *= (2925158236)); - assertEquals(0, x /= (x+(tmp = 1405531594.0181243, tmp))); - assertEquals(0, x *= (2712022631.230831)); - assertEquals(0, x >>= (tmp = 80518779.81608999, tmp)); - assertEquals(1953477932.8046472, x += (tmp = 1953477932.8046472, tmp)); - assertEquals(1953477932, x >>= (tmp = 3025539936, tmp)); - assertEquals(1953477932, x -= ((-2675119685.8812313)>>(x/(-1808264410.9754841)))); - assertEquals(1292620430, x += ((-660857502)%((((tmp = -698782819, tmp)%(tmp = 2847304199, tmp))<<(-2423443217.1315413))+x))); - assertEquals(78895, x >>>= x); - assertEquals(2, x >>= x); - assertEquals(2, x <<= (tmp = 1313641888.8301702, tmp)); - assertEquals(1857416935.2532766, x += (tmp = 1857416933.2532766, tmp)); - assertEquals(-1677721600, x <<= (tmp = -2482476902, tmp)); - assertEquals(309226853.62854385, x -= (tmp = -1986948453.6285439, tmp)); - assertEquals(33965156, x &= (2409088742)); - assertEquals(Infinity, x /= (x-(x<<((x/(tmp = -3106546671.536726, tmp))/((tmp = 2695710176, tmp)-((((-2102442864)&(857636911.7079853))/x)%(-65640292))))))); - assertEquals(1270005091, x |= (tmp = 1270005091.0081215, tmp)); - assertEquals(1270005091, x %= (tmp = -1833876598.2761571, tmp)); - assertEquals(158750636, x >>>= x); - assertEquals(-1000809106.0879555, x -= (tmp = 1159559742.0879555, tmp)); - assertEquals(72400936, x &= ((2448271389.3097963)%(tmp = 1517733861, tmp))); - assertEquals(282816, x >>= x); - assertEquals(282816, x %= (tmp = 3192677386, tmp)); - assertEquals(0.00021521351827207216, x /= (1314118194.2040696)); - assertEquals(Infinity, x /= (((tmp = 2822091386.1977024, tmp)&x)%(tmp = -3155658210, tmp))); - assertEquals(NaN, x %= (-359319199)); - assertEquals(0, x >>>= (((tmp = -2651558483, tmp)-(x<<(tmp = 2537675226.941645, tmp)))<<(tmp = 667468049.0240343, tmp))); - assertEquals(-0, x *= (tmp = -2827980482.12998, tmp)); - assertEquals(-0, x %= (((tmp = -689972329.3533998, tmp)>>>x)|(tmp = -7488144, tmp))); - assertEquals(0, x >>>= x); - assertEquals(0, x |= x); - assertEquals(-2410373675.2262926, x -= (2410373675.2262926)); - assertEquals(1840423, x >>= ((-1081642113)^x)); - assertEquals(-4829451429403412, x *= (-2624098606.35485)); - assertEquals(-94552231, x %= (tmp = -97015883, tmp)); - assertEquals(-94433287, x ^= (((tmp = -2297735280, tmp)&(((tmp = 2261074987.7072973, tmp)%((((2565078998)^(-2573247878))|x)|(((tmp = -2120919004.7239416, tmp)>>(tmp = -579224101, tmp))>>>(1905808441))))*(x|(3149383322))))>>(542664972))); - assertEquals(0, x ^= (x<<(tmp = -3112569312, tmp))); - assertEquals(0, x <<= (-2141934818.7052917)); - assertEquals(0, x >>= (tmp = -2539525922, tmp)); - assertEquals(-434467613, x ^= (tmp = -434467613, tmp)); - assertEquals(-274792709, x |= (1233452601.462551)); - assertEquals(-274726917, x |= (-2130333750)); - assertEquals(-272629761, x |= (-1516071602.5622227)); - assertEquals(-272629761, x |= ((tmp = 3012131694, tmp)&((tmp = -2595342375.8674774, tmp)-((tmp = -2710765792, tmp)>>>((x-(tmp = 2397845540, tmp))+(2496667307)))))); - assertEquals(-4194305, x |= (1343705633.165825)); - assertEquals(4190207, x >>>= ((tmp = 276587830, tmp)*((tmp = -1517753936, tmp)>>x))); - assertEquals(0, x >>= (x|((2247486919)-((-1664642412.4710495)*((((tmp = -358185292.17083216, tmp)-(tmp = -1472193444, tmp))*(tmp = 2699733752, tmp))&((x|(x<<(1137610148.1318119)))>>(((375089690.8764564)*x)&(tmp = 859788933.9560187, tmp)))))))); - assertEquals(0, x %= (3080673960)); - assertEquals(0, x >>>= (1328846190.1963305)); - assertEquals(1249447579, x |= (-3045519717.580775)); - assertEquals(-0.8743931060971377, x /= (-1428931187)); - assertEquals(1, x |= ((tmp = -1756877535.7557893, tmp)/((-142900015.93200803)<<(1414557031.347334)))); - assertEquals(759627265, x ^= (759627264.0514802)); - assertEquals(741823, x >>= (1106391210)); - assertEquals(610451, x &= ((x>>>((919849416)+((tmp = -427708986, tmp)^((x%x)|(tmp = -2853100288.932063, tmp)))))*x)); - assertEquals(372650423401, x *= x); - assertEquals(410404493, x >>>= ((((-1425086765)>>>x)>>((2813118707.914771)>>(-424850240)))^x)); - assertEquals(120511585729013, x *= ((tmp = -1889454669, tmp)>>>x)); - assertEquals(120513295294304.22, x -= (tmp = -1709565291.2115698, tmp)); - assertEquals(6164, x >>>= ((2244715719.397763)^(tmp = -741235818.6903033, tmp))); - assertEquals(937572790.468221, x -= (tmp = -937566626.468221, tmp)); - assertEquals(937572790, x |= ((2129102867.156146)*(x%x))); - assertEquals(32, x &= ((2700124055.3712993)>>>((1977241506)>>>(-2915605511)))); - assertEquals(32, x %= (tmp = -2513825862, tmp)); - assertEquals(0, x <<= (-1379604802)); - assertEquals(0, x >>>= (tmp = -1033248759, tmp)); - assertEquals(-1151517050, x ^= (3143450246)); - assertEquals(-180577, x |= ((738373819.4081701)^(-357134176))); - assertEquals(-0, x %= x); - assertEquals(-2086887759, x |= (tmp = 2208079537, tmp)); - assertEquals(-2, x >>= (1460216478.7305799)); - assertEquals(-2, x %= ((-1979700249.0593133)^(-3156454032.4790583))); - assertEquals(-256, x <<= ((1810316926)>>>(tmp = 414362256, tmp))); - assertEquals(-1, x >>= (((((((-1616428585.595561)*((tmp = 2574896242.9045777, tmp)|(86659152.37838173)))>>(((tmp = 2476869361, tmp)&((x+((tmp = -2445847462.1974697, tmp)>>(tmp = -1960643509.5255682, tmp)))+(x|(((((2231574372.778028)|(tmp = 1824767560, tmp))>>>((1108035230.2692142)|(tmp = 2354035815, tmp)))/((tmp = -2602922032, tmp)>>(-925080304.7681987)))-x))))-(x>>x)))>>>((tmp = 751425805.8402164, tmp)|(tmp = 1165240270.3437088, tmp)))-x)*(2870745939))-(x>>>((tmp = 2986532631.405425, tmp)>>>(((tmp = 2547448699, tmp)+(((((x<<(((((-2756908638.4197435)>>>(3134770084))-(-1147872642.3756688))%(x*(tmp = -282198341.6600039, tmp)))+(-770969864.2055655)))+((-2725270341)^x))/(-3093925722))>>(x&x))>>((tmp = -2705768192, tmp)>>>(((tmp = 577253091.6042917, tmp)/(((x&(((((x+x)>>>(-1000588972))/(x&(717414336)))^(tmp = 428782104.21504414, tmp))>>>(1084724288.953223)))%(tmp = -2130932217.4562194, tmp))&x))-(-286367389)))))+((x>>(tmp = 2001277117, tmp))>>((tmp = 1028512592, tmp)^((tmp = 2055148650, tmp)+((tmp = 1490798399, tmp)/(tmp = -2077566434.2678986, tmp)))))))))); - assertEquals(-1, x |= (tmp = 1542129482, tmp)); - assertEquals(-671816743, x &= (tmp = -671816743.9111726, tmp)); - assertEquals(-1840333080, x -= (1168516337)); - assertEquals(-1755382023, x |= ((((tmp = 2625163636.0142937, tmp)>>>((tmp = 1534304735, tmp)^x))-(tmp = -1959666777.9995313, tmp))%x)); - assertEquals(-1750421896, x += (x>>>(tmp = -1364828055.1003118, tmp))); - assertEquals(-72864007, x %= (tmp = 239651127, tmp)); - assertEquals(-72863956, x -= (((tmp = -1103261657.626319, tmp)*((tmp = 2789506613, tmp)+((tmp = 2294239314, tmp)>>>(2588428607.5454817))))>>x)); - assertEquals(-170337477, x -= (tmp = 97473521, tmp)); - assertEquals(-170337477, x |= (((tmp = 246292300.58998203, tmp)/(((tmp = -2664407492, tmp)|((-2416228818)^(tmp = 909802077, tmp)))%(tmp = 532643021.68109465, tmp)))/(tmp = 1015597843.8295637, tmp))); - assertEquals(1, x >>>= (((tmp = -2247554641.7422867, tmp)/(1186555294))%(tmp = -785511772.3124621, tmp))); - assertEquals(1188939891.668705, x -= (tmp = -1188939890.668705, tmp)); - assertEquals(1188939891, x &= x); - assertEquals(1188413555, x &= (((tmp = -372965330.5709038, tmp)%(((tmp = 3108909487, tmp)|(x^(-1056955571.9951684)))^(-1549217484.009048)))/(x>>>(1403428437.9368362)))); - assertEquals(-0.7343692094664643, x /= (-1618278026.4758227)); - assertEquals(0, x -= x); - assertEquals(0, x &= (-2701762139.7500515)); - assertEquals(0, x >>>= (((-1692761485.2299166)^x)+(tmp = -1221349575.938864, tmp))); - assertEquals(0, x <<= ((2148160230)<<x)); - assertEquals(0, x <<= (((x<<(-740907931.38363))&(tmp = -930960051.6095045, tmp))>>(x/((tmp = -1921545150.1239789, tmp)/(-3015379806))))); - assertEquals(0, x <<= x); - assertEquals(NaN, x /= (x|x)); - assertEquals(0, x >>= (tmp = -2265988773, tmp)); - assertEquals(-0, x *= (((x<<(-928153614))<<(-989694208))^(2544757713.481016))); - assertEquals(0, x >>= ((tmp = 578009959.5299993, tmp)>>x)); - assertEquals(0, x /= ((((tmp = 412689800.0431709, tmp)&(1630886276))*(tmp = 2028783080.7296097, tmp))/x)); - assertEquals(0, x |= ((((x*(-2197198786))>>((2719887264.761987)<<(tmp = 2253246512, tmp)))-(tmp = -150703768.07045603, tmp))/(((-3160098146)%(((((1486098047.843547)>>(((tmp = -593773744.1144242, tmp)&(x<<(2651087978)))|((-680492758.930413)>>(tmp = 88363052.13662052, tmp))))<<x)<<(tmp = 2232672341, tmp))/((x<<x)&(((((348589117.64135563)<<(-1010050456.3097556))^(x/(tmp = -2282328795, tmp)))-(tmp = 1653716293, tmp))-((3157124731)/((tmp = 3007369535.341745, tmp)%(tmp = -2246556917, tmp)))))))+x))); - assertEquals(0, x >>= ((1935211663.5568764)>>(x-(tmp = 2116580032, tmp)))); - assertEquals(-1725272693, x ^= (tmp = -1725272693, tmp)); - assertEquals(313683, x >>>= (-1782632531.2877684)); - assertEquals(0.009772287443565642, x /= (tmp = 32099240, tmp)); - assertEquals(-647945916.9902277, x += (-647945917)); - assertEquals(3647021380, x >>>= ((((((((2470411371.688199)<<x)>>x)-(x>>>((tmp = 1750747780, tmp)/x)))-x)<<(tmp = -2666186351.695101, tmp))^(((tmp = 2749205312.6666174, tmp)%x)&(2069802830.360536)))<<(tmp = 6051917.9244532585, tmp))); - assertEquals(-647939220, x |= ((x>>>((tmp = -2980404582.794245, tmp)>>>(-996846982)))^x)); - assertEquals(-572178450, x |= ((-800571300.3277931)+(tmp = 2084365671, tmp))); - assertEquals(1172311208, x &= (x&((tmp = -1207487657.8953774, tmp)^x))); - assertEquals(12176516458994, x += ((((tmp = -1534997221, tmp)%(412142731))*((tmp = 2958726303, tmp)>>(1489169839)))+(((-574726407.2051775)>>>(((1772885017)<<(947804536.9958035))>>(-2406844737)))>>x))); - assertEquals(-1480065024, x <<= x); - assertEquals(-1736999042.227129, x += (tmp = -256934018.22712898, tmp)); - assertEquals(-1338699394, x ^= ((((((x%(((tmp = -2551168455.222048, tmp)|(3213507293.930222))/((-1559278033)>>((tmp = 3107774495.3698573, tmp)-(2456375180.8660913)))))*((x*(tmp = 1088820004.8562922, tmp))+((tmp = 1850986704.9836102, tmp)%(tmp = -1226590364, tmp))))*(1786192008))&(((2193303940.310299)%(tmp = 1041726867.0602217, tmp))|((2210722848)/((-1293401295.6714435)&((tmp = 3052430315, tmp)|x)))))>>>(tmp = -2028014470.1524236, tmp))+(((1695818039.0383925)<<((1669068145)*(-2746592133.899276)))<<(tmp = 519092169, tmp)))); - assertEquals(-334674849, x >>= (1170377794)); - assertEquals(-10214, x >>= ((tmp = 1074704264.3712895, tmp)>>>((tmp = -1200860192, tmp)^((tmp = 539325023.4101218, tmp)*((tmp = -588989295, tmp)|x))))); - assertEquals(1384169472, x &= (1384171140)); - assertEquals(1384169472, x >>>= ((tmp = -2161405973.830981, tmp)*(tmp = 2054628644, tmp))); - assertEquals(1610140972, x |= (527961388)); - assertEquals(1073273198, x += ((tmp = -259650225.71344328, tmp)&(tmp = -344359694, tmp))); - assertEquals(65507, x >>= ((x<<((tmp = 2925070713.5245204, tmp)%(x+((tmp = -1229447799, tmp)/(((x/(x|(((-2337139694)|((((((2996268529.7965417)&x)%(((tmp = -1088587413, tmp)>>(-1384104418.90339))>>((tmp = -1643984822.3946526, tmp)+x)))%(((1118125268.4540217)-((((-1975051668.6652594)-(-704573232))+((tmp = 1674952373, tmp)/(tmp = 1321895696.0062659, tmp)))*(tmp = 1820002533.2021284, tmp)))>>>(tmp = -583960746.9993203, tmp)))|((tmp = -2577675508.550925, tmp)&x))/(tmp = 1459790066, tmp)))/(((((1051712301.7804044)&(tmp = -2726396354, tmp))^(tmp = 263937254.18934345, tmp))+(((x^x)*(((tmp = -2289491571, tmp)+x)%(-2239181148)))&x))>>(tmp = -1743418186.3030887, tmp)))))/(tmp = 1475718622, tmp))<<x)))))|(x&((((tmp = -2934707420, tmp)<<x)/x)^(1022527598.7386684))))); - assertEquals(2047, x >>= (x-(tmp = 2300626270, tmp))); - assertEquals(8384512, x <<= (tmp = -1917680820, tmp)); - assertEquals(0, x <<= (2393691134)); - assertEquals(0, x >>= x); - assertEquals(649995936.5853252, x -= (tmp = -649995936.5853252, tmp)); - assertEquals(649995936, x &= x); - assertEquals(-0.33672017582945424, x /= (tmp = -1930374188, tmp)); - assertEquals(-0.33672017582945424, x += (x&((1208055031)^(-2761287670.968586)))); - assertEquals(0, x |= x); - assertEquals(0, x <<= ((-2038368978)/x)); - assertEquals(0, x >>= (x&((tmp = 2481378057.738218, tmp)&(x+(1172701643))))); - assertEquals(0, x <<= ((x*(((((((tmp = 70690601.3046323, tmp)&(((((((((((x+(x+(x^(3118107461))))<<(264682213.41888392))&(tmp = -709415381.8623683, tmp))%(((((-1840054964)>>>(tmp = -405893120.89603686, tmp))|((-625507229)^(3128979265)))>>(x>>((tmp = -2480442390, tmp)*((x>>(tmp = -421414980.88330936, tmp))>>>((tmp = 1850868592, tmp)&(-2948543832.879225))))))|((2986545185)&((tmp = -1947550706, tmp)%(((tmp = 2590238422.1414256, tmp)/(((tmp = -361038812, tmp)>>x)|(((tmp = 1798444068, tmp)|((x&((tmp = -3104542069, tmp)-x))*((tmp = -1158658918, tmp)+((tmp = 2777031040.5552707, tmp)<<(-2816019335.9008327)))))<<x)))/(((2287795988.231702)/x)/(((-2588712925)>>>(2521189250))*((tmp = -2533527920, tmp)+(tmp = 1762281307.2162101, tmp)))))))))/x)/(tmp = 1047121955.5357032, tmp))|(((-121292251)<<(x^(x-(tmp = 1420006180, tmp))))%((-2278606219)>>>(((tmp = -1412487726, tmp)&(((((tmp = 253596554.16016424, tmp)/(tmp = 2083376247.0079951, tmp))^(x^((1549116789.8449988)>>>((((-1844170084)^(tmp = 1886066422, tmp))&x)<<(34918329)))))^(tmp = -440805555.3369155, tmp))-x))%(-1936512969)))))+(2911511178.4035435))|(1012059391))|(x>>>(tmp = -2551794626.158037, tmp)))+((2926596072.210515)/(tmp = -280299595.0450909, tmp))))&((tmp = 1501086971, tmp)^(tmp = 2114076983, tmp)))-((-1679390574.1466925)-(941349044)))-((x>>x)>>((-2600539474.2033434)+(tmp = 2567056503.9079475, tmp))))*(tmp = 1285896052, tmp))%(((tmp = 1191465410.7595167, tmp)>>((tmp = -2857472754, tmp)%x))>>>(((tmp = 1960819627.6552541, tmp)&(-2651207221.127376))*((((-687312743)+((x>>x)<<x))|((((((1549588195)*((tmp = 2733091019, tmp)^((527322540)<<(x>>x))))%(tmp = -2063962943, tmp))*x)*(734060600))&(-3049417708)))+(((((1084267726)+((x|x)^((tmp = -1917070472.4858549, tmp)%((690016078.9375831)*x))))%((((((tmp = -2091172769, tmp)%(2532365378))>>>(-871354260))/(tmp = 254167019.07825458, tmp))&(1330216175.9871218))>>(tmp = 1931099207, tmp)))^(-1116448185.2618852))>>((961660080.8135855)/x)))))))>>>(-1486048007.7053368))); - assertEquals(0, x >>= x); - assertEquals(0, x %= (tmp = -1202200444.6506357, tmp)); - assertEquals(-0, x *= (-527500796.4145117)); - assertEquals(0, x >>= (tmp = -2082822707, tmp)); - assertEquals(0, x *= ((-1882398459.290778)>>>x)); - assertEquals(0, x &= (x/(tmp = -1569332286.392817, tmp))); - assertEquals(-390169607, x |= (-390169607.11600184)); - assertEquals(-780339214, x += x); - assertEquals(-780339214, x %= (2765959073)); - assertEquals(-5954, x >>= (tmp = -1900007055, tmp)); - assertEquals(743563420, x &= ((((-1520146483.5367205)|(-2075330284.3762321))-(tmp = -2263151872, tmp))%(-1264641939.957402))); - assertEquals(1487126840, x += (x>>>(((x+((tmp = -1263274491, tmp)>>>x))&(470419048.0490037))%(tmp = -2642587112, tmp)))); - assertEquals(Infinity, x /= (x^x)); - assertEquals(0, x ^= ((tmp = -1436368543, tmp)+(x/(tmp = -1125415374.3297129, tmp)))); - assertEquals(0, x += x); - assertEquals(0, x <<= x); - assertEquals(0, x &= (tmp = 3101147204.2905564, tmp)); - assertEquals(0, x &= (tmp = 2914487586.606511, tmp)); - assertEquals(0, x += x); - assertEquals(0, x -= (((-1738542908.6138556)&(((x+x)-(tmp = -2801153969, tmp))%(tmp = -1206684064.1477358, tmp)))>>((-2575546469.271897)|(tmp = -2573119106, tmp)))); - assertEquals(-1468808707, x ^= (tmp = -1468808707, tmp)); - assertEquals(1357349882, x <<= (tmp = -2808501087.7003627, tmp)); - assertEquals(-572025862, x |= ((((tmp = -2415486246.573399, tmp)/((tmp = -707895732.4593301, tmp)&x))%((-1960091005.0425267)*(972618070.9166157)))-(1649962343))); - assertEquals(327213586796843100, x *= (x%(1337884626))); - assertEquals(42991616, x &= (-2905576654.1280055)); - assertEquals(-26049289585042860, x *= (-605915571.6557121)); - assertEquals(597809748, x >>= ((362850791.077795)/(tmp = 1222777657.4401796, tmp))); - assertEquals(597809748, x |= x); - assertEquals(770065246, x -= ((-711227660)|(tmp = -508554506, tmp))); - assertEquals(593000483097040500, x *= x); - assertEquals(0, x %= x); - assertEquals(0, x <<= (317862995.456813)); - assertEquals(0, x >>= ((tmp = 2518385735, tmp)+((-2973864605.267604)/(-930953312.718833)))); - assertEquals(1227822411, x ^= (x^(1227822411.8553264))); - assertEquals(1090520320, x &= (x+((((-2100097959)>>(x/(tmp = -2002285068, tmp)))/(-364207954.9242482))-((tmp = 2771293106.7927113, tmp)-(tmp = -847237774, tmp))))); - assertEquals(1090520320, x >>= (((((2439492849)<<((-2932672756.2578926)*((743648426.7224461)+((2942284935)<<((x/(((tmp = 886289462.6565771, tmp)+(-459458622.7475352))>>(tmp = -785521448.4979162, tmp)))|(tmp = -11630282.877367258, tmp))))))-(tmp = -647511106.9602091, tmp))^x)&x)); - assertEquals(115944291.48829031, x %= (243644007.12792742)); - assertEquals(1, x /= x); - assertEquals(0, x >>>= ((tmp = -819782567, tmp)%(tmp = 2774793208.1994505, tmp))); - assertEquals(0, x >>= (tmp = 721096000.2409859, tmp)); - assertEquals(0, x &= ((x%x)%x)); - assertEquals(-0, x *= ((-1670466344)<<x)); - assertEquals(0, x >>= (-677240844.904707)); - assertEquals(NaN, x %= (((((-1575993236.6126876)/(-2846264078.9581823))^((((-2220459664)-(((-1809496020)>>>(tmp = -3015964803.4566207, tmp))&x))/(tmp = -3081895596.0486784, tmp))>>>(x&x)))%(x^(-1338943139)))^(x-((((2074140963.2841332)^(tmp = 1878485274, tmp))%(((x/(-2568856967.6491556))^x)<<((x+x)^((((2139002721)|(x<<(-1356174045.840464)))>>x)-(tmp = 2305062176, tmp)))))>>>(((((x<<(tmp = -1663280319.078543, tmp))-((1498355849.4158854)-((-1321681257)>>>(tmp = -1321415088.6152222, tmp))))^(-2266278142.1584673))+(858538943))&((((x-((x|(((tmp = -1576599651, tmp)+((tmp = 1595319586, tmp)&(-2736785205.9203863)))>>((x+((-1856237826)+x))<<(tmp = -1590561854.3540869, tmp))))^(((-41283672.55606127)&(tmp = 2971132248, tmp))+x)))/(-849371349.1667476))%(x*((-1705070934.6892798)>>>x)))<<((2418200640)*x))))))); - assertEquals(0, x >>>= (tmp = 664214199.5283061, tmp)); - assertEquals(0, x <<= ((-2827299151)<<(1815817649))); - assertEquals(1405772596, x |= (tmp = 1405772596, tmp)); - assertEquals(-1483422104, x <<= (-2791499935.6822596)); - assertEquals(-45271, x >>= (1740128943.4254808)); - assertEquals(-45271, x <<= ((2072269957)-((tmp = -2553664811.4472017, tmp)*(tmp = -2502730352, tmp)))); - assertEquals(1192951471.6745887, x -= (-1192996742.6745887)); - assertEquals(-353370112, x <<= (tmp = -1410280844, tmp)); - assertEquals(0, x ^= (x%((2754092728)*(-1017564599.1094015)))); - assertEquals(-2662096003.2397957, x -= (tmp = 2662096003.2397957, tmp)); - assertEquals(-2587094028.50764, x -= (tmp = -75001974.7321558, tmp)); - assertEquals(6693055512339889000, x *= x); - assertEquals(897526784, x %= (x-((tmp = 897526813, tmp)%(-1525574090)))); - assertEquals(7011928, x >>= ((-440899641.344357)%x)); - assertEquals(8382047686388683, x += (x*(1195398423.8538609))); - assertEquals(16764095372777366, x += x); - assertEquals(16764096859576696, x -= (tmp = -1486799329.7207344, tmp)); - assertEquals(16764099774187724, x += (2914611029)); - assertEquals(16764102926624664, x -= (-3152436939.724612)); - assertEquals(-538220648, x |= x); - assertEquals(269110324, x /= (((-2114698894.6014318)/(tmp = 767687453, tmp))>>(623601568.1558858))); - assertEquals(256, x >>= x); - assertEquals(-293446891, x += (x+(-293447403))); - assertEquals(119, x >>>= ((1759400753)>>(2481263470.4489403))); - assertEquals(14, x >>= (762849027.89693)); - assertEquals(16, x += (x&(x>>(1104537666.1510491)))); - assertEquals(-12499808227.980995, x *= (tmp = -781238014.2488122, tmp)); - assertEquals(1, x /= x); - assertEquals(1, x &= x); - assertEquals(0, x >>>= ((tmp = 1513381008, tmp)|(tmp = 1593208075.7259543, tmp))); - assertEquals(0, x &= (-788154636.2843091)); - assertEquals(-0, x /= (tmp = -2124830879, tmp)); - assertEquals(0, x &= (934237436)); - assertEquals(0, x |= x); - assertEquals(-79370942.97651315, x += (-79370942.97651315)); - assertEquals(-79370942.97651315, x %= ((tmp = -2683255523, tmp)<<(tmp = 2323123280.287587, tmp))); - assertEquals(-79370942, x |= x); - assertEquals(0.05861647801688159, x /= (-1354072177.061561)); - assertEquals(0, x <<= (((((((tmp = 1989257036, tmp)&(tmp = 1565496213.6578887, tmp))&x)&(tmp = -2798643735.905287, tmp))&(2354854813.43784))%(tmp = 1118124748, tmp))<<((tmp = 2453617740, tmp)*(((tmp = 1762604500.492329, tmp)<<(-2865619363))%(((2474193854.640994)|((tmp = 1425847419.6256948, tmp)|(((-1271669386)%((x|((tmp = -2059795445.3607287, tmp)+x))*(x*x)))>>>(tmp = -2997360849.0750895, tmp))))/(tmp = 2326894252, tmp)))))); - assertEquals(0, x >>>= ((-671325215)/((-727408755.8793397)>>(tmp = 315457854, tmp)))); - assertEquals(0, x >>= (x&x)); - assertEquals(0, x <<= ((x/x)>>>(((((x&x)-((x*(((tmp = -2689062497.0087833, tmp)^x)/((-1465906334.9701924)<<(tmp = -349000262, tmp))))*x))%(1630399442.5429945))*x)+((tmp = 605234630, tmp)%(tmp = 2325750892.5065155, tmp))))); - assertEquals(0, x |= (x%((x>>(((((tmp = 1622100459, tmp)<<x)&((((((tmp = 2411490075, tmp)<<x)|x)>>((x<<x)-(-2133780459)))/x)&(x+x)))%(x/((((tmp = 580125125.5035453, tmp)>>>(-470336002.1246581))|((tmp = 871348531, tmp)*x))>>(2866448831.23781))))-((2352334552)-(-562797641.6467373))))-(x^(tmp = -681731388, tmp))))); - assertEquals(0, x <<= (tmp = -1358347010.3729038, tmp)); - assertEquals(-260967814, x |= ((tmp = -260967814.45976686, tmp)%(tmp = 1126020255.1772437, tmp))); - assertEquals(NaN, x %= ((((tmp = 3176388281, tmp)<<(tmp = 611228283.2600244, tmp))>>>((tmp = 3068009824, tmp)+(tmp = 2482705111, tmp)))>>>((tmp = -750778285.2580311, tmp)>>>x))); - assertEquals(0, x <<= (x>>>x)); - assertEquals(0, x /= (1238919162)); - assertEquals(0, x >>= (x^x)); - assertEquals(0, x &= (-2137844801)); - assertEquals(0, x >>>= (x^(x*(-1774217252)))); - assertEquals(0, x >>= x); - assertEquals(0, x |= x); - assertEquals(0, x &= (x<<(tmp = 2791377560, tmp))); - assertEquals(-1330674638.8117397, x += (tmp = -1330674638.8117397, tmp)); - assertEquals(353, x >>>= (-212202857.4320326)); - assertEquals(353, x ^= ((((x+(tmp = 1448262278, tmp))-(-3141272537))>>(tmp = 1116596587.7832575, tmp))>>>((x-(((tmp = 303953098, tmp)>>>((tmp = 691514425, tmp)/((176223098)*(((2876180016)%(-1805235275.892374))|x))))<<(((tmp = 528736141.838547, tmp)^(2556817082))*(2898381286.2846575))))|((-1445518239)&(tmp = 389789481.9604758, tmp))))); - assertEquals(0, x >>>= (-227376461.14343977)); - assertEquals(0, x <<= (tmp = -2575967504, tmp)); - assertEquals(0, x <<= (x^((-2668391896)>>((x+(tmp = 598697235.9205595, tmp))+((((-2105306785)|((-1174912319.794015)>>>(x-((148979923)%((((tmp = -2459140558.4436393, tmp)|(1265905916.494016))^(tmp = 1213922357.2230597, tmp))|(1028030636))))))%x)+(((tmp = 1393280827.0135512, tmp)^((tmp = 1210906638, tmp)+(-1572777641.1396031)))<<x)))))); - assertEquals(0, x *= (tmp = 2134187165, tmp)); - assertEquals(-1084549964, x -= (tmp = 1084549964, tmp)); - assertEquals(-2045706240, x &= ((tmp = -1250758905.7889671, tmp)*(x+(((x<<(x/(tmp = -738983664.845448, tmp)))>>>x)&(tmp = 2197525295, tmp))))); - assertEquals(-2045706240, x ^= (((522049712.14743733)>>(tmp = -2695628092, tmp))>>>(tmp = -2603972068, tmp))); - assertEquals(2249261056, x >>>= x); - assertEquals(-33291, x |= ((((1891467762)<<(184547486.213719))-((458875403.50689447)^(((x&(x*x))|x)%(-3127945140))))|(-100765232))); - assertEquals(-33291, x %= (1460486884.1367688)); - assertEquals(-1, x >>= (tmp = -2667341441, tmp)); - assertEquals(-3.6289151568259606e-10, x /= (tmp = 2755644474.4072013, tmp)); - assertEquals(-3.6289151568259606e-10, x %= (tmp = 1186700893.0751028, tmp)); - assertEquals(0, x <<= (tmp = -1199872107.9612694, tmp)); - assertEquals(371216449, x ^= ((tmp = 371324611.1357789, tmp)&(x-(x|((tmp = -518410357, tmp)>>((tmp = 687379733, tmp)/x)))))); - assertEquals(0.3561383159088311, x /= (((((x%(((((-2293101242)%((((495316779)/x)-((-3198854939.8857965)>>>((tmp = -288916023, tmp)-(x^(tmp = -2504080119.431858, tmp)))))^(-1201674989)))-((2965433901)*(405932927)))/((1974547923)|(tmp = 534069372, tmp)))-(x-((x+(-1258297330))%x))))<<(((-2648166176.4947824)^(-3043930615))&(1550481610)))<<(tmp = -3118264986.743822, tmp))<<x)|x)); - assertEquals(-46272499.15029934, x -= (tmp = 46272499.50643766, tmp)); - assertEquals(-6, x >>= ((tmp = -731454087.0621192, tmp)>>>x)); - assertEquals(-2.7207928474520667e-9, x /= (((x<<(x|((tmp = -1650731700.9540024, tmp)/(tmp = -677823292, tmp))))^((((((1972576122.928667)>>x)%(2952412902.115453))<<((-2888879343)+(tmp = -425663504, tmp)))>>>(((((tmp = 1089969932, tmp)>>>(x|((-2088509661)/(1131470551))))>>>x)+x)|(tmp = 955695979.7982506, tmp)))|(((((tmp = 826954002.6188571, tmp)^(2016485728))|((x/(((x<<(tmp = 2493217141, tmp))/(-2259979800.997408))-(tmp = -427592173.41389966, tmp)))%(((-471172918)/x)>>>((383234436.16425097)&(tmp = 1664411146.5308032, tmp)))))*(tmp = 1863669754.7545495, tmp))*(x>>(2062197604)))))>>>((x-(2624545856))*(tmp = 1025803102, tmp)))); - assertEquals(0, x >>= ((tmp = 1068702028, tmp)*(296106770))); - assertEquals(0, x ^= (x/x)); - assertEquals(85359536, x ^= (((x|(((tmp = 740629227, tmp)<<(-1107397366))%((tmp = 2315368172, tmp)>>(((-2269513683)|(-2698795048))+(-396757976)))))*(929482738.803125))^(((-1415213955.4198723)-(tmp = -2885808324, tmp))>>>((tmp = -472842353.85736656, tmp)&(tmp = 1684231312.4497018, tmp))))); - assertEquals(2075131904, x <<= x); - assertEquals(123, x >>>= (x>>>(tmp = 754093009, tmp))); - assertEquals(0, x >>= ((-2690948145)/((1988638799)+x))); - assertEquals(0, x >>>= (tmp = -798849903.2467625, tmp)); - assertEquals(NaN, x %= x); - assertEquals(NaN, x *= (2431863540.4609756)); - assertEquals(484934656, x |= ((-2322193663)*(tmp = -2754666771, tmp))); - assertEquals(-82505091404694530, x *= (tmp = -170136513, tmp)); - assertEquals(-82505090515370620, x += ((-148762237)&(tmp = 889417717, tmp))); - assertEquals(-908221124, x %= (tmp = -2346393300, tmp)); - assertEquals(-1242515799, x ^= (2083328917)); - assertEquals(-1126056310271520600, x *= ((((tmp = -3065605442, tmp)<<(-3012703413))|x)^(-2081329316.4781387))); - assertEquals(-1126056309941068000, x += ((((tmp = 1886925157, tmp)&((tmp = -163003119.31722307, tmp)/((tmp = 2094816076, tmp)>>((tmp = -706947027, tmp)^x))))^((1819889650.5261197)<<(-1641091933)))>>x)); - assertEquals(-1864360191, x |= (((x/x)|x)|x)); - assertEquals(-1864360191, x &= x); - assertEquals(-3728720382, x += x); - assertEquals(1042663165, x ^= (535165183.4230335)); - assertEquals(2644530017.8833704, x += (1601866852.8833704)); - assertEquals(-574949401, x |= ((tmp = 943193254.5210983, tmp)^((x%(tmp = -2645213497, tmp))*(-1904818769)))); - assertEquals(1763223578, x ^= ((x^(tmp = -2244359016, tmp))^(tmp = 320955522, tmp))); - assertEquals(-1.9640961474334235, x /= (tmp = -897727731.0502782, tmp)); - assertEquals(1, x >>>= (x-(-3183031393.8967886))); - assertEquals(1, x &= (tmp = 1732572051.4196641, tmp)); - assertEquals(1, x >>= (-1642797568)); - assertEquals(-2339115203.3140306, x += (-2339115204.3140306)); - assertEquals(1955852093, x ^= (((((-1469402389)/(-2648643333.1454573))>>>x)<<(x/x))>>x)); - assertEquals(-965322519, x ^= (3001399252)); - assertEquals(-2139727840, x &= (tmp = 2298411812.964484, tmp)); - assertEquals(2103328, x &= (tmp = -2488723009, tmp)); - assertEquals(1799011007, x |= (tmp = -2498057537.226923, tmp)); - assertEquals(1799011007, x |= ((-308193085)>>>x)); - assertEquals(1799011007, x |= x); - assertEquals(818879107, x ^= (1542823996.423564)); - assertEquals(-2601416919234843600, x *= ((-2357923057.076759)-x)); - assertEquals(-2601416920481796600, x -= (x|(tmp = -3048039765, tmp))); - assertEquals(-33690112, x <<= x); - assertEquals(1039491072, x &= (tmp = 1039491474.3389125, tmp)); - assertEquals(126891, x >>= (-3079837011.6151257)); - assertEquals(-163191923097543, x *= (((tmp = -2847221258.4048786, tmp)*(x-(tmp = 1527622853.5925639, tmp)))^x)); - assertEquals(753616551, x ^= (-946895202)); - assertEquals(-347691264, x <<= (tmp = -433184408.33790135, tmp)); - assertEquals(0, x <<= (x|(tmp = -1911731462.6835637, tmp))); - assertEquals(-0, x *= (tmp = -2616154415.1662617, tmp)); - assertEquals(0, x >>= x); - assertEquals(0, x -= x); - assertEquals(0, x *= (2272504250.501526)); - assertEquals(0, x ^= x); - assertEquals(NaN, x %= x); - assertEquals(0, x >>>= (2475346113)); - assertEquals(NaN, x /= (((x+(-2646140897))&(((tmp = 1039073714.142481, tmp)-x)*x))|(x*(((-1277822905.773948)>>(tmp = 2035512354.2400663, tmp))*(77938193.80013895))))); - assertEquals(0, x ^= (x<<(tmp = 2491934268, tmp))); - assertEquals(0, x &= (tmp = 569878335.4607931, tmp)); - assertEquals(-88575883, x ^= ((453890820.8012209)-((1569189876)%((-1280613677.7083852)^(-1902514249.29567))))); - assertEquals(-88575883, x %= (tmp = 257947563.19206762, tmp)); - assertEquals(-88575881.7863678, x -= ((tmp = 1257547359.029678, tmp)/(x^(tmp = 948265672.821815, tmp)))); - assertEquals(-169, x >>= (tmp = -2530523309.6703596, tmp)); - assertEquals(-1, x >>= x); - assertEquals(-1, x |= x); - assertEquals(131071, x >>>= (-673590289)); - assertEquals(1117196836, x -= (-1117065765)); - assertEquals(3092236000.7125187, x -= (-1975039164.7125185)); - assertEquals(1, x /= x); - assertEquals(-1599945863, x ^= (tmp = 2695021432.453696, tmp)); - assertEquals(940543782, x ^= (tmp = 2561494111, tmp)); - assertEquals(891400321673221800, x *= (tmp = 947749949.2662871, tmp)); - assertEquals(-1509927296, x >>= ((tmp = 1113290009, tmp)-x)); - assertEquals(-23, x >>= (tmp = 3216989626.7370152, tmp)); - assertEquals(-0, x %= x); - assertEquals(0, x <<= (431687857.15246475)); - assertEquals(-0, x /= (tmp = -1924652745.081665, tmp)); - assertEquals(0, x <<= (1312950547.2179976)); - assertEquals(0, x %= ((tmp = 2110842937.8580878, tmp)|(x<<x))); - assertEquals(0, x >>>= ((((-386879000)-((tmp = -2334036143.9396124, tmp)/((tmp = 965101904.2841234, tmp)<<(((3029227182.8426695)<<((tmp = -464466927, tmp)>>((((((tmp = 849594477.4111787, tmp)^(x&((513950657.6663146)%(x>>>x))))-((2898589263)|x))+(tmp = 2842171258.621288, tmp))>>>(tmp = -3158746843, tmp))<<(tmp = -2891369879, tmp))))-(x-(x&(tmp = -1707413686.2706504, tmp)))))))-(-2860419051))*(-1708418923))); - assertEquals(-328055783, x += ((((2857010474.8010874)|((tmp = -1415997622.320347, tmp)-(-1706423374)))%(tmp = 824357977.1339042, tmp))^(x>>(x|x)))); - assertEquals(-168539902503779140, x *= ((tmp = -1057687018, tmp)<<((1408752963)-(2030056734)))); - assertEquals(-Infinity, x /= ((x-(2232683614.320658))*(((tmp = 195551174, tmp)*((((739595970)>>>(tmp = -2218890946.8788786, tmp))>>>(((tmp = -240716255.22407627, tmp)&(((((1598029916.3478878)|((tmp = -881749732, tmp)+(x>>x)))^(4443059))<<(((tmp = 2453020763, tmp)+((x>>>(tmp = -1904203813, tmp))&(-355424604.49235344)))<<(tmp = 2814696070, tmp)))%((tmp = -250266444, tmp)>>>(((((2710614972)&(((tmp = 910572052.6994087, tmp)^(tmp = -1028443184.3220406, tmp))/((-2718010521)^(tmp = 676361106, tmp))))|x)^(-1326539884))>>(-1573782639.7129154)))))/(tmp = 1923172768, tmp)))>>>(tmp = -2858780232.4886074, tmp)))/((((((-2060319376.353397)%x)>>(tmp = -3122570085.9065285, tmp))/(tmp = -1499018723.8064275, tmp))*((-655257391)<<x))>>x)))); - assertEquals(NaN, x += ((3059633304)%((((tmp = 2538190083, tmp)*((tmp = -2386800763.356364, tmp)/x))&(1341370996))%(-2929765076.078223)))); - assertEquals(NaN, x %= ((x&(347774821))>>>(462318570.2578629))); - assertEquals(NaN, x *= ((2829810152.071517)*(tmp = 768565684.6892327, tmp))); - assertEquals(NaN, x -= x); - assertEquals(0, x >>>= (x&(tmp = 1786182552, tmp))); - assertEquals(973967377, x ^= ((tmp = 2115869489.836838, tmp)&(994956497))); - assertEquals(985246427.4230617, x += (11279050.423061728)); - assertEquals(985246427, x &= x); - assertEquals(0, x >>= ((tmp = 1090502660.1867907, tmp)>>((-1599370623.5747645)-(tmp = -1321550958, tmp)))); - assertEquals(0, x %= (tmp = -2386531950.018572, tmp)); - assertEquals(0, x >>>= x); - assertEquals(NaN, x /= x); - assertEquals(0, x >>>= (tmp = -1535987507.682257, tmp)); - assertEquals(-0, x /= (-2570639987)); - assertEquals(-542895632, x |= (tmp = -542895632, tmp)); - assertEquals(-33930977, x >>= (tmp = -861198108.1147206, tmp)); - assertEquals(-0, x %= x); - assertEquals(0, x ^= (x*(-608154714.1872904))); - assertEquals(-140011520, x |= ((tmp = 377418995, tmp)<<((1989575902)>>(tmp = -2558458031.066773, tmp)))); - assertEquals(-140026048, x -= ((((tmp = 1465272774.7540011, tmp)<<((2164701398)<<(tmp = -818119264, tmp)))>>((tmp = -1490486001, tmp)>>(664410099.6412607)))>>(x>>>(((tmp = -2438272073.2205153, tmp)%(tmp = 2142162105.4572072, tmp))-(tmp = 2259040711.6543813, tmp))))); - assertEquals(39214588236996610, x *= (x<<(-401696127.06632423))); - assertEquals(1, x /= x); - assertEquals(0, x %= x); - assertEquals(0, x *= ((tmp = -1709874807.176726, tmp)&(-2786424611))); - assertEquals(-1320474063.3408537, x += (tmp = -1320474063.3408537, tmp)); - assertEquals(88, x >>>= (tmp = -3179247911.7094674, tmp)); - assertEquals(1606348131, x += ((tmp = 1555621121.5726175, tmp)|(-3026277110.9493155))); - assertEquals(200793516, x >>>= x); - assertEquals(-2952688672.1074514, x -= (tmp = 3153482188.1074514, tmp)); - assertEquals(1342278624, x >>>= ((x>>>((tmp = 1264475713, tmp)-(-913041544)))>>>((tmp = 2008379930, tmp)%(tmp = 3105129336, tmp)))); - assertEquals(0, x ^= x); - assertEquals(0, x /= (tmp = 788363717, tmp)); - assertEquals(430466213, x -= (tmp = -430466213, tmp)); - assertEquals(164757385222499550, x *= (tmp = 382741735, tmp)); - assertEquals(164757385222499550, x %= (((tmp = 1974063648, tmp)%((806015603)>>>x))*((tmp = 2836795324, tmp)<<(tmp = -1785878767, tmp)))); - assertEquals(-190957725.86956096, x /= (x^((-2939333300.066044)-(x|(-2085991826))))); - assertEquals(-190957725.86956096, x %= (tmp = -948386352, tmp)); - assertEquals(0.6457336106922105, x /= (-295722141)); - assertEquals(0, x |= ((415991250)&((x>>(tmp = -3188277823, tmp))<<(511898664.1008285)))); - assertEquals(0, x &= ((793238922)|x)); - assertEquals(-1576701979, x ^= (2718265317)); - assertEquals(-49271937, x >>= x); - assertEquals(-49271937, x |= x); - assertEquals(-49271937, x &= x); - assertEquals(775316382, x -= (-824588319)); - assertEquals(912498176, x <<= (tmp = -2223542776.836312, tmp)); - assertEquals(0, x -= (x&((tmp = 1999412385.1074471, tmp)/(-1628205254)))); - assertEquals(0, x -= x); - assertEquals(0, x >>= (-768730139.7749677)); - assertEquals(-1861304245, x |= (((5128483)^(((tmp = -1768372004, tmp)/(x^(tmp = 1310002444.757094, tmp)))*((tmp = 188242683.09898067, tmp)^(tmp = -2263757432, tmp))))^((tmp = 2223246327, tmp)*((tmp = -2360528979, tmp)-((tmp = 2442334308, tmp)>>(458302081)))))); - assertEquals(1, x /= x); - assertEquals(2, x += x); - assertEquals(1, x /= x); - assertEquals(0, x ^= x); - assertEquals(-0, x *= (-1852374359.3930533)); - assertEquals(0, x <<= (tmp = 1223645195.148961, tmp)); - assertEquals(1789655087, x |= ((-2505312209.770559)>>x)); - assertEquals(-65568768, x <<= x); - assertEquals(4229398528, x >>>= x); - assertEquals(-8408187, x |= (-3029781627)); - assertEquals(-8408187, x |= (((2322165037)-((tmp = -1424506897.362995, tmp)%x))&x)); - assertEquals(-7884926, x += (x>>>(x|(2738095820)))); - assertEquals(-7884926, x %= (576507013)); - assertEquals(751801768, x ^= (tmp = -750241238, tmp)); - assertEquals(-1986010067668600800, x *= (tmp = -2641667195, tmp)); - assertEquals(1921196240, x ^= (x%(-1954178308))); - assertEquals(847388880, x ^= ((tmp = 1632856124, tmp)&((tmp = -1536309755, tmp)<<(tmp = -3158362800, tmp)))); - assertEquals(-469662000.6651099, x += (tmp = -1317050880.6651099, tmp)); - assertEquals(-812358332, x ^= ((-2832480471)>>>(2016495937))); - assertEquals(21, x ^= (((tmp = 1815603134.2513008, tmp)/((tmp = 147415927, tmp)%(-1059701742)))+x)); - assertEquals(-2844409139.792712, x += (tmp = -2844409160.792712, tmp)); - assertEquals(177070, x >>>= x); - assertEquals(0, x %= x); - assertEquals(0, x >>= x); - assertEquals(1459126376, x ^= (tmp = -2835840920, tmp)); - assertEquals(1459126376, x %= (-1462864282)); - assertEquals(0, x >>>= (tmp = 2922724319, tmp)); - assertEquals(338995506, x ^= (338995506.6411549)); - assertEquals(336896258, x &= (2635904967)); - assertEquals(336634112, x -= (x&(tmp = 1659656287, tmp))); - assertEquals(NaN, x %= (x-x)); - assertEquals(NaN, x /= (tmp = -674606200, tmp)); - assertEquals(NaN, x %= ((x|(2788108542))/(x+(tmp = 600941473, tmp)))); - assertEquals(0, x >>>= ((-1858251597.3970242)>>>x)); - assertEquals(1951294747, x |= (tmp = 1951294747, tmp)); - assertEquals(1951294747, x &= x); - assertEquals(-153190625, x |= (-1500095737)); - assertEquals(23467367587890624, x *= x); - assertEquals(346531290.1813514, x /= (((((-513617734.11148167)|x)/((tmp = -2042982150.1170752, tmp)%((x%((x%x)>>>(((-1369980151)&(((922678983)%(x&(tmp = -855337708, tmp)))-((tmp = -2717183760, tmp)>>>((1939904985.4701347)%(((tmp = -2473316858, tmp)&((tmp = -599556221.9046664, tmp)>>((tmp = -6352213, tmp)/x)))&x)))))%x)))/((tmp = -1842773812.8648412, tmp)>>>(((x>>>(tmp = 499774063, tmp))<<(((tmp = -1353532660.5755146, tmp)*(-3070956509))>>(((-905883994.0188017)>>(tmp = -16637173, tmp))<<((tmp = 471668537, tmp)*((tmp = -232036004.26637793, tmp)/x)))))&(tmp = 85227224, tmp))))))>>>(x|(-2528471983)))-((tmp = 1531574803, tmp)+((x>>>x)-(2889291290.158888))))); - assertEquals(-94.42225749399837, x /= (((tmp = 2381634642.1432824, tmp)>>(tmp = -2637618935, tmp))|(2307200473))); - assertEquals(-47, x >>= (1524333345.141235)); - assertEquals(-2.8699253616435082e-8, x /= (1637673252)); - assertEquals(0, x |= x); - assertEquals(1083427040, x += ((-2012055268)<<(tmp = -2192382589.6911573, tmp))); - assertEquals(1083427040, x %= (x*x)); - assertEquals(2694039776, x += ((((-1740065704.9004602)<<(-736392934))%(2781638048.424092))>>>(x&x))); - assertEquals(-1600927520, x |= ((tmp = 2904430054.869525, tmp)*(((1054051883.4751332)*x)*((-939020743)-(tmp = 1636935481.1834455, tmp))))); - assertEquals(-1600927520, x -= (x%x)); - assertEquals(3037584978216498700, x *= (tmp = -1897390694, tmp)); - assertEquals(372598954.1823988, x %= (tmp = 1553763703.5082102, tmp)); - assertEquals(-1476395008, x <<= ((x>>((tmp = 282496335.49494267, tmp)^((-1948623419.6947453)|((((((tmp = -1203306995, tmp)-(-5554612.355098486))>>>(1867254951.4836824))>>x)|(-695777865))/((-59122652.19377303)<<(-609999229.7448442))))))>>(x/(tmp = -1207010654.9993455, tmp)))); - assertEquals(-2.2540185787941605, x /= (((tmp = 1364159859.9199843, tmp)*x)>>x)); - assertEquals(-2, x |= x); - assertEquals(2241824008, x *= ((3174055292.962967)>>(((-2379151623.602476)>>(tmp = -1423760236, tmp))>>(tmp = -522536019.2225733, tmp)))); - assertEquals(-2138158385, x ^= ((x>>((((1316131966.9180691)-((x*x)>>x))>>>x)>>((-2712430284)|(((((x<<(-616185937.6090865))-(((x-(tmp = 2957048661, tmp))<<(tmp = 617564839.888214, tmp))/(x%((tmp = -447175647.9393475, tmp)<<(2203298493.460617)))))-((x&((x<<(914944265))^(((-1294901094)*((tmp = 2512344795, tmp)+((((tmp = -1227572518, tmp)%(1831277766.4920158))*((x|x)^(tmp = 2515415182.6718826, tmp)))*x)))-(961485129))))>>>(tmp = 2079018304, tmp)))>>(tmp = 734028202, tmp))^(554858721.6149715)))))-((tmp = 1312985279.5114603, tmp)^(tmp = 2450817476.179955, tmp)))); - assertEquals(2.759030298237921, x /= (x|(tmp = -775901745.3688724, tmp))); - assertEquals(8, x <<= x); - assertEquals(NaN, x %= (((x&((1792031228.831834)>>(-1174912501)))%(((-2351757750)+(tmp = -2610099430, tmp))*(-2811655968)))*(x&(tmp = -1881632878, tmp)))); - assertEquals(0, x &= ((x*(616116645.7508612))^(2789436828.536846))); - assertEquals(0, x *= x); - assertEquals(35097452, x ^= ((tmp = 1023684579, tmp)%(((x|((tmp = -757953041, tmp)+(772988909)))+(tmp = -2934577578, tmp))>>>((tmp = -1973224283, tmp)>>>((x*(2244818063.270375))|(x-(-716709285))))))); - assertEquals(0.015207441433418992, x /= (2307913014.4056892)); - assertEquals(-5865042.942076175, x -= (5865042.957283616)); - assertEquals(-67719.94207617454, x %= (((1464126615.2493973)+(398302030.0108756))>>>x)); - assertEquals(4294899577, x >>>= (x<<x)); - assertEquals(-1, x >>= (tmp = 607447902, tmp)); - assertEquals(-1, x >>= (3081219749.9119744)); - assertEquals(6.53694303504065e-10, x /= (tmp = -1529767040.4034374, tmp)); - assertEquals(6.53694303504065e-10, x %= ((tmp = 899070650.7190754, tmp)&(tmp = -1101166301, tmp))); - assertEquals(6.53694303504065e-10, x %= (tmp = -2207346460, tmp)); - assertEquals(NaN, x %= (((x&x)>>x)%(((-10980184)+x)&(tmp = -1473044870.4729445, tmp)))); - assertEquals(NaN, x -= x); - assertEquals(-1755985426, x ^= (tmp = 2538981870, tmp)); - assertEquals(-13842, x %= ((((-2258237411.3816605)+(-1325704332.0531585))<<((tmp = -877665450.1877053, tmp)>>(((((2420989037)+(2084279990.6278818))*(-327869571.9348242))+x)^x)))>>>x)); - assertEquals(1, x /= x); - assertEquals(1, x >>= ((2241312290)^(2859250114))); - assertEquals(0, x >>= x); - assertEquals(-1615631756, x |= (-1615631756.1469975)); - assertEquals(-1615631756, x |= x); - assertEquals(-627245056, x <<= ((x*(tmp = -1308330685.5971081, tmp))|(tmp = 1479586158, tmp))); - assertEquals(-627245056, x |= x); - assertEquals(1786953888, x ^= (-1340096352.1839824)); - assertEquals(1668014353, x -= (tmp = 118939535, tmp)); - assertEquals(1, x /= x); - assertEquals(-645681, x ^= ((-1322356629)>>(tmp = 1829870283, tmp))); - assertEquals(-1322354688, x <<= (-794779253)); - assertEquals(-4310084378.672725, x += (-2987729690.6727247)); - assertEquals(-8620168757.34545, x += x); - assertEquals(-8720421, x |= (tmp = -748107877.6417065, tmp)); - assertEquals(-1508858270, x ^= (1500137913)); - assertEquals(-0.825735756765112, x /= (1827289490.1767085)); - assertEquals(1253449509.1742642, x += (((tmp = 1253449509.9576545, tmp)-(((tmp = 2860243975, tmp)+(367947569.85976696))>>(((((530960315)>>>((((x%(tmp = -2203199228, tmp))<<(x*(((tmp = -117302283, tmp)/(x-((2579576936)%(-1225024012))))&(tmp = -2857767500.1967726, tmp))))/((x/((tmp = -166066119, tmp)<<x))|x))>>>x))|(((2771852372)>>(((tmp = -3103692094.1463976, tmp)-(tmp = 2867208546.069278, tmp))>>>(702718610.1963737)))|(tmp = 2680447361, tmp)))>>x)>>(-2006613979.051014))))^((-1665626277.9339101)/(x<<(tmp = 342268763, tmp))))); - assertEquals(1693336701.1742642, x += (tmp = 439887192, tmp)); - assertEquals(0.8479581831275719, x /= ((1171383583)+(((x&x)>>>(51482548.618915915))-(tmp = -825572595.1031849, tmp)))); - assertEquals(28, x |= ((tmp = -2355932919.6737213, tmp)>>(tmp = -2395605638, tmp))); - assertEquals(0, x %= x); - assertEquals(0, x -= x); - assertEquals(0, x <<= (x^((tmp = 2793423893.484949, tmp)*(1585074754.3250475)))); - assertEquals(0, x >>= (x/(x-((957719861.9175875)&(1288527195))))); - assertEquals(0, x >>>= ((-1429196921.4432657)/x)); - assertEquals(-852424225.734199, x -= (tmp = 852424225.734199, tmp)); - assertEquals(-46674433, x |= ((tmp = -2335242963, tmp)*((2135206646.2614377)>>(tmp = 505649511.8292929, tmp)))); - assertEquals(2944662357, x += (tmp = 2991336790, tmp)); - assertEquals(1404, x >>>= (849155189.1503456)); - assertEquals(-846755170, x ^= (tmp = -846753822.4471285, tmp)); - assertEquals(52615, x >>>= ((-517068110)+x)); - assertEquals(1475021859.9916897, x += (tmp = 1474969244.9916897, tmp)); - assertEquals(0, x %= x); - assertEquals(0, x %= ((539583595.8244679)*(tmp = 1469751690.9193692, tmp))); - assertEquals(0, x &= (807524227.2057163)); - assertEquals(NaN, x %= x); - assertEquals(NaN, x -= (x^((tmp = -362481588, tmp)%(2611296227)))); - assertEquals(NaN, x *= x); - assertEquals(0, x >>= ((-2519875630.999908)<<x)); - assertEquals(NaN, x %= x); - assertEquals(NaN, x += (((tmp = 2485209575, tmp)>>(tmp = 2326979823, tmp))%(x-(((-1296334640.7476478)&x)<<x)))); - assertEquals(0, x >>= (((tmp = 1370704131, tmp)^((((tmp = 793217372.7587746, tmp)>>(((-1455696484.109328)|(((((-2186284424.5379324)<<(tmp = 3052914152.254852, tmp))-(x>>(tmp = 3121403408, tmp)))+((778194280)-(((((tmp = 2398957652, tmp)-(x+(((-2592019996.937958)>>((tmp = 1648537981, tmp)>>x))<<(-677436594))))<<(39366669.09012544))|((tmp = 3133808408.9582872, tmp)-(-2987527245.010673)))*x)))|((tmp = -2178662629, tmp)<<x)))^(((tmp = 909652440.3570575, tmp)%(-2572839902.6852217))%(-1879408081))))*(tmp = -2910988598, tmp))&(((x^x)>>(2822040993))|((x*x)^(((1072489842.6785052)|(x-(((464054192.7390214)^x)<<(tmp = -2754448095, tmp))))*((tmp = -1544182396, tmp)/(tmp = -3198554481, tmp)))))))^(tmp = 1946162396.9841106, tmp))); - assertEquals(371272192, x |= (((x^((x-(x/x))&(tmp = 2370429394, tmp)))-(tmp = -403692829, tmp))*(tmp = 2808636109, tmp))); - assertEquals(929786482, x |= ((729966239.8987448)^(x-((tmp = 120127779, tmp)^((tmp = -3088531385, tmp)>>>((x+((tmp = 2364833601, tmp)>>>(((599149090.6666714)>>(tmp = 2838821032, tmp))%(tmp = -662846011, tmp))))-(tmp = 1168491221.1813436, tmp))))))); - assertEquals(-681121542, x += ((-1610909505.998718)^((tmp = -957338882, tmp)>>>(tmp = 1935594133.6531684, tmp)))); - assertEquals(-2147483648, x <<= ((tmp = 15161708, tmp)|(2453975670))); - assertEquals(-2147483648, x >>= x); - assertEquals(0, x <<= (2080486058)); - assertEquals(0, x &= (((x&(tmp = -767821326, tmp))/((tmp = 1877040536, tmp)>>>(tmp = 2378603217.75597, tmp)))*(-1601799835))); - assertEquals(0, x %= (-1820240383)); - assertEquals(1621233920, x ^= ((tmp = 820230232, tmp)*(1727283900))); - assertEquals(1621233920, x |= (x>>>x)); - assertEquals(1621233931, x += ((tmp = 794966194.9011587, tmp)>>(tmp = -597737830.5450518, tmp))); - assertEquals(1621276543, x |= (((x^((2354444886)+(tmp = 685142845.4708651, tmp)))-(tmp = 790204976.9120214, tmp))>>>((((tmp = -2792921939, tmp)/(((((tmp = -80705524, tmp)<<x)-(((((((tmp = 1951577216.379527, tmp)>>>x)%((-529882150)>>>(tmp = -1682409624, tmp)))<<((-42043756.29025769)-(-1803729173.6855814)))/(2937202170.118023))*(tmp = -1998098798.5722106, tmp))*(tmp = -2996229463.904228, tmp)))&x)>>>(-301330643)))/(-2858859382.0050273))-(tmp = 1571854256.0740635, tmp)))); - assertEquals(810638271, x >>>= (x/(1553632833))); - assertEquals(810638271, x <<= (tmp = -1467397440, tmp)); - assertEquals(-2147483648, x <<= x); - assertEquals(871068871, x ^= (tmp = 3018552519, tmp)); - assertEquals(-1073743881, x |= ((tmp = 2294122324.020989, tmp)|(tmp = -1799706842.4493146, tmp))); - assertEquals(-77816868, x += (((-2225296403)&x)>>(tmp = -2667103424.445239, tmp))); - assertEquals(-1215889, x >>= (tmp = 1876107590.8391647, tmp)); - assertEquals(-2431778, x += x); - assertEquals(4292535518, x >>>= (((x>>(-1825580683))/x)%x)); - assertEquals(4292802560, x -= (x|(1492864090))); - assertEquals(0, x -= x); - assertEquals(0, x >>= x); - assertEquals(0, x %= (tmp = 2173121205, tmp)); - assertEquals(0, x *= (x>>x)); - assertEquals(1565261471, x |= ((1565261471.323931)>>>x)); - assertEquals(0, x -= x); - assertEquals(-86980804, x |= (-86980804)); - assertEquals(-698956484, x -= (((((2754713793.1746016)*(((((-1514587465.0698888)>>(tmp = -1307050817, tmp))/(tmp = 2368054667.438519, tmp))*(-1908125943.5714772))<<(x>>>(-357164827.4932244))))+(1257487617))<<(2954979945))&(612330472))); - assertEquals(-1073741824, x <<= x); - assertEquals(54497747, x ^= (-1019244077.098908)); - assertEquals(54501375, x |= (((tmp = 1944912427, tmp)>>>x)%x)); - assertEquals(0, x -= x); - assertEquals(0, x -= x); - assertEquals(-0, x *= (-1748215388)); - assertEquals(0, x >>= x); - assertEquals(0, x >>>= (((tmp = 988769112, tmp)%(tmp = -3133658477, tmp))<<x)); - assertEquals(0, x %= (1685221089.2950323)); - assertEquals(0, x >>>= (x+((793467168)-(tmp = 135877882, tmp)))); - assertEquals(0, x %= ((tmp = -2406801984, tmp)%(tmp = -987618172, tmp))); - assertEquals(0, x *= ((-2943444887.953456)|(tmp = -2327469738.4544783, tmp))); - assertEquals(0, x >>= x); - assertEquals(-145484729.70167828, x += (tmp = -145484729.70167828, tmp)); - assertEquals(1140855872, x &= (x^(tmp = 3151437967.965556, tmp))); - assertEquals(1486808408, x += (tmp = 345952536, tmp)); - assertEquals(107846582.36594129, x %= (-1378961825.6340587)); - assertEquals(-642031616, x <<= (x+x)); - assertEquals(151747770.95108718, x *= (x/(tmp = 2716379907, tmp))); - assertEquals(192723456, x <<= (tmp = -1731167384, tmp)); - assertEquals(2151208003, x -= ((-2151208003)+x)); - assertEquals(1, x /= x); - assertEquals(1, x |= x); - assertEquals(1996766603, x |= (1996766602)); - assertEquals(895606123, x ^= (tmp = 1113972960.966081, tmp)); - assertEquals(-1500036886, x ^= (tmp = 2482412929, tmp)); - assertEquals(-1542644247, x ^= (x>>>((tmp = 51449105, tmp)>>>(((-2057313176)*x)/(-1768119916))))); - assertEquals(-1496074063273093600, x *= ((tmp = 786152274, tmp)^(387292498))); - assertEquals(-794329073, x %= (((tmp = -2314637675.617696, tmp)*((((x*(411053423.29070306))-(2889448433.4240828))/((-970630131)/(tmp = -2886607600.7423067, tmp)))<<(tmp = 1263617112.9362245, tmp)))|(2816980223.8209996))); - assertEquals(2468008436047106600, x *= (tmp = -3107035257.725115, tmp)); - assertEquals(3040956928, x >>>= ((tmp = 1514372119.1787262, tmp)*(3169809008))); - assertEquals(-19, x >>= (tmp = -266966022.10604453, tmp)); - assertEquals(-1.6505580654964654e-8, x /= ((-3143841480)>>(x-x))); - assertEquals(-2.2420284729165577e-7, x *= (x*((((703414102.2523813)%(tmp = 2989948152, tmp))-((-1583401827.2949386)^((tmp = -1916731338, tmp)%((331500653.3566053)|(((tmp = 29865940, tmp)+((tmp = -2294889418.6764183, tmp)<<(tmp = -1558629267.255229, tmp)))>>>(x*(x+x)))))))|((988977957)&(-2986790281))))); - assertEquals(0, x ^= (x/(tmp = 781117823.345541, tmp))); - assertEquals(NaN, x *= (((x^((((tmp = -2969290335, tmp)+(((((tmp = -175387021, tmp)&(tmp = -1080807973, tmp))<<(tmp = -2395571076.6876855, tmp))|((tmp = -1775289899.4106793, tmp)^x))|(-2963463918)))*(tmp = -1761443911, tmp))^(tmp = 847135725, tmp)))<<((146689636)<<x))%x)); - assertEquals(0, x ^= x); - assertEquals(1720182184, x -= (((tmp = 3184020508, tmp)|((-489485703)+(tmp = -2644503573, tmp)))&(tmp = 2575055579.6375213, tmp))); - assertEquals(1720182184, x >>= (x<<(-45408034))); - assertEquals(5.759243187540471e+27, x *= (((x&(1456298805))+(x<<(106573181)))*((566861317.2877743)+(2262937360.3733215)))); - assertEquals(5.759243187540471e+27, x -= (tmp = -1365873935, tmp)); - assertEquals(0, x <<= x); - assertEquals(0, x >>= (1960073319.3465362)); - assertEquals(0, x <<= x); - assertEquals(560463904, x += ((tmp = 1844076589.9286406, tmp)&((((((-691675777.5800121)|(-745631201))|x)+(tmp = 1504458593.2843904, tmp))-x)<<x))); - assertEquals(-513210271, x -= (x|(1052702623.7761713))); - assertEquals(3781757025, x >>>= ((-1346666404.362477)*(tmp = 2798191459, tmp))); - assertEquals(1080100929, x &= (1122097879.882534)); - assertEquals(1276833905.8093092, x *= ((1276833905.8093092)/x)); - assertEquals(1276833905.8093092, x %= (1796226525.7152414)); - assertEquals(1276833905, x <<= (((tmp = -491205007.83412814, tmp)*(tmp = 1496201476.496839, tmp))>>(x+((tmp = -854043282.114594, tmp)-((x|(tmp = -807842056, tmp))*x))))); - assertEquals(1276833905, x %= (((-1870099318)>>>(((tmp = -2689717222, tmp)/(248095232))/(tmp = 1036728800.5566598, tmp)))&(((((857866837)>>(tmp = 3034825801.740485, tmp))|(-1676371984))>>>(x<<x))%((-3035366571.0221004)*(1578324367.8819473))))); - assertEquals(1, x /= x); - assertEquals(2819223656.189109, x += (2819223655.189109)); - assertEquals(-1475743640, x >>= (((tmp = 2586723314.38089, tmp)/(x&(tmp = -697978283.9961061, tmp)))<<(x%((-1167534676)>>(x^((tmp = -284763535, tmp)*((x%x)&((((tmp = 2916973220.726839, tmp)%x)/(tmp = -1338421209.0621986, tmp))|((tmp = -834710536.803335, tmp)%x))))))))); - assertEquals(-3267683406, x -= (tmp = 1791939766, tmp)); - assertEquals(-2090420900700614100, x *= (639725653)); - assertEquals(-1540353536, x %= ((-1800269105)<<((((x&(((tmp = 1135087416.3945065, tmp)^(613708290))>>x))>>(tmp = -1234604858.7683473, tmp))^(2404822882.7666225))>>>((tmp = -287205516, tmp)-((1648853730.1462333)^((x+(x%((tmp = 359176339, tmp)%((2856479172)<<(tmp = -1995209313, tmp)))))^(((tmp = 2857919171.839304, tmp)>>>(tmp = 2779498870, tmp))>>x))))))); - assertEquals(-2093767030, x ^= (654554250.498078)); - assertEquals(1, x >>>= ((tmp = -166296226.12181997, tmp)^(x/x))); - assertEquals(-1487427474, x -= ((x<<x)|(1487427475.4063978))); - assertEquals(-1487427470.562726, x += ((-1226399959.8267038)/((tmp = 2172365551, tmp)<<x))); - assertEquals(-3457859227618939400, x *= (tmp = 2324724597.3686075, tmp)); - assertEquals(396221312, x >>= (-1354035390)); - assertEquals(0, x %= x); - assertEquals(0, x &= (tmp = 2733387603, tmp)); - assertEquals(1485905453, x |= ((((tmp = -1321532329.304437, tmp)&((((tmp = 1817382709.4180388, tmp)%(((tmp = 2089156555.7749293, tmp)-(-1555460267))|(tmp = 717392475.9986715, tmp)))%(tmp = 1976713214, tmp))^x))>>>x)+(tmp = -2812404197.002721, tmp))); - assertEquals(1485905453, x |= x); - assertEquals(-997658264, x <<= (-1409757949.6038744)); - assertEquals(-997657290, x -= ((-2041106361)>>(tmp = -2014750507, tmp))); - assertEquals(-2138512124, x &= (tmp = 2565597060, tmp)); - assertEquals(8422400, x &= ((-2819342693.5172367)*(tmp = 1441722560, tmp))); - assertEquals(111816531.81703067, x -= (-103394131.81703067)); - assertEquals(59606682.673836395, x *= ((tmp = -1451690098, tmp)/(x-(2835050651.717734)))); - assertEquals(-119213365.34767279, x *= (x|((-2656365050)/((-66180492)+(tmp = 284225706.32323086, tmp))))); - assertEquals(-232839, x >>= (1694344809.435083)); - assertEquals(-1, x >>= x); - assertEquals(1, x *= x); - assertEquals(1, x |= x); - assertEquals(0, x >>= (tmp = 397239268, tmp)); - assertEquals(-1525784563, x -= (tmp = 1525784563, tmp)); - assertEquals(-153.62740888512675, x /= (((tmp = -2040622579.5354173, tmp)*(tmp = -1149025861.549324, tmp))%(((tmp = 2981701364.0073133, tmp)*(tmp = 2993366361, tmp))|(x|(tmp = 1800299979, tmp))))); - assertEquals(-1671795135, x &= (-1671795135.6173766)); - assertEquals(-4253, x |= ((((x*((1533721762.8796673)<<((tmp = 1026164775.0081646, tmp)<<x)))<<(((x-((((x>>((((((tmp = -481536070.7067797, tmp)&(tmp = 1663121016, tmp))>>>(-2974733313.5449667))+(tmp = -493019653, tmp))>>x)&(tmp = 879307404.8600142, tmp)))>>>x)%(x-(tmp = -1806412445.788453, tmp)))%x))<<(x<<(x+x)))+x))>>((tmp = -332473688.28477216, tmp)<<((tmp = 1701065928, tmp)+(((((tmp = -2407330783, tmp)+x)-((tmp = 584100783, tmp)%(tmp = -3077106506, tmp)))^x)>>x))))<<x)); - assertEquals(-0, x %= x); - assertEquals(0, x >>>= x); - assertEquals(0, x >>>= (1578470476.6074834)); - assertEquals(0, x >>>= (974609751)); - assertEquals(-120, x += (x-((tmp = -245718438.0842378, tmp)>>>(tmp = -1870354951, tmp)))); - assertEquals(-6.134465505515781e-8, x /= (1956160645)); - assertEquals(-0, x %= x); - assertEquals(0, x *= (tmp = -399718472.70049024, tmp)); - assertEquals(-1803198769.8413258, x += (-1803198769.8413258)); - assertEquals(988624943, x ^= ((((tmp = 320776739.5608537, tmp)*(((tmp = -983452570.3150327, tmp)^x)&(tmp = -3181597938, tmp)))-(tmp = -1367913740.9036021, tmp))/(((tmp = -535854933.2943456, tmp)-(717666905.8122432))>>>(((((x^(tmp = 380453258.60062766, tmp))^(tmp = -1242333929, tmp))/((tmp = 1072416261, tmp)+(((2090466933)*(x*(tmp = -386283072, tmp)))|((tmp = 789259942, tmp)<<(tmp = -1475723636.1901488, tmp)))))>>>x)%((x>>(tmp = -1243048658.3818703, tmp))|((((((tmp = -619553509, tmp)|x)/(878117279.285609))|((x<<(x>>>(tmp = -749568437.7390883, tmp)))*x))/(tmp = 1674804407, tmp))-(x*(tmp = 1528620873, tmp)))))))); - assertEquals(988625135, x |= (x>>>(tmp = 2402222006, tmp))); - assertEquals(988625135, x %= (-2691094165.990094)); - assertEquals(0, x %= x); - assertEquals(-0, x *= (tmp = -1409904262, tmp)); - assertEquals(-0, x /= ((1176483512.8626208)<<x)); - assertEquals(0, x &= ((((1677892713.6240005)^(tmp = 2575724881, tmp))^(tmp = -2935655281.208194, tmp))*(216675668))); - assertEquals(0, x >>= (tmp = -1296960457, tmp)); - assertEquals(0, x |= x); - assertEquals(NaN, x /= x); - assertEquals(0, x <<= (x>>(-3127984289.9112387))); - assertEquals(0, x %= ((tmp = 190018725.45957255, tmp)<<((x>>>x)/x))); - assertEquals(0, x /= (1185681972)); - assertEquals(0, x &= ((tmp = -1285574617, tmp)>>x)); - assertEquals(0, x >>>= ((tmp = 2498246277.2054763, tmp)+(((tmp = 924534435, tmp)&x)>>(tmp = 1379755429, tmp)))); - assertEquals(0, x -= x); - assertEquals(0, x /= (3093439341)); - assertEquals(0, x *= (x>>>x)); - assertEquals(0, x &= (tmp = 551328367, tmp)); - assertEquals(-0, x /= (-3153411714.834353)); - assertEquals(1217585288, x ^= (tmp = -3077382008.637764, tmp)); - assertEquals(-639702017, x |= ((tmp = -640922633, tmp)%(tmp = -879654762, tmp))); - assertEquals(-1645297680, x <<= (tmp = 1418982820.8182912, tmp)); - assertEquals(-1.4059558868398736, x /= (1170234212.4674253)); - assertEquals(-2650856935.66554, x *= (1885448157)); - assertEquals(1326259953.26931, x *= (((x>>(x|(-496195134.78045774)))+((2029515886)%(tmp = 1148955580, tmp)))/(tmp = -1760016519, tmp))); - assertEquals(0, x &= (((((-273334205)+(tmp = 797224093.682485, tmp))/x)>>>((((tmp = -887577414, tmp)/x)+x)%(tmp = 720417467, tmp)))^(((x-(tmp = -309071035, tmp))>>(-3123114729.33889))/x))); - assertEquals(0, x ^= x); - assertEquals(0, x %= ((tmp = -2243857462, tmp)/((((((2642220700.6673346)&x)*(tmp = 1454878837, tmp))|((-25825087.30002737)%(851535616.3479034)))<<(tmp = -697581582, tmp))%(tmp = 2248990486, tmp)))); - assertEquals(0, x >>= (((x|(((tmp = -220437911, tmp)&((((255690498)*(((2993252642)>>>(tmp = 300426048.0338713, tmp))>>x))&((-364232989)+(x<<(-1824069275))))%(x+(tmp = 2696406059.026349, tmp))))+((tmp = 2911683270, tmp)/(tmp = 2718991915, tmp))))*(x/(((tmp = -982851060.0744538, tmp)^((-2903383954)<<((-85365803.80553412)^x)))%(1489258330.5730634))))>>>x)); - assertEquals(0.7805921633088815, x += (((-1886920875)/(-2417294156.5304217))%(tmp = -1176793645.8923106, tmp))); - assertEquals(0, x <<= x); - assertEquals(-2215008905, x -= (2215008905)); - assertEquals(1931542900, x &= (-215923724.72133207)); - assertEquals(907191462, x ^= (-3133954606.357727)); - assertEquals(453595731, x >>>= (((tmp = 2726241550, tmp)/(tmp = -332682163, tmp))*((((tmp = 2500467531, tmp)>>>(((x<<(tmp = -1847200310.4863105, tmp))/x)^x))+x)<<(191688342.22953415)))); - assertEquals(-0.21671182880645923, x /= ((((-1169180683.1316955)%x)>>>(1650525418))^((2198033206.797462)&((-6913973.910871983)%(1758398541.8440342))))); - assertEquals(-375102237.1603561, x += (tmp = -375102236.9436443, tmp)); - assertEquals(1, x &= (((84374105.89811504)|((tmp = -2480295008.926951, tmp)>>((605043461)>>(tmp = -2495122811, tmp))))>>(-2129266088))); - assertEquals(1, x |= x); - assertEquals(0.0000024171579540208214, x /= (((-2600416098)>>(-2076954196))^x)); - assertEquals(0.0000024171579540208214, x %= (tmp = -2632420148.815531, tmp)); - assertEquals(1809220936.0126908, x -= (-1809220936.0126884)); - assertEquals(1682452118.2686126, x += (((2358977542)<<(x/(tmp = -2862107929, tmp)))+(x+(x%((-3101674407)/(((x*((x>>(tmp = 630458691.3736696, tmp))>>>(tmp = -852137742, tmp)))/x)-((-1875892391.1022017)&(tmp = -1027359748.9533749, tmp)))))))); - assertEquals(1682452118, x <<= (((tmp = -80832958.07816291, tmp)>>x)%(x-((x^(x<<(tmp = -156565345, tmp)))|((tmp = -1208807363.727137, tmp)/(tmp = 2614737513.304538, tmp)))))); - assertEquals(6572078, x >>= (-1573364824)); - assertEquals(13144156, x += x); - assertEquals(1731678184, x ^= ((tmp = 593370804.9985657, tmp)|(-3124896848.53273))); - assertEquals(845545, x >>>= (tmp = -605637621.2299933, tmp)); - assertEquals(-1383361088, x ^= (tmp = -1383632087, tmp)); - assertEquals(-82545896480031520, x += ((x+(1023183845.7316296))*((((tmp = 576673669, tmp)>>(((-584800080.1625061)/(2388147521.9174623))+((((x>>>(-905032341.5830328))^(tmp = -2170356357, tmp))-x)+((136459319)+(-1799824119.689473)))))|x)&(tmp = -2688743506.0257063, tmp)))); - assertEquals(-895206176, x |= x); - assertEquals(-0, x %= x); - assertEquals(1791306023, x ^= ((tmp = -3219480856, tmp)+(tmp = 715819582.0181161, tmp))); - assertEquals(1791306023, x &= x); - assertEquals(2725167636753240600, x *= (1521330025)); - assertEquals(-281190679, x |= (tmp = -1422045975.798171, tmp)); - assertEquals(-281190679, x += (x%x)); - assertEquals(-2342097426.906673, x -= (tmp = 2060906747.906673, tmp)); - assertEquals(-4651462701.906673, x -= (2309365275)); - assertEquals(1878, x >>>= (2544974549.345834)); - assertEquals(1964, x += (x&((1067649861)>>(182139255.7513579)))); - assertEquals(2209, x += (x>>(tmp = -1775039165, tmp))); - assertEquals(0, x -= x); - assertEquals(-0, x /= (tmp = -1634697185, tmp)); - assertEquals(NaN, x /= x); - assertEquals(0, x >>>= ((tmp = 3075747652, tmp)&(tmp = 819236484, tmp))); - assertEquals(0, x /= ((1276203810.476657)%(-2434960500.784484))); - assertEquals(0, x >>>= (tmp = -503633649, tmp)); - assertEquals(-982731931, x |= (-982731931)); - assertEquals(-1965463862, x += x); - assertEquals(-0.221469672913716, x %= ((tmp = -1742292120, tmp)/x)); - assertEquals(-0.221469672913716, x %= (-2021391941.1839576)); - assertEquals(0, x <<= (((((tmp = -2802447851, tmp)>>((2534456072.6518855)&x))%(tmp = 2841162496.610816, tmp))<<((89341820)/(2565367990.0552235)))>>(tmp = 2700250984.4830647, tmp))); - assertEquals(0, x >>= x); - assertEquals(0, x >>= ((tmp = -636189745, tmp)>>>(x/(((tmp = 2634252476, tmp)%(2026595795))>>(tmp = -2048078394.743723, tmp))))); - assertEquals(NaN, x %= ((x%((((x%((tmp = -2583207106, tmp)&x))|(190357769))<<(tmp = 595856931.2599536, tmp))%x))*((-2433186614.6715775)<<((2856869562.1088696)^(tmp = 1112328003, tmp))))); - assertEquals(1621713910, x |= (tmp = 1621713910.0282416, tmp)); - assertEquals(3243427820, x += x); - assertEquals(0, x *= (x&(x-x))); - assertEquals(0, x >>>= (((2871235439)<<((x+((tmp = -1319445828.9659343, tmp)+(tmp = 1595655077.959171, tmp)))>>(tmp = -86333903, tmp)))-(x/(2907174373.268768)))); - assertEquals(0, x >>= (-1091774077.2173789)); - assertEquals(NaN, x /= x); - assertEquals(NaN, x *= (tmp = 1976023677.7015994, tmp)); - assertEquals(NaN, x -= (-3013707698)); - assertEquals(NaN, x += ((x+(((tmp = -3119865782.9691515, tmp)<<(1327383504.0158405))^(((-143382411.7239611)>>>((-2157016781)+(((-335815848)/x)<<(tmp = 1953515427, tmp))))&(-2715729178))))/(413738158.2334299))); - assertEquals(NaN, x %= x); - assertEquals(NaN, x += (-845480493)); - assertEquals(-789816013, x |= (tmp = -789816013.129916, tmp)); - assertEquals(0, x ^= x); - assertEquals(0, x <<= (3032573320)); - assertEquals(47630, x ^= ((1086705488)%((x^(tmp = -1610832418, tmp))>>>(tmp = 1136352558, tmp)))); - assertEquals(47630, x >>= (tmp = 1035320352.4269229, tmp)); - assertEquals(47630, x >>= ((((x^x)<<(x*((((x&((-1657468419)*((tmp = -674435523, tmp)&((tmp = 2992300334, tmp)|x))))*((tmp = -489509378.31950426, tmp)*(tmp = 2276316053, tmp)))>>>x)<<x)))%(tmp = -1209988989, tmp))/(tmp = -2080515253.3541622, tmp))); - assertEquals(3192518951.8129544, x += (3192471321.8129544)); - assertEquals(648116457.8129544, x %= (-2544402494)); - assertEquals(0, x -= x); - assertEquals(NaN, x /= x); - assertEquals(NaN, x /= x); - assertEquals(0, x <<= x); - assertEquals(0, x >>= x); - assertEquals(0, x *= (tmp = 30051865, tmp)); - assertEquals(0, x ^= ((x&(((x&x)>>>(((((((x+(2319551861.0414495))>>>(tmp = -3099624461, tmp))^((((tmp = 1574312763, tmp)|x)>>>((-2723797246)&(tmp = -1993956152, tmp)))|(-1830179045)))|(((((((-2545698704.3662167)>>>x)-(((-79478653)|x)%(x+(x>>((tmp = 2386405508.2180576, tmp)/x)))))>>((((-1947911815.2808042)*((x+(368522081.2884482))-(tmp = 2452991210, tmp)))>>(343556643.1123545))>>((((tmp = 1869261547.537739, tmp)>>(3193214755))|x)&(x*(2027025120)))))<<((-1149196187)>>>(814378291.8374172)))+((((((((-160721403)/(2079201480.2186408))+((x|((((tmp = -299595483.16805863, tmp)>>>((x|((x+x)/(-2359032023.9366207)))<<(tmp = -3095108545, tmp)))>>((tmp = -1547963617.9087071, tmp)*(x>>x)))&((tmp = -1568186648.7499216, tmp)+(((2646528453)^(-2004832723.0506048))>>>(tmp = -3188715603.921877, tmp)))))+(tmp = 1578824724, tmp)))^x)^x)/(tmp = -985331362, tmp))|(tmp = 445135036, tmp))<<(tmp = -73386074.43413758, tmp)))+(((-1674995105.9837937)-(tmp = 1392915573, tmp))>>x)))%(tmp = 1215953864, tmp))&((tmp = -439264643.5238693, tmp)>>>x))+(((tmp = 2311895902, tmp)|(1604405793.6399229))&(tmp = -565192829, tmp))))-x))>>(-2455985321))); - assertEquals(0, x %= ((1177798817)>>(tmp = 2081394163.5420477, tmp))); - assertEquals(0, x >>>= ((x^(tmp = -41947528.33954811, tmp))>>(x>>>((tmp = 1367644771, tmp)+x)))); - assertEquals(0, x %= ((x+((tmp = 163275724, tmp)<<((tmp = -514460883.3040788, tmp)+x)))|(tmp = -287112073.2482593, tmp))); - assertEquals(0, x &= (3067975906)); - assertEquals(201342051, x |= (tmp = 201342051, tmp)); - assertEquals(0, x %= (((((-2580351108.8990865)<<(tmp = 2675329316, tmp))&((1338398946)%((-1548041558)+((x>>(-1568233868.7366815))|((x>>((tmp = -1064582207, tmp)/(-1062237014)))>>(tmp = 854123209, tmp))))))<<(((989032887)*(1842748656))%(tmp = -1566983130, tmp)))-x)); - assertEquals(-0, x /= (tmp = -828519512.617768, tmp)); - assertEquals(0, x &= ((((1449608518)+(-1829731972))*(1828894311))*(((tmp = -1121326205.614264, tmp)^(-2057547855))<<(tmp = -2758835896, tmp)))); - assertEquals(NaN, x %= ((tmp = -2138671333, tmp)%x)); - assertEquals(0, x &= x); - assertEquals(665568613.0328879, x += (665568613.0328879)); - assertEquals(317, x >>= (2627267349.735873)); - assertEquals(0, x -= x); - assertEquals(0, x &= (((tmp = 3030611035, tmp)*(((tmp = 476143340.933007, tmp)>>(x-(2238302130.2331467)))|(x|x)))%(tmp = 320526262, tmp))); - assertEquals(0, x <<= (tmp = 729401206, tmp)); - assertEquals(0, x >>>= (1721412276)); - assertEquals(217629949.3530736, x += ((tmp = 217629949.3530736, tmp)%((-931931100.601475)%(x^(tmp = -2149340123.548764, tmp))))); - assertEquals(217629949.3530736, x %= (tmp = 2275384959.4243402, tmp)); - assertEquals(0, x >>>= (1112677437.5524077)); - assertEquals(0, x *= (500256656.7476063)); - assertEquals(0, x >>>= x); - assertEquals(0, x -= x); - assertEquals(0, x -= x); - assertEquals(0, x &= (-1076968794)); - assertEquals(0, x /= (tmp = 1774420931.0082943, tmp)); - assertEquals(0, x |= x); - assertEquals(0, x >>= x); - assertEquals(0, x %= (-2978890122.943079)); - assertEquals(-0, x /= (tmp = -2954608787, tmp)); - assertEquals(-800048201, x ^= ((tmp = -800048201.7227018, tmp)>>>((-2016227566.1480863)/(tmp = -2263395521, tmp)))); - assertEquals(3333, x >>>= (-2038839052)); - assertEquals(487957736.625432, x += (487954403.625432)); - assertEquals(-1650983426, x |= (2643918270)); - assertEquals(-1861867448, x &= (tmp = -251254199.12813115, tmp)); - assertEquals(-7.934314690172143e-18, x %= ((((x^(-703896560.6519544))>>(tmp = -1853262409, tmp))/(tmp = -1168012152.177894, tmp))/(tmp = 837616075.1097361, tmp))); - assertEquals(0, x ^= x); - assertEquals(0, x &= (tmp = -2328150260.5399947, tmp)); - assertEquals(-1954860020, x |= (tmp = 2340107276, tmp)); - assertEquals(-1954860020, x >>= ((tmp = 159177341, tmp)*(x&(-705832619)))); - assertEquals(-1954895727, x -= (x>>>((-1443742544.7183702)^((((tmp = 869581714.0137681, tmp)+x)^((x%(tmp = -1036566362.5189383, tmp))^(x%x)))>>x)))); - assertEquals(1.0241361338078498, x /= (tmp = -1908824093.2692068, tmp)); - assertEquals(16777216, x <<= (x*(((-1925197281)^(tmp = -1392300089.4750946, tmp))|x))); - assertEquals(-225882765524992, x *= (tmp = -13463662, tmp)); - assertEquals(-1845493760, x |= x); - assertEquals(-1845493760, x %= (tmp = 3181618519.786825, tmp)); - assertEquals(0, x ^= x); - assertEquals(0, x <<= x); - assertEquals(0, x >>>= x); - assertEquals(NaN, x /= (x>>>x)); - assertEquals(NaN, x %= (((((tmp = -521176477, tmp)>>(((tmp = 370693623, tmp)/(((tmp = -1181033022.4136918, tmp)>>(x|(x*(2601660441))))+(tmp = -1696992780, tmp)))|(x|(-1197454193.198036))))>>>(((2512453418.3855605)+((((((tmp = 799501914, tmp)&(((1788580469.7069902)*(((((1476778529.5109258)<<(tmp = -1873387738.3541565, tmp))-((tmp = -521988584.7945764, tmp)*(-1598785351.3914914)))&(-1899161721.8061454))&((x/x)*(690506460))))>>>((tmp = 2255896398.840741, tmp)>>((tmp = -1331486014.6180065, tmp)+(-1159698058.534132)))))*((1112115365.2633948)&((x>>((x>>(-784426389.4693215))&(-492064338.97227573)))>>x)))^((x-((tmp = 2986028023, tmp)>>(tmp = 2347380320.00517, tmp)))*(tmp = -1463851121, tmp)))*(tmp = -1059437133, tmp))%(x-(tmp = 1238739493.7636225, tmp))))^(2029235174)))*(-1923899530))>>>x)); - assertEquals(0, x >>>= (2848792983.510682)); - assertEquals(0, x >>= (((tmp = 3042817032.705198, tmp)>>>x)&((((tmp = -829389221, tmp)-((2669682285.8576303)+(tmp = 1812236814.3082042, tmp)))^x)%((tmp = -2401726554, tmp)^((tmp = 2464685683, tmp)|(-2685039620.224061)))))); - assertEquals(2069649722, x |= (2069649722.311271)); - assertEquals(NaN, x %= (((((-68757739.39282179)&(-1382816369))/(3122326124))<<(x-(-507995800.3369653)))<<(((-1962768567.343907)+((tmp = 1357057125, tmp)/x))^(tmp = 1997617124, tmp)))); - assertEquals(NaN, x += x); - assertEquals(0, x >>= (26895919)); - assertEquals(0, x >>>= x); - assertEquals(0, x %= (tmp = 1092448030, tmp)); - assertEquals(0, x <<= (tmp = -477672441.46258235, tmp)); - assertEquals(0, x /= (2113701907)); - assertEquals(0, x >>>= x); - assertEquals(NaN, x /= x); - assertEquals(1341078673, x |= (-2953888623)); - assertEquals(1341078673, x &= x); - assertEquals(0, x %= x); - assertEquals(414817852.151006, x -= (-414817852.151006)); - assertEquals(1006632960, x <<= ((((((126465614.8316778)+(x-(2511803375)))+(tmp = 1620717148.352402, tmp))*x)/(tmp = -3013745105.5275207, tmp))-((tmp = -418034061.6865432, tmp)/(-300492911)))); - assertEquals(1055624813, x |= (tmp = 921407085, tmp)); - assertEquals(-3, x |= ((((tmp = 1382397819.7507677, tmp)+(tmp = -111851147.7289567, tmp))+x)/((tmp = 247980405.7238742, tmp)^(tmp = -592156399.8577058, tmp)))); - assertEquals(35161, x &= (((((((-2973570544.725141)*(tmp = -1244715638, tmp))+x)<<(x/((x>>>(-2143371615.073137))/(226072236))))%((x-(tmp = 1971392936, tmp))^(tmp = 2653103658, tmp)))%((tmp = 2828319571.7066674, tmp)>>((1528970502)^((tmp = -55869558, tmp)%x))))>>(889380585.6738582))); - assertEquals(0, x ^= x); - assertEquals(0, x *= (2749718750)); - assertEquals(0, x >>>= ((((-1633495402.6252813)*(tmp = 2943656739.1108646, tmp))+(tmp = 977432165, tmp))&((tmp = -2338132019, tmp)*(408176349.8061733)))); - assertEquals(-1778794752, x -= (((tmp = -1391412154.5199084, tmp)-((-3172342474)|x))&(1854366052))); - assertEquals(-1778794752, x %= (tmp = 2024807296.6901965, tmp)); - assertEquals(-1114410.466337204, x %= ((tmp = -240344444.24487805, tmp)%(-47661164))); - assertEquals(-0, x %= x); - assertEquals(0, x >>= (x>>x)); - assertEquals(0, x *= x); - assertEquals(0, x /= ((-3134902611)|(tmp = -3131158951, tmp))); - assertEquals(-0, x /= (((tmp = 1430247610.634234, tmp)&x)+((tmp = -2047191110.8623483, tmp)-((((x%((((x/(tmp = -2599234213, tmp))|(tmp = 2650380060, tmp))|x)+x))>>>x)&(-1961373866))<<x)))); - assertEquals(-718394682, x -= ((x|(tmp = 1764417670.8577194, tmp))%(1046022988))); - assertEquals(3576572614, x >>>= (((tmp = 2480472883.078992, tmp)<<x)>>((2035208402.8039393)&(tmp = 492980449, tmp)))); - assertEquals(434034142, x %= (x&((x>>>(311110449.48751545))|(-243530647)))); - assertEquals(524703439.3065736, x += (((tmp = 1392771723.3065736, tmp)%(x&x))%(tmp = -2199704930, tmp))); - assertEquals(373686272, x &= (x<<((tmp = 2103372351.9456532, tmp)%(tmp = -1367109519, tmp)))); - assertEquals(373686272, x >>= x); - assertEquals(-0.12245430020241108, x /= (tmp = -3051638622.5907507, tmp)); - assertEquals(1, x /= x); - assertEquals(1, x %= (3095983855)); - assertEquals(-1454736871, x ^= (x*(tmp = -1454736872, tmp))); - assertEquals(-1454736866, x ^= (((724989405.7338341)|(tmp = -2834298786.384371, tmp))>>>(tmp = -2029602148.1758833, tmp))); - assertEquals(-1454736866, x &= x); - assertEquals(-197394432, x <<= (tmp = -1562128975, tmp)); - assertEquals(251658240, x <<= (tmp = 2126510950, tmp)); - assertEquals(3295700610.703306, x -= (tmp = -3044042370.703306, tmp)); - assertEquals(-51152917, x |= ((949179883.1784958)|(((tmp = -2046168220, tmp)>>(x/x))/(((835064313)*(tmp = 2197600689, tmp))^(((tmp = 2717104216, tmp)&x)<<(-1402661995.3845913)))))); - assertEquals(-1549204421, x ^= ((((tmp = -481013711, tmp)>>>((tmp = 119589341.80209589, tmp)%(-995489985.2905662)))-(635717011))^(x+(x*x)))); - assertEquals(-1078356672.3999934, x += (470847748.6000067)); - assertEquals(1484987268.4638166, x += (tmp = 2563343940.86381, tmp)); - assertEquals(277020804, x &= (tmp = 2532819117, tmp)); - assertEquals(-2097118208, x <<= (x>>>x)); - assertEquals(-2147483648, x <<= (tmp = 761285045, tmp)); - assertEquals(2147483648, x >>>= x); - assertEquals(-935909870282997800, x *= ((-2583300643)|x)); - assertEquals(-370753566.54721737, x %= (-1084543510.4524941)); - assertEquals(-177, x >>= (-946264747.6588805)); - assertEquals(-416077682, x ^= (tmp = 416077761, tmp)); - assertEquals(NaN, x %= ((((tmp = 779607408, tmp)*(((tmp = -3007128117, tmp)*(851442866.6153773))+x))&(1283388806))/(-876363553))); - assertEquals(NaN, x %= (x/(tmp = -1668413939.652408, tmp))); - assertEquals(-1726405921, x ^= (tmp = -1726405921, tmp)); - assertEquals(-1, x >>= ((3031008213.807012)>>x)); - assertEquals(4294967295, x >>>= ((x>>>x)&(tmp = 2788082290, tmp))); - assertEquals(8544111670008449000, x *= (tmp = 1989331020.0417833, tmp)); - assertEquals(268435456, x <<= (tmp = 3121736017.2098465, tmp)); - assertEquals(-2.1011176170964474e+26, x -= (((tmp = 1392503299, tmp)*(tmp = 1446108825.1572113, tmp))*(x^(tmp = 372776014.213725, tmp)))); - assertEquals(0, x |= x); - assertEquals(0, x >>= ((-112413907.70074797)*(-702798603))); - assertEquals(1829518838, x |= (tmp = -2465448458, tmp)); - assertEquals(57172463, x >>= ((tmp = 2979642955.241792, tmp)%(tmp = -2464398693.291434, tmp))); - assertEquals(114344926, x += x); - assertEquals(113279134, x &= (2397742238.6877637)); - assertEquals(54, x >>= (1908522709.6377516)); - assertEquals(-2.966982919573829e-7, x /= (tmp = -182003070, tmp)); - assertEquals(0, x <<= (-1078417156)); - assertEquals(-147831390, x ^= (((-147831390)>>>x)+x)); - assertEquals(0, x -= x); - assertEquals(-242221450.44696307, x -= (tmp = 242221450.44696307, tmp)); - assertEquals(-484442900, x <<= (((tmp = -2033947265.088614, tmp)&x)/(x^(tmp = -2893953848, tmp)))); - assertEquals(-3227648, x <<= (x<<((tmp = -193993010, tmp)*((983187830)|(3146465242.2783365))))); - assertEquals(-6455296, x += x); - assertEquals(-1771542585, x -= (x^(tmp = -1767335879, tmp))); - assertEquals(-0, x %= x); - assertEquals(0, x >>>= ((((tmp = -1612864670.4532743, tmp)*(tmp = 786265765.210487, tmp))*((((tmp = -893735877.3250401, tmp)*((x^(tmp = -2804782464.233885, tmp))<<x))&(x-x))^x))<<x)); - assertEquals(0, x -= (x>>>(-1648118674.380736))); - assertEquals(0, x >>= ((tmp = -2706058813.0028524, tmp)>>(2745047169))); - assertEquals(0, x += x); - assertEquals(0, x %= (-898267735.137356)); - assertEquals(0, x >>>= x); - assertEquals(0, x >>= ((265527509)/((tmp = 2190845136.7048635, tmp)+((x>>x)>>>((x%(x-x))&((((-2080184609.8989801)&((-327231633)>>>((tmp = 864849136, tmp)%(((-524363239)*(((((tmp = 2245852565.3713694, tmp)&(1918365.8978698254))>>>(tmp = -2463081769, tmp))-(((2438244059.471446)|((((-135303645.38470244)*(-861663832.2253196))%(tmp = 1273185196.0261836, tmp))|((2261539338.832875)%((320267076.2363237)+x))))>>(tmp = -2731398821, tmp)))/(tmp = -1947938611, tmp)))^x))))>>(tmp = 833666235, tmp))|x)))))); - assertEquals(-1116704570, x ^= (-1116704570)); - assertEquals(1379561710, x ^= (tmp = -280362968.19654894, tmp)); - assertEquals(-1673822208, x <<= x); - assertEquals(-1673822208, x |= (x<<(tmp = 1389479193.9038138, tmp))); - assertEquals(2559712, x >>>= (-2703763734.0354066)); - assertEquals(2593499, x ^= (x>>>((tmp = 148668150.03291285, tmp)^(tmp = -1580360304, tmp)))); - assertEquals(2070393855, x |= (tmp = -2227002907, tmp)); - assertEquals(304197770, x &= (tmp = 2453257354, tmp)); - assertEquals(304197770, x <<= ((-669331453.8814087)-(x^(x^(tmp = 33804899.98928583, tmp))))); - assertEquals(297068, x >>= x); - assertEquals(Infinity, x /= (x-x)); - assertEquals(NaN, x %= x); - assertEquals(0, x ^= x); - assertEquals(0, x %= ((tmp = 1723087085, tmp)%(2859382131.304421))); - assertEquals(0, x %= (((tmp = 2935439763, tmp)<<(-3163992768.637094))%(tmp = 67176733, tmp))); - assertEquals(0, x &= (tmp = 2480771277, tmp)); - assertEquals(0, x >>>= (x+(tmp = -3168690063, tmp))); - assertEquals(0, x *= ((tmp = -1915275449.1806245, tmp)>>>((tmp = -1644482094.1822858, tmp)/(tmp = -432927173, tmp)))); - assertEquals(0, x += (((2766509428.071809)/(x/((942453848.5423365)/(((tmp = -1284574492, tmp)&((tmp = 760186450.7301528, tmp)-(2464974117.358138)))/((x/(x|(672536969)))*(x>>(-1272232579)))))))>>(x*(-3175565978)))); - assertEquals(-1277710521, x -= (1277710521)); - assertEquals(-1277710521, x >>= (((tmp = -2349135858, tmp)-x)-x)); - assertEquals(-1277710521, x >>= ((tmp = 2135645051, tmp)*(tmp = -2468555366, tmp))); - assertEquals(-155971, x >>= (-1294859507)); - assertEquals(-0, x %= x); - assertEquals(0, x >>>= (((861078292.6597499)|(-268063679))-(((((-221864206.9494424)-(-3186868203.2201176))&(tmp = 1287132927, tmp))<<(((tmp = 1964887915, tmp)<<((25908382)^(tmp = -688293519.875164, tmp)))*(2075946055)))&(x-((x>>x)&(1395338223.7954774)))))); - assertEquals(788002218, x -= (-788002218)); - assertEquals(716399906, x &= (-1145868506)); - assertEquals(145776674, x &= (-1661931477.360386)); - assertEquals(145776674, x |= x); - assertEquals(-0.05255700469257692, x /= (tmp = -2773686873, tmp)); - assertEquals(-660918434, x |= (-660918434.2915542)); - assertEquals(1223537346, x ^= (tmp = -1871274596, tmp)); - assertEquals(305884336, x >>= (x&x)); - assertEquals(-1.1123775647978218e-8, x *= ((tmp = -793393031.4229445, tmp)/((tmp = -503919284, tmp)*(((((tmp = 429810625, tmp)>>>x)-((2091544148.870375)<<(((((x^x)%x)|x)/(-260773261))<<((tmp = -1323834653, tmp)&x))))*((-1231800099.3724015)+x))*((x+((-559726167)^x))>>>((-549148877)<<((((tmp = 1196115201, tmp)/((tmp = -2654658968.390111, tmp)%(tmp = -1044419580, tmp)))*(((((x>>>(733571228))+(2919762692.511447))/(-2718451983.570547))^x)+((2891533060.1804514)^((tmp = -2514488663, tmp)&x))))<<(tmp = -2526139641.6733007, tmp)))))))); - assertEquals(0, x >>>= x); - assertEquals(0, x *= x); - assertEquals(0, x |= x); - assertEquals(3076984066.336236, x -= ((tmp = -3076984066.336236, tmp)+((tmp = -446575828.5155368, tmp)&x))); - assertEquals(1, x /= x); - assertEquals(1513281647.839972, x *= (1513281647.839972)); - assertEquals(1251138155, x ^= ((tmp = 2124481052, tmp)&(2431937351.4392214))); - assertEquals(1, x /= x); - assertEquals(0, x &= (tmp = 627050040, tmp)); - assertEquals(497153016, x ^= (497153016)); - assertEquals(-1112801283, x |= (tmp = 2752196557, tmp)); - assertEquals(0.5735447276296568, x /= ((((tmp = -500878794, tmp)%(tmp = -2559962372.2930336, tmp))%(2661010102))+(tmp = -1439338297, tmp))); - assertEquals(1.0244795995097235e-9, x /= (559840067)); - assertEquals(0.43468811912309857, x *= (424301391)); - assertEquals(-1972757928, x ^= (tmp = -1972757928.9227014, tmp)); - assertEquals(-606757265, x ^= (tmp = -2923461577.264596, tmp)); - assertEquals(-37, x >>= (((-2736561559.7474318)%(tmp = -27668972.662741184, tmp))*(2774711606))); - assertEquals(-1923785671, x += ((-1923785597)+x)); - assertEquals(-3877639176, x += (tmp = -1953853505, tmp)); - assertEquals(-4688259242, x -= ((810620066.4394455)>>(((-1474285107.459875)>>x)/(((((-570672326.4007359)>>(tmp = -3086802075, tmp))%x)>>>(((tmp = 286938819.28193486, tmp)>>>((1712478502)>>(tmp = 3045149117.796816, tmp)))<<(tmp = 750463263.292952, tmp)))&(tmp = 2055350255.5669963, tmp))))); - assertEquals(-0, x %= x); - assertEquals(0, x <<= (1037856162.5105649)); - assertEquals(0, x *= x); - assertEquals(0, x &= (997845077.4917375)); - assertEquals(0, x *= x); - assertEquals(0, x *= x); - assertEquals(0, x <<= (((x<<x)&(57691805))>>(786927663))); - assertEquals(0, x ^= x); - assertEquals(0, x += x); - assertEquals(0, x &= (-2131910624.1429484)); - assertEquals(0, x >>>= (-43787814)); - assertEquals(-2415062021, x += (tmp = -2415062021, tmp)); - assertEquals(-4830124042, x += x); - assertEquals(-186683401, x |= (tmp = 1960135383, tmp)); - assertEquals(NaN, x *= ((tmp = -1674740173.9864025, tmp)%(((((((-432895485.7261934)-x)^x)>>>(((-1627743078.3383338)>>(179992151))<<((tmp = 911484278.0555259, tmp)|(((tmp = -3042492703, tmp)>>(((-663866035.302746)>>(((x-((440661929.50030375)>>>(tmp = 263692082, tmp)))*x)+x))/((1546004407)^(((tmp = 2023662889.1594632, tmp)*(tmp = -2456602312, tmp))+(tmp = 755602286.1810379, tmp)))))%((tmp = -336449961, tmp)|(tmp = 206780145, tmp))))))/(1068005219.1508512))<<(tmp = -474008862.6864624, tmp))/(((((((1518711056.5437899)>>>(tmp = 287418286.63085747, tmp))<<(tmp = 2823048707, tmp))^(((x<<(x^(-1600970311)))&(x>>(((tmp = 157300110.7636031, tmp)*(tmp = -3047000529, tmp))&(1743024951.3535223))))>>x))-(tmp = -2895435807, tmp))*((tmp = -314120704, tmp)&(tmp = 1759205369, tmp)))>>(tmp = 1833555960.046526, tmp))))); - assertEquals(NaN, x -= (tmp = 694955369, tmp)); - assertEquals(NaN, x *= (x%x)); - assertEquals(0, x |= x); - assertEquals(0, x ^= x); - assertEquals(0, x &= x); - assertEquals(NaN, x /= (x+x)); - assertEquals(NaN, x %= ((tmp = -1595988845, tmp)*((1754043345)>>>(-601631332)))); - assertEquals(0, x >>>= (tmp = 862768754.5445609, tmp)); - assertEquals(NaN, x /= x); - assertEquals(NaN, x %= x); - assertEquals(NaN, x *= (tmp = -1774545519, tmp)); - assertEquals(0, x >>>= (tmp = -2492937784, tmp)); - assertEquals(0, x %= ((((x<<(-1657262788.2028513))&((x^(tmp = -671811451, tmp))<<(-2984124996)))^(1455422699.7504625))-((-340550620)>>x))); - assertEquals(918278025, x ^= ((tmp = -918278027, tmp)^((tmp = 2889422870, tmp)/(tmp = -657306935.7725658, tmp)))); - assertEquals(918278025, x %= (2603186571.0582614)); - assertEquals(107034679.32509923, x %= (tmp = -811243345.6749008, tmp)); - assertEquals(53517339, x >>= (x%((((x*((tmp = -983766424, tmp)^(-1881545357.8686862)))|(tmp = -1429937087, tmp))>>((x<<x)>>((((tmp = -2347470476, tmp)&x)+((x&x)<<(396061331.6476157)))*(tmp = -3136296453.209073, tmp))))>>>(((tmp = 908427836, tmp)|(tmp = 207737064, tmp))|(((1253036041)-(tmp = 2705074182, tmp))+(-431215157.82083917)))))); - assertEquals(53477378, x &= ((((-1128036654.165636)*x)+x)>>(x>>(3080099059)))); - assertEquals(0, x >>= (-590692293)); - assertEquals(0, x %= (-2395850570.9700127)); - assertEquals(0, x *= ((tmp = 1377485272, tmp)&(1129370608))); - assertEquals(0, x += (x>>>(x%(((((tmp = -1746827236, tmp)+((tmp = -326913490, tmp)&((-58256967)&x)))*(tmp = -1176487022.001651, tmp))>>>(-2089147643))-x)))); - assertEquals(0, x <<= (tmp = 1073298160.2914447, tmp)); - assertEquals(-837811832, x ^= (-837811832)); - assertEquals(102760448, x <<= (tmp = 2833582450.4544373, tmp)); - assertEquals(0, x &= (((((((tmp = 2595641175, tmp)*x)+(tmp = -2049260172.1025927, tmp))%((2986747823)>>(tmp = -2120598518, tmp)))&((tmp = -2742408622, tmp)&x))>>x)*((1043474247.9601482)&(tmp = 1686365779.9885998, tmp)))); - assertEquals(0, x >>= ((tmp = 1717862848, tmp)-(tmp = 1077024446.4160957, tmp))); - assertEquals(NaN, x /= x); - assertEquals(NaN, x /= (-1669429787.975099)); - assertEquals(NaN, x -= (-2299895633.4807186)); - assertEquals(138173970, x ^= (138173970.56627905)); - assertEquals(-2084183776, x <<= (3073345316)); - assertEquals(-0, x %= x); - assertEquals(0, x >>= (-3080556066.068573)); - assertEquals(0, x &= ((tmp = -2587514820, tmp)*(x-((x^(1995672257))*(1125326747.2339358))))); - assertEquals(NaN, x %= x); - assertEquals(0, x >>= (tmp = 2139186585, tmp)); - assertEquals(-1904096640, x |= ((-602301360.1919911)*(-1270444810))); - assertEquals(1073741824, x <<= (tmp = -1069467849, tmp)); - assertEquals(1073741824, x ^= (x-x)); - assertEquals(536870912, x >>>= (-1579466367.160293)); - assertEquals(512, x >>= (972402804.3890183)); - assertEquals(512, x &= (tmp = 2664796831, tmp)); - assertEquals(16777216, x <<= (-2738292561)); - assertEquals(0, x >>>= ((((1397663615.3889246)|(1117420260.6730964))-(-1173734560))<<((tmp = 1007006104.0172879, tmp)<<((tmp = -623002097, tmp)%(tmp = -35829654.379403114, tmp))))); - assertEquals(1200191544, x ^= (tmp = -3094775752, tmp)); - assertEquals(71, x >>>= x); - assertEquals(71, x |= x); - assertEquals(1394763772, x += (1394763701)); - assertEquals(-1.492717171027427, x /= ((x&(tmp = 1243787435, tmp))-(2043911970.26752))); - assertEquals(-1.1002448961224718e-8, x /= ((((835185744)*(((tmp = 2165818437, tmp)^(tmp = 2567417009.1166553, tmp))/x))/x)/(((63485842.39971793)^(2668248282.597389))/x))); - assertEquals(0, x <<= (tmp = 1598238578.637568, tmp)); - assertEquals(0, x |= (x&((tmp = -1812945547.5373957, tmp)>>>x))); - assertEquals(0, x >>>= (x+(-1969679729.7299538))); - assertEquals(1582033662, x += (tmp = 1582033662, tmp)); - assertEquals(1, x >>>= x); - assertEquals(-550748739, x += ((tmp = -550748740, tmp)/(x&((2537822642.235506)^((-2167656297)%(tmp = 1161201210, tmp)))))); - assertEquals(-268921, x >>= (tmp = 1916069547.7381654, tmp)); - assertEquals(-0.00021776939364231114, x /= (tmp = 1234888868, tmp)); - assertEquals(0, x <<= (-1036375023)); - assertEquals(0, x &= ((((x/(2398886792.27443))&(x|((-1813057854.1797302)-x)))&(x/(((tmp = 3091133731.4967556, tmp)|(3013139691.823039))<<x)))>>>(2542784636.963599))); - assertEquals(0, x += ((x*x)/(tmp = 347079383, tmp))); - assertEquals(788347904, x |= ((1462257124.6374629)*((3180592147.4065146)-(x&(1922244678))))); - assertEquals(2130672735, x |= (tmp = -2846986145, tmp)); - assertEquals(-1331327970, x ^= ((656251304)-(tmp = 1489152359, tmp))); - assertEquals(-0.14377179742889856, x %= (((2889747597.813753)-(1730428996))/(((tmp = -1378710998, tmp)&x)|x))); - assertEquals(-1754612583.143772, x += ((-1754725729)^((-2285838408)>>>(1434074349)))); - assertEquals(-0, x %= x); - assertEquals(0, x &= (tmp = -1031961332, tmp)); - assertEquals(NaN, x /= x); - assertEquals(NaN, x /= (3059476325)); - assertEquals(NaN, x *= ((x*((((tmp = 13529540.462185979, tmp)&x)^((x<<(-1312696238.1628869))&(-2029766712.3852897)))>>x))/x)); - assertEquals(1657339940, x ^= ((tmp = -488956817.1491232, tmp)&(tmp = -2352413900.1983714, tmp))); - assertEquals(-530683621952432200, x *= (tmp = -320202035.2882054, tmp)); - assertEquals(229226258, x ^= ((tmp = -1263410990.026416, tmp)+(((-808046349)&(tmp = -1294442506, tmp))&((tmp = 1147437219, tmp)<<((tmp = -820299900, tmp)-(tmp = -1947748943.3443851, tmp)))))); - assertEquals(7163320, x >>= (-2631307131)); - assertEquals(-68, x |= (((-1271721343)>>x)%x)); - assertEquals(-39956523818.38862, x *= (587595938.505715)); - assertEquals(0, x -= x); - assertEquals(0, x >>>= ((x^(x+x))<<(tmp = 265212367, tmp))); - assertEquals(0, x |= (((x>>((tmp = 2294761023, tmp)/(x>>(2125624288))))&((-2125650113)|(tmp = 1014409884, tmp)))%(tmp = -527324757, tmp))); - assertEquals(0, x >>= ((tmp = 2267075595, tmp)*(-1681569641.8304193))); - assertEquals(0, x >>>= x); - assertEquals(0.5738410949707031, x -= ((tmp = -1846572645.573841, tmp)%((((((x^(((-156613905.64173532)/x)<<x))+((x|((2405109060)>>>x))^x))/(570585894.8542807))+(x&(-2544708558)))^((((tmp = -2539082152.490635, tmp)+((((-657138283)/(2204743293))-((tmp = -1422552246.565012, tmp)+x))<<(x-x)))>>(x/(x>>>(tmp = -3027022305.484394, tmp))))<<x))&((-2066650303.3258202)/(tmp = -1666842593.0050385, tmp))))); - assertEquals(0, x >>>= ((((tmp = 2473451837.613817, tmp)>>((2526373359.1434193)>>(x<<x)))+((tmp = -579162065, tmp)+((tmp = -3115798169.551487, tmp)-(tmp = 933004398.9618305, tmp))))&(tmp = 131167062, tmp))); - assertEquals(-2067675316, x ^= (-2067675316.6300585)); - assertEquals(543772, x >>>= x); - assertEquals(-1073741824, x <<= x); - assertEquals(3221225472, x >>>= ((x*(1478586441.081221))&(tmp = -3050416829.2279186, tmp))); - assertEquals(0, x ^= x); - assertEquals(0, x *= x); - assertEquals(-1017771903.0298333, x -= (1017771903.0298333)); - assertEquals(0.6404112721149928, x /= ((tmp = -144667370, tmp)^(-2849599562))); - assertEquals(-2410517638773644000, x -= (((tmp = 1759631550, tmp)*x)*((((tmp = -2949481475, tmp)>>>x)*x)|(tmp = -2977983804, tmp)))); - assertEquals(-0, x %= (x+((((tmp = -1307866327.7569134, tmp)<<((x&((tmp = -2380043169.8405933, tmp)|x))>>(472992789.7639668)))|(((((x<<(tmp = -1416427232.7298179, tmp))%(-1404989679.409946))*((x/(tmp = -992416608, tmp))/(tmp = 524646495, tmp)))-(tmp = 734405570, tmp))>>x))/(1079256317.7325506)))); - assertEquals(0, x <<= (tmp = 2459834668, tmp)); - assertEquals(-0, x /= (tmp = -1892164840.5719755, tmp)); - assertEquals(0, x >>= (x|(((1299844244)>>>(((tmp = -2422924469.9824634, tmp)|x)-((((1914590293.2194016)+(-3033885853.8243046))-((tmp = -1720088308, tmp)%x))<<(tmp = 2210817619, tmp))))<<x))); - assertEquals(0, x <<= (((tmp = 3192483902.841396, tmp)>>>(((x^(2944537154))|(tmp = -1334426566, tmp))*(((((((-2705218389)&x)+(1987320749))+(tmp = -111851605, tmp))|(2894234323))-(265580345))&x)))%(((tmp = 1431928204.6987057, tmp)&(tmp = 914901046, tmp))&(x>>>x)))); - assertEquals(0, x >>>= (tmp = 1941940941, tmp)); - assertEquals(0, x %= (3089014384)); - assertEquals(0, x += ((tmp = 2948646615, tmp)*x)); - assertEquals(-0, x /= (tmp = -1480146895, tmp)); - assertEquals(NaN, x /= x); - assertEquals(NaN, x %= (-2995257724.158043)); - assertEquals(NaN, x %= (tmp = 2714835455, tmp)); - assertEquals(NaN, x /= (tmp = -311440765.98078775, tmp)); - assertEquals(NaN, x -= (-1600234513.697098)); - assertEquals(0, x <<= x); - assertEquals(0, x <<= (-1499045929)); - assertEquals(-0, x *= (-2491783113)); - assertEquals(0, x ^= (x%((x>>(((1234398704.3681123)>>>x)%(x+x)))>>(402257223.4673699)))); - assertEquals(-643225204, x ^= (((-55960194.698637486)+((((721411198)-(((tmp = 1308676208.7953796, tmp)%(2242904895))-x))>>((((tmp = 332791012, tmp)&((tmp = -2094787948, tmp)/((x/(2427791092))^(2444944499.6414557))))%(((x+(1253986263.5049214))+(((((3135584075.248715)+((tmp = -2569819028.5414333, tmp)%(440908176.1619092)))>>>(x<<((3061615025)-x)))%x)%(x+((2369612016)*((((tmp = 1173615806, tmp)*(-1910894327))&(2428053015.077821))*(-55668334.70082307))))))<<(tmp = -2129259989.0307562, tmp)))+(1579400360)))%((-3053590451.8996153)>>x)))+(x>>(x%(x^((-1772493876)^x)))))); - assertEquals(413738663060841600, x *= x); - assertEquals(1581062538.4501781, x %= ((tmp = -1298397672.0300272, tmp)-((2237197923)+(tmp = -1385478459, tmp)))); - assertEquals(755644566.8709538, x %= (tmp = -825417971.5792243, tmp)); - assertEquals(1, x /= x); - assertEquals(0, x >>>= ((89330582)%(-1012731642.4855506))); - assertEquals(0, x >>>= x); - assertEquals(NaN, x %= ((x>>>((x/(tmp = -1848848941.2352903, tmp))>>>(tmp = -71862893, tmp)))&(-2385996598.2015553))); - assertEquals(NaN, x += (-2292484503.318904)); - assertEquals(NaN, x *= (2961064461)); - assertEquals(NaN, x += (x<<((2076798243.6442)/((tmp = -81541044.75366282, tmp)^((3041366498.551101)+((2126874365)/(tmp = -177610359, tmp))))))); - assertEquals(NaN, x %= ((x/((x/x)+x))>>>x)); - assertEquals(NaN, x /= x); - assertEquals(NaN, x += (1171761980.678)); - assertEquals(NaN, x += ((2355675823)<<(-390497521))); - assertEquals(NaN, x %= x); - assertEquals(0, x &= (tmp = -658428225.56619, tmp)); - assertEquals(0, x ^= x); - assertEquals(0, x <<= (1643310725.5713737)); - assertEquals(0, x <<= x); - assertEquals(0, x <<= (-397005335.3712895)); - assertEquals(0, x >>>= (tmp = -2804713458.166788, tmp)); - assertEquals(0, x <<= (((((((tmp = 1879988501, tmp)%(1528081313.9360204))+(1376936736))*((((x>>>((1736268617.339198)>>>(-2598735297.4277673)))<<((((((((-2742982036)/(231867353.4549594))-(875335564))<<x)|((2241386341.742653)<<((-22024910.828409433)&(x<<x))))*(-756987803.5693252))+x)^(tmp = 1084498737, tmp)))<<(1920373881.8464394))&(2370827451.82652)))&(x^(tmp = -891503574, tmp)))<<x)>>>((-1519588625.2332087)^(483024636.2600144)))); - assertEquals(52193878.40997505, x -= ((tmp = -341753803.40997505, tmp)%(tmp = -96519975, tmp))); - assertEquals(-1665844168.938803, x -= (1718038047.348778)); - assertEquals(3.6962232549405003e-19, x /= (((((-809583468.5507183)>>>((tmp = 286797763, tmp)%((1579183142.7321532)/(1853824036.001172))))<<x)>>(((x|x)^((tmp = -2641304815, tmp)<<(x<<x)))>>(((((268338128.8300134)&(-1778318362.8509881))*(751081373.346478))<<(((525066612)>>(-1139761212))*(2949167563.299916)))<<x)))+((tmp = 664905121, tmp)*((-2208280205)*(3069462420))))); - assertEquals(4710721795.110161, x += (((217604832)+((1307891481.781326)-x))+(tmp = 3185225481.328835, tmp))); - assertEquals(0, x %= x); - assertEquals(0, x -= (((x>>>(x/(tmp = 46977522.46204984, tmp)))>>(-2466993199.615269))&(tmp = 14524430.287991166, tmp))); - assertEquals(0, x >>= x); - assertEquals(0, x /= (tmp = 578120637, tmp)); - assertEquals(-17267104, x -= (((tmp = 1515285919.495792, tmp)+(((tmp = -1364790286.7057304, tmp)+((954599071)>>((897770243.1509961)*x)))^x))>>>(566027942.1732262))); - assertEquals(-17267104, x &= x); - assertEquals(189138241, x ^= ((tmp = 1565742675.9503145, tmp)-((tmp = 1737806643, tmp)|((x*(tmp = -1382435297.5955122, tmp))*(-2820516692.153056))))); - assertEquals(189138241, x %= (x*(tmp = -1670678493, tmp))); - assertEquals(1693, x %= ((-2328713314)>>>(1623637325))); - assertEquals(1693, x %= ((-1019394014)*(x|x))); - assertEquals(3386, x += x); - assertEquals(9268970871604, x *= (2737439714)); - assertEquals(-4720.120483643183, x /= (tmp = -1963714889, tmp)); - assertEquals(-1, x >>= ((x^(((-2404688047.455056)|((1439590234.6203847)<<(tmp = -2496557617, tmp)))/((x<<((tmp = 1865549512.282249, tmp)/(((360384191.55661833)>>(tmp = -1225297117.344188, tmp))>>>(2703264010.4122753))))*(1521960888.0071676))))%(tmp = 2834001448.0508294, tmp))); - assertEquals(63, x >>>= (x&(-3079339174.6490154))); - assertEquals(0, x >>>= (1039770956.6196513)); - assertEquals(0, x >>>= (-1074820214)); - assertEquals(0, x >>>= (x/x)); - assertEquals(0, x >>= ((tmp = -449117604.2811785, tmp)&x)); - assertEquals(-0, x /= (tmp = -118266935.1241343, tmp)); - assertEquals(2226140134, x += (tmp = 2226140134, tmp)); - assertEquals(2068827161, x ^= ((tmp = -1950744808.846384, tmp)>>((2258661151)^((tmp = -1118176421.8650177, tmp)<<(2828634014))))); - assertEquals(123, x >>>= (-1779624840.0515127)); - assertEquals(0, x >>>= (x|((tmp = -239082904, tmp)<<(tmp = 1404827607, tmp)))); - assertEquals(0, x >>>= x); - assertEquals(1793109749, x ^= (tmp = -2501857547.710491, tmp)); - assertEquals(855, x >>>= x); - assertEquals(0, x >>>= (-847289833)); - assertEquals(0, x %= (-2271241045)); - assertEquals(169648072, x ^= (((tmp = 169648072.66759944, tmp)^x)|x)); - assertEquals(176025927479164930, x *= ((tmp = 1111997198.8803885, tmp)<<(tmp = 2913623691, tmp))); - assertEquals(176025926613281700, x += ((tmp = -865883245, tmp)<<(x+(-2624661650)))); - assertEquals(3406506912, x >>>= ((x|(tmp = 2436016535, tmp))*(((tmp = -1222337225, tmp)<<((1765930268)&x))*(tmp = 1600702938, tmp)))); - assertEquals(1.694694170868292, x %= (x/(-1597121830.794548))); - assertEquals(0, x >>= (tmp = -2443203089, tmp)); - assertEquals(0, x >>>= (1323174858.2229874)); - assertEquals(0, x &= ((tmp = 846556929.2764134, tmp)|(((1483000635.0020065)|(-3151225553))|(tmp = -229028309, tmp)))); - assertEquals(0, x >>= x); - assertEquals(0, x >>= ((((((-2677334787)>>>x)>>((tmp = 496077992, tmp)&((((x<<(x*(tmp = 1095163344.2352686, tmp)))+(-952017952))%((x<<((x*x)/(tmp = 2983152477, tmp)))^((tmp = -939521852.1514642, tmp)^(tmp = 143967625.83755958, tmp))))*((tmp = 551827709.8366535, tmp)>>>x))))^((-1552681253.69869)-(-1874069995)))>>>(x>>(x%(tmp = -2554673215, tmp))))|(tmp = -190693051.77664518, tmp))); - assertEquals(0, x /= (tmp = 427402761.37668264, tmp)); - assertEquals(0, x <<= x); - assertEquals(0, x |= (x>>>(((((-543326164.0673618)>>>(-2344090136.707964))>>>((((-563350246.6026886)/x)/(1525481037.3332934))&(tmp = -2917983401.88958, tmp)))^(-1094667845.1208413))^x))); - assertEquals(0, x &= (1080322749.897747)); - assertEquals(0, x %= (tmp = -1572157280, tmp)); - assertEquals(0, x >>>= x); - assertEquals(0, x %= ((377280936)|x)); - assertEquals(708335912, x -= (tmp = -708335912, tmp)); - assertEquals(2766937, x >>>= x); - assertEquals(547342779, x += (tmp = 544575842, tmp)); - assertEquals(546273751, x -= ((x>>>(472833385.9560914))|((tmp = -1164832103.9970903, tmp)/(3147856452.1699758)))); - assertEquals(546273751, x &= x); - assertEquals(0, x ^= x); - assertEquals(0, x >>>= (tmp = -3181805175, tmp)); - assertEquals(-375546685, x |= (-375546685.08261824)); - assertEquals(1089992785780217200, x *= (tmp = -2902416209, tmp)); - assertEquals(0, x %= x); - assertEquals(-1854981526, x -= ((x-x)-(-1854981526))); - assertEquals(-3709963052, x += x); - assertEquals(-316772482, x %= (tmp = -1696595285, tmp)); - assertEquals(-316772482, x |= x); - assertEquals(1, x /= x); - assertEquals(0, x -= x); - assertEquals(-1418375842, x ^= (-1418375842)); - assertEquals(-2, x >>= x); - assertEquals(-4, x += x); - assertEquals(-8388608, x &= (x<<(-350555339.30086184))); - assertEquals(-16777216, x += x); - assertEquals(-0, x %= x); - assertEquals(1083355129, x += (tmp = 1083355129, tmp)); - assertEquals(0, x &= (((tmp = 389729053, tmp)-(tmp = 2944192190.0939536, tmp))/(x-(2081712461.2657034)))); - assertEquals(0, x += x); - assertEquals(-3, x += ((3147270119.5831738)>>((2455837253.1801558)%((-2100649096)>>(((290236808.01408327)|(x&((2661741230.3235292)|((tmp = 1686874589.4690177, tmp)<<x))))*(x+(tmp = 2327674670, tmp))))))); - assertEquals(-3, x %= ((x>>(((-2962686431)%x)>>((((2438370783)-(tmp = 2667305770.4839745, tmp))>>>x)>>>x)))<<((x&(tmp = 1428498616, tmp))|((tmp = 2621728539.102742, tmp)/(-204559901))))); - assertEquals(2, x ^= (x|((((tmp = 1751230118.6865973, tmp)/(-867465831.207304))>>((-808143600.0912395)+(-2882191493.0506454)))^x))); - assertEquals(2, x %= (-2015954220.2250996)); - assertEquals(0, x >>>= (tmp = 401373999, tmp)); - assertEquals(0, x >>= (2371830723)); - assertEquals(0, x >>>= ((((tmp = 2765919396, tmp)-x)-(530310269.7131671))|(tmp = -615761207.9006102, tmp))); - assertEquals(-145389011, x ^= (tmp = -145389011, tmp)); - assertEquals(-145389011, x |= x); - assertEquals(1632929832, x &= (-2518898392)); - assertEquals(4190540017.751949, x += (tmp = 2557610185.751949, tmp)); - assertEquals(4980024282.153588, x += ((1841304364.1177452)%(tmp = 1051820099.7161053, tmp))); - assertEquals(0, x >>>= (((((1379314342.4233718)>>((-2782805860)^((x%(tmp = 1328845288, tmp))>>>(tmp = 901403219.858733, tmp))))+(x/((tmp = -3078904299, tmp)/x)))/x)|(x|(1399702815)))); - assertEquals(-1820494882, x ^= (tmp = -1820494882.407127, tmp)); - assertEquals(-305870376, x %= (tmp = -757312253, tmp)); - assertEquals(-577530443, x += (x|(tmp = -1958083619.6653333, tmp))); - assertEquals(333541412591776260, x *= x); - assertEquals(-949341696, x >>= ((((1550069663)<<((x>>>(tmp = 2406565178.902887, tmp))>>>((1844746612.632984)/((tmp = 2233757197, tmp)*((-1524891464.1028347)>>(tmp = 2498623474.5616803, tmp))))))&x)<<(x&(tmp = -370379833.3884752, tmp)))); - assertEquals(-277202090, x |= ((-762200848.8405354)-(tmp = 1749136282, tmp))); - assertEquals(0.13704539927239265, x /= (tmp = -2022702633.373563, tmp)); - assertEquals(0, x -= x); - assertEquals(0, x %= ((132951580.19304836)-((427623236.27544415)-(1212242858)))); - assertEquals(0, x &= ((449148576)&(-1609588210.249217))); - assertEquals(0, x >>= x); - assertEquals(0, x -= x); - assertEquals(-0, x /= (tmp = -1640777090.9694843, tmp)); - assertEquals(0, x &= (((tmp = -1923412153, tmp)>>>((x>>(tmp = 3027958119.0651507, tmp))+(60243350)))>>(tmp = -2610106062, tmp))); - assertEquals(0, x ^= (((-186998676)/(tmp = 2697937056, tmp))-x)); - assertEquals(-1147950080, x |= ((2425449461)*(tmp = -2525854833, tmp))); - assertEquals(457688198, x ^= (2698274950.660941)); - assertEquals(8724, x %= ((1174351031)>>>((371599047.36048746)+(3025292010)))); - assertEquals(0, x <<= (tmp = -710011617, tmp)); - assertEquals(0, x >>>= (1693410026)); - assertEquals(1443005362, x ^= ((tmp = -2851961934, tmp)+((((x%x)-(tmp = 547622400, tmp))<<(((tmp = 722396486.5553623, tmp)|x)>>>((((tmp = -542268973.5080287, tmp)<<(tmp = 1347854903.771954, tmp))>>>(tmp = -889664427.7115686, tmp))&((tmp = 1549560114, tmp)*(tmp = 964918035, tmp)))))&(-2422502602.920377)))); - assertEquals(3986573462, x -= (-2543568100)); - assertEquals(7973146924, x += x); - assertEquals(-1, x >>= (-75987297)); - assertEquals(-12, x += ((2940824338.64834)>>(tmp = 3061467355, tmp))); - assertEquals(-3.8229398525977614e-8, x /= (313894554)); - assertEquals(-2.890709270374084e-17, x /= (tmp = 1322491989, tmp)); - assertEquals(0, x |= (x-x)); - assertEquals(0, x >>>= (tmp = -1205300664, tmp)); - assertEquals(-0, x /= (((2869505187.6914144)>>(tmp = 1541407065, tmp))/(((-571132581)>>>(x>>x))/((x^(170373762.8793683))>>>((((tmp = -363073421.05897164, tmp)|(((tmp = -1591421637, tmp)>>(1095719702.8838692))&(636687681.9145031)))^x)^(x|x)))))); - assertEquals(-1487828433, x ^= (-1487828433.3462324)); - assertEquals(-0, x %= x); - assertEquals(1716342498, x -= ((tmp = 2578624798, tmp)^x)); - assertEquals(1636, x >>= ((264194540)>>>(-801900756))); - assertEquals(0, x >>>= ((tmp = 2502688876, tmp)+((x<<(x|((-628272226.0338528)|((x<<(-2083074091))>>>(tmp = 1692123246.8418589, tmp)))))>>(1594759826.990993)))); - assertEquals(0, x <<= (tmp = -904399643, tmp)); - assertEquals(NaN, x /= ((x^(x-x))%((tmp = 1744962024.4882128, tmp)%x))); - assertEquals(NaN, x /= (-1013142883.1845908)); - assertEquals(NaN, x /= ((tmp = 793633198, tmp)^(-2993598490.8659954))); - assertEquals(0, x &= (x>>((tmp = 1200937851, tmp)<<(((tmp = -2807378465, tmp)&(tmp = -143778237, tmp))|(tmp = -1200772223, tmp))))); - assertEquals(0, x <<= x); - assertEquals(88144, x |= (((((tmp = 3002723937.8560686, tmp)*(tmp = -3171720774.2612267, tmp))%(((tmp = -2586705978.7271833, tmp)%((x+(-1553704278))&(2405085526.501994)))>>((-240842053)>>>(((((tmp = -1886367228.4794896, tmp)>>>x)^(tmp = 2604098316, tmp))^(tmp = 1362808529, tmp))<<((tmp = -1062263918, tmp)|((-172718753)%(tmp = -1910172365.4882073, tmp)))))))^((1444153362)>>((x&((-1205465523.2604182)^(tmp = -2062463383, tmp)))>>(tmp = 956712476, tmp))))>>((((-1004215312)^((((-1707378612.5424936)^(tmp = 2372161553, tmp))/((tmp = 1802586581, tmp)*((2082257.1896460056)&((tmp = -1270773477, tmp)^(tmp = 942517360.3447798, tmp)))))+x))%((((666494127)^(x^x))>>>(tmp = -2592829775, tmp))+((-1601528223)+((x+(tmp = -2417034771.7409983, tmp))>>>((tmp = -730673817, tmp)*x)))))>>x))); - assertEquals(-2603179111.7557006, x -= ((2603267255.755627)+(x/(1200979191.2823262)))); - assertEquals(1691788185, x >>= (tmp = 3088840032, tmp)); - assertEquals(-168382533, x |= (tmp = -780750941.4590135, tmp)); - assertEquals(-168382533, x >>= (60741120.48285198)); - assertEquals(-134287365, x |= (x*(tmp = 834637940.7151251, tmp))); - assertEquals(-1481917089, x -= (tmp = 1347629724, tmp)); - assertEquals(1, x >>>= x); - assertEquals(262144, x <<= (2680216914)); - assertEquals(1075132032, x ^= (x-((tmp = 3220359552.3398685, tmp)^(((-434474746.6039338)|((((((((tmp = 1945689314.9683735, tmp)>>(1300022273))>>>(333705550))&x)%(588357521))-(x+(x^(((tmp = -134560382, tmp)+x)-((((994246147.7195556)-(-1506599689.7383268))%(x<<x))>>((1256426985.5269494)+(tmp = 1860295952.8232574, tmp)))))))^(((tmp = 917333220.2226384, tmp)>>x)>>>(tmp = 865898066, tmp)))%((x|(x%((tmp = -2660580370, tmp)&(tmp = 2966426022, tmp))))*x)))/(((tmp = 682585452, tmp)&(-3219368609))+((tmp = -1330253964, tmp)+((x&(2857161427))/x))))))); - assertEquals(274944, x &= ((2606953028.1319966)-(-1707165702))); - assertEquals(266752, x &= ((x<<((x+(x+(x^(-1570175484))))^x))^(x+(x<<(tmp = 90330700.84649956, tmp))))); - assertEquals(266752, x &= ((((x*(tmp = 2033225408, tmp))-(x-((tmp = 1507658653, tmp)/(-3016036094))))>>>((1497480588)>>(2784070758)))|(tmp = -3025904401.93921, tmp))); - assertEquals(-1680442631, x |= ((x/(445284843))|((tmp = 2614520057.2723284, tmp)<<x))); - assertEquals(40851947, x >>>= (tmp = -1577031386.938616, tmp)); - assertEquals(2493, x >>= ((3044630989.3662357)-(-2670572992.8580284))); - assertEquals(-0.0000017317105653562252, x /= (-1439617017.9207587)); - assertEquals(0, x &= (2359806567)); - assertEquals(623768541, x ^= (623768541)); - assertEquals(1028567149.0716183, x += (((tmp = 1307794561, tmp)%(x>>x))-(-404798608.0716183))); - assertEquals(-1.2971762489811298, x /= (tmp = -792927830.6471529, tmp)); - assertEquals(-1.2971762489811298, x %= ((-2426421701.2490773)/(-689566815.3393874))); - assertEquals(-2147483648, x <<= x); - assertEquals(-2147483648, x &= (tmp = -869991477, tmp)); - assertEquals(-268435456, x >>= (1383186659)); - assertEquals(0, x -= x); - assertEquals(-2009742037, x |= (-2009742037.5389993)); - assertEquals(-1386630820, x ^= (627864695)); - assertEquals(-1033479103975173600, x *= (tmp = 745316697.9046186, tmp)); - assertEquals(-1628048487, x |= (2662654361)); - assertEquals(325551, x >>>= (340874477)); - assertEquals(-1235730537, x ^= (tmp = 3059533880.0725217, tmp)); - assertEquals(-1235730537, x %= (2247137328)); - assertEquals(-220200960, x <<= ((x>>x)-x)); - assertEquals(0, x <<= ((tmp = 337220439.90653336, tmp)|(tmp = 2901619168.375105, tmp))); - assertEquals(0, x >>>= ((-2114406183)/x)); - assertEquals(0, x %= ((1425828626.3896675)/x)); - assertEquals(0, x >>>= ((3213757494)>>>(2595550834.3436537))); - assertEquals(0, x <<= x); - assertEquals(-0, x /= ((1544519069.5634403)/((tmp = -1332146306, tmp)&(-762835430.0022461)))); - assertEquals(0, x ^= x); - assertEquals(0, x >>= (x|((((x*((-786272700)+x))<<x)+((tmp = -1868484904, tmp)-(tmp = -1692200376, tmp)))+(-1010450257.6674457)))); - assertEquals(0, x -= x); - assertEquals(0, x ^= (x>>>(706010741))); - assertEquals(-964928697, x |= (-964928697)); - assertEquals(1, x /= x); - assertEquals(0, x >>= ((((tmp = 1778003555.3780043, tmp)>>(x%((tmp = -766158535, tmp)^((-2681449292.8257303)%((x-(x|(tmp = 1966478387.2443752, tmp)))^(((tmp = -1848398085, tmp)&x)>>>(tmp = -2860470842, tmp)))))))%(tmp = 2315077030, tmp))^x)); - assertEquals(0, x ^= x); - assertEquals(-288007757, x ^= ((tmp = 183607156.1803962, tmp)-(tmp = 471614914, tmp))); - assertEquals(-270573581, x |= (tmp = -849475741.9424644, tmp)); - assertEquals(-2129929, x |= (((((1942852445)&(tmp = 1280372312, tmp))*(x*(tmp = -1601900291, tmp)))^((509080002.81080174)-(tmp = 2699498226.9164257, tmp)))>>(((-335361221)>>(tmp = 843134832, tmp))%(-35532542)))); - assertEquals(-232622355, x ^= ((-3060885134.5375547)-(((tmp = 1965966723, tmp)-((tmp = 1248630129.6970558, tmp)<<(tmp = 1859637857.5027392, tmp)))*x))); - assertEquals(-52149658093200070, x *= (224181627.31264615)); - assertEquals(-697122968, x ^= (x-(x+(tmp = 2747211186.407712, tmp)))); - assertEquals(-2146269688, x &= ((tmp = -1466710519, tmp)^(x/(1419998975)))); - assertEquals(-536567422, x >>= (((((tmp = -1760701688.999274, tmp)>>(-1821976334))/(((tmp = -1660849531, tmp)>>>x)-((x+((tmp = -2489545009.4327965, tmp)>>>((tmp = -267360771.39148235, tmp)^x)))*(((-1453528661)%x)>>>(((243967010.3118453)/((((((2977476024)>>>((-1630798246)<<x))&(591563895.2506002))*(((2668543723.9720144)>>>x)|(1600638279)))^x)>>(x<<(tmp = -152589389, tmp))))>>>(x|(2821305924.9225664)))))))+(618968002.8307843))%(tmp = -1005408074.368274, tmp))); - assertEquals(40962, x &= (114403906)); - assertEquals(19741977727890, x *= ((-2367133915.963945)>>>(-3119344126))); - assertEquals(1313341440, x <<= x); - assertEquals(626, x >>>= ((((-333992843)%(tmp = -2742280618.6046286, tmp))>>>x)|x)); - assertEquals(0, x <<= (2598188575)); - assertEquals(NaN, x %= x); - assertEquals(NaN, x %= x); - assertEquals(0, x ^= (x%((2507288229.3233204)&(tmp = -1714553169.9276752, tmp)))); - assertEquals(0, x /= ((633436914.3859445)>>>(tmp = 1579804050.6442273, tmp))); - assertEquals(0, x *= ((tmp = 1172218326, tmp)<<((tmp = -2491306095.8456626, tmp)*(((tmp = 1305371897.9753594, tmp)>>((x^(((3077992060)*x)<<(492815553.904796)))>>((652151523)|x)))%x)))); - assertEquals(0, x <<= x); - assertEquals(0, x %= (1118131711)); - assertEquals(0, x &= ((tmp = 2734673884, tmp)|(x-((tmp = 2694578672.8975897, tmp)*(((x>>(2350811280.974167))*(1052548515))&(x^(x*(tmp = -1336287059.0982835, tmp)))))))); - assertEquals(-2632782867.1256156, x += ((tmp = -2743992725.1256156, tmp)+(tmp = 111209858, tmp))); - assertEquals(-0, x %= x); - assertEquals(0, x >>>= (((tmp = -2050519887, tmp)^(106865302.74529803))>>(1642851915.2909596))); - assertEquals(-171964826, x |= (tmp = -171964826.6087358, tmp)); - assertEquals(-2.113405951193522, x /= (tmp = 81368572.80206144, tmp)); - assertEquals(3, x >>>= x); - assertEquals(0, x %= x); - assertEquals(-1717345907.837667, x += (-1717345907.837667)); - assertEquals(-100964883, x |= (tmp = -109574931.80629134, tmp)); - assertEquals(-33849857, x |= (-974111718.2433801)); - assertEquals(1, x >>>= (tmp = -2556222849.005595, tmp)); - assertEquals(1, x /= x); - assertEquals(0, x >>>= (-1796630999.4739401)); - assertEquals(0, x >>>= x); - assertEquals(2031695758, x += (((x/(((tmp = -2364918403, tmp)%(x^((tmp = 277767803.6375599, tmp)>>((((tmp = 540036080, tmp)/(x|(2665298931)))/(x|((x>>(-2035456216.6165116))<<(2143184420.5651584))))^x))))&(tmp = 927798419.8784283, tmp)))-(-2031695758))>>>x)); - assertEquals(2031695758, x |= x); - assertEquals(2031695758, x <<= (((x>>(x%x))|(tmp = -1164531232.7384055, tmp))*x)); - assertEquals(124004, x >>>= x); - assertEquals(529846352, x += ((529722348)%((2417645298.865121)|(x>>(x>>>(x+x)))))); - assertEquals(60067920, x &= (((tmp = -3166008541.8486233, tmp)-x)|(x%x))); - assertEquals(1415594240755200, x *= ((-2786707452.873729)>>(((tmp = -2369315809, tmp)*((1559868465)|(1011218835.1735028)))>>>x))); - assertEquals(1415595182259140, x += (941503939.9023957)); - assertEquals(0, x <<= ((tmp = 2887184784.265529, tmp)/(-2575891671.0881453))); - assertEquals(0, x &= ((tmp = -1546339583, tmp)>>>(tmp = -587433830, tmp))); - assertEquals(0, x *= (((tmp = 1356991166.5990682, tmp)%(tmp = -284401292, tmp))*(1869973719.9757812))); - assertEquals(NaN, x %= x); - assertEquals(0, x ^= (((tmp = 92575404.43720293, tmp)>>>(263475358.17717505))%x)); - assertEquals(0, x <<= (((561514358)*(tmp = -439584969, tmp))%((((-3005411368.7172136)+x)|(-2230472917))&x))); - assertEquals(0, x >>= ((x>>>x)-((x-(1630649280.510933))+x))); - assertEquals(0, x >>= (tmp = -1772403084.7012017, tmp)); - assertEquals(0, x *= x); - assertEquals(0, x += x); - assertEquals(0, x &= x); - assertEquals(0, x >>= (tmp = 1622680387, tmp)); - assertEquals(1033887633558225200, x -= ((-510616337)*(tmp = 2024783695, tmp))); - assertEquals(-2.8073538539158063e+27, x *= (tmp = -2715337492, tmp)); - assertEquals(-2.8073538539158063e+27, x -= ((tmp = -1664804757, tmp)&((tmp = -226616419, tmp)>>>(1006711498)))); - assertEquals(1894539615, x |= (tmp = -2400427681.1831083, tmp)); - assertEquals(7400545, x >>= (774629608.4463601)); - assertEquals(456756268, x += (449355723)); - assertEquals(285771784, x &= (-1316427366)); - assertEquals(17, x >>= ((tmp = -220509931.20787525, tmp)*(((tmp = 2518859292, tmp)+(-1477543005.1586645))>>(tmp = 3172820250.687789, tmp)))); - assertEquals(85924262443, x *= (x*((tmp = -2856669745.965829, tmp)&(((tmp = 401420695, tmp)^(tmp = 2355371132, tmp))|(tmp = 590645330.021911, tmp))))); - assertEquals(1703875715, x ^= ((-2576394029.7843904)-x)); - assertEquals(1703875715, x %= (tmp = 2234144310, tmp)); - assertEquals(271405807, x ^= (1973569132)); - assertEquals(1060178, x >>>= (tmp = -84823096, tmp)); - assertEquals(8, x >>>= (tmp = 2246120561.905554, tmp)); - assertEquals(-2846791089, x += (-2846791097)); - assertEquals(104933962, x &= (x-(-2969030955.99584))); - assertEquals(489215611.96215343, x -= (-384281649.96215343)); - assertEquals(489215611, x |= x); - assertEquals(1186191360, x <<= ((tmp = 774407142.993727, tmp)%x)); - assertEquals(1186191360, x %= (1555004022)); - assertEquals(-1697134080, x ^= (tmp = -597421568, tmp)); - assertEquals(-1102053376, x <<= ((-927370769.4059179)^((tmp = 1093490918, tmp)>>(((-2522227493.3821955)%x)+(-2657319903))))); - assertEquals(1086450058, x ^= (-23991926.187098265)); - assertEquals(1086450058, x |= x); - assertEquals(-1.6554590588410778, x /= (x|(x<<(x+x)))); - assertEquals(67108863, x >>>= ((-926530233)+x)); - assertEquals(494553310, x ^= (tmp = 512079649, tmp)); - assertEquals(207751168, x &= (2892146720.6261826)); - assertEquals(207751168, x &= x); - assertEquals(207751168, x |= x); - assertEquals(6340, x >>>= (((((x<<(x-((-2819638321)*((x<<x)+x))))>>x)+(tmp = 2016170261, tmp))+(tmp = 2755496043.772017, tmp))+(-841368625.1402085))); - assertEquals(6340, x ^= ((x/(tmp = -192734784, tmp))>>>(((-140306239)&x)-x))); - assertEquals(1, x /= x); - assertEquals(0, x >>= x); - assertEquals(26786600, x ^= (tmp = 26786600, tmp)); - assertEquals(-0.014657576899542954, x /= ((-1454855938.0338)+(-372635753.3681567))); - assertEquals(0, x &= ((tmp = 2480635933, tmp)&(-2986584704.9165974))); - assertEquals(-2108639122, x += ((tmp = 2108639123.8683565, tmp)^((-881296055)/(((x<<(2026200582))|(tmp = -862495245.138771, tmp))-(-1111596494.892467))))); - assertEquals(1893466112, x <<= (tmp = 607974481, tmp)); - assertEquals(1893466112, x |= x); - assertEquals(1133122783.997418, x += ((tmp = -760343332, tmp)-((x-(tmp = -878561823.4218843, tmp))/(tmp = -693454632.596637, tmp)))); - assertEquals(8, x >>>= (tmp = 700339003.3919828, tmp)); - assertEquals(4.605305035175536e-9, x /= (1737127060.8343256)); - assertEquals(4.605305035175536e-9, x -= ((x%(897221779))>>>x)); - assertEquals(-1864423625.5704088, x += (tmp = -1864423625.5704088, tmp)); - assertEquals(1132240092, x <<= (1304417186.1193643)); - assertEquals(-2088985380, x ^= (x<<x)); - assertEquals(-4, x >>= ((tmp = 1959823884.0935726, tmp)%(-1679792398.569136))); - assertEquals(-268435456, x <<= ((tmp = 2586838136, tmp)|((tmp = -481716750.718518, tmp)>>>((1485826674.882607)/(tmp = -2826294011, tmp))))); - assertEquals(-32768, x >>= (2060648973)); - assertEquals(1, x /= x); - assertEquals(-2838976297, x -= (tmp = 2838976298, tmp)); - assertEquals(-1382985298, x <<= ((tmp = -2104305023, tmp)&x)); - assertEquals(10, x >>>= (x+x)); - assertEquals(10, x -= (x>>>(361588901.70779836))); - assertEquals(854603510, x -= (-854603500)); - assertEquals(-557842432, x <<= (tmp = 1212985813.6094751, tmp)); - assertEquals(-459390188241943040, x *= (tmp = 823512450.6304014, tmp)); - assertEquals(-232800033621957060, x /= ((((((686635689)/(tmp = 2013252543, tmp))*(tmp = -1591617746.8678951, tmp))|(((tmp = -1777454093.5611362, tmp)>>>((tmp = 2680809394, tmp)^(((x>>((((((tmp = -265022244, tmp)%((tmp = -3075004537, tmp)>>(((((1427784269.5686688)^((tmp = -1095171528.911587, tmp)^(-942424985.7979553)))>>(-1279441481.1987405))*((2493620394)>>(-2769016043)))/(x&((tmp = 2059033657, tmp)%(((tmp = 1948606940.1488457, tmp)-(tmp = -2645984114.13219, tmp))^x))))))^x)^x)%(x%((((tmp = 3209433446.4551353, tmp)%(tmp = 1364430104.0424738, tmp))/(tmp = -2103044578.349498, tmp))+(tmp = -2613222750, tmp))))*(2099218034)))&(((tmp = -378500985.49700975, tmp)>>(((x+x)|(x%(((-1841907486)<<(-1220613546.194021))<<(tmp = -1260884176, tmp))))^(tmp = 1858784116, tmp)))>>>((x%x)%((x>>>(tmp = -2540799113.7667685, tmp))|x))))/((((tmp = 642072894.6455215, tmp)-(-324951103.6679399))*(tmp = 1424524615, tmp))+((x<<(tmp = -904578863.5945344, tmp))*(tmp = 49233475.435349464, tmp))))))<<(tmp = 1680210257, tmp)))+((tmp = -1516431503, tmp)>>>(-1105406695.3068116)))/(-275019361.6764543))); - assertEquals(192359387.42913792, x /= (-1210234846)); - assertEquals(192359387.42913792, x %= (-2920206625.0154076)); - assertEquals(192359387.42913803, x -= (((((((tmp = -1263203016.3258834, tmp)-(2432034005.6011124))&x)<<(1479434294))>>((tmp = -1695856315.523002, tmp)>>>(tmp = 557391345, tmp)))/(tmp = -1280240246.2501266, tmp))%((tmp = -2196489823.034029, tmp)>>(((x&((912221637.1101809)+((tmp = -3003677979.652423, tmp)>>(tmp = -716129460.1668484, tmp))))-((x+(x-(-2780610859)))>>>(-2445608016)))<<((x*(x+(x+(((-2124412727.9007604)%(tmp = -593539041.5539455, tmp))&(tmp = 2404054468.768749, tmp)))))%(x>>(tmp = -2913066344.404591, tmp))))))); - assertEquals(11740, x >>= (688848398.7228824)); - assertEquals(11740, x >>= ((1545765912)*(307650529.9764147))); - assertEquals(23480, x += x); - assertEquals(0, x >>>= ((tmp = 1313078391, tmp)|x)); - assertEquals(1726251264, x -= ((1939413887)<<(1004888744.2840619))); - assertEquals(765324793.5278986, x %= (960926470.4721014)); - assertEquals(747387, x >>= ((2483010044)-(tmp = -413698190, tmp))); - assertEquals(1, x /= x); - assertEquals(3016811624, x *= (3016811624)); - assertEquals(17408, x &= (((tmp = -991624868, tmp)<<(((63107932)/(tmp = 2659939199, tmp))|(tmp = -1968768911.3575773, tmp)))>>(((-2876822038.9910746)|(tmp = 2550230179.243425, tmp))<<((x*(x<<((x<<((tmp = -1627718523.616604, tmp)|((2154120561.254636)-(x%(x<<(1484563622.1791654))))))<<((((x^(tmp = 3016524169, tmp))<<(((x+(tmp = 1887816698.2455955, tmp))+x)-x))-(-3023329069))-x))))+x)))); - assertEquals(0, x <<= (((1247441062.177967)/(-1717276234))+x)); - assertEquals(0, x |= ((x%((-1648299429.4520087)>>(-137511052)))>>(tmp = 221301016.4926411, tmp))); - assertEquals(0, x /= ((-2598501544.913707)>>>(-2177037696))); - assertEquals(NaN, x %= (x>>x)); - assertEquals(0, x &= (tmp = 1852419158, tmp)); - assertEquals(-829029120, x |= (((2122339180)*((((((tmp = 768748914, tmp)<<((1008490427)&((1937367899.957056)-(((635094486)>>(((tmp = -795046025, tmp)*(2665104134.4455256))^(tmp = 706594584.2462804, tmp)))/(504397522)))))/(-556057788))>>((x/(tmp = -2732280594, tmp))-x))+(-1989667473))+(tmp = 2766802447.789895, tmp)))<<(((tmp = -2969169096, tmp)-x)+(tmp = 2093593159.0942125, tmp)))); - assertEquals(0.6451933462602606, x /= ((-1284931292)<<(x<<(tmp = 1294716764, tmp)))); - assertEquals(1515416866.520901, x *= (2348779440)); - assertEquals(-1620606242886682600, x *= ((-993898625.5357854)&(((tmp = -571100481, tmp)/x)*((2428590177.311031)%(tmp = -2671379453, tmp))))); - assertEquals(-1137472828, x %= (tmp = -1195183004, tmp)); - assertEquals(-3096634005473250000, x *= (tmp = 2722380640, tmp)); - assertEquals(-3096634003996758500, x -= (-1476491033.833419)); - assertEquals(-3096634000805538000, x += (3191220521.978341)); - assertEquals(-3096634000805468000, x += ((((tmp = -3024976741, tmp)&(952616360))|((x*(-1547952311))+(x*x)))>>>(tmp = 981373323, tmp))); - assertEquals(-3096633998655594000, x += (2149873927)); - assertEquals(-118812224101.54297, x %= (((2641881276.9898443)*(((502159480)^x)<<x))%((tmp = -2840045365.547772, tmp)*(((((-2297661528)>>>(x>>(-229103883.94961858)))&(((-1285047374.6746495)<<((-360045084)>>>((x-(tmp = -956123411.1260898, tmp))%x)))>>((tmp = -2375660287.5213504, tmp)+((((tmp = -2753478891, tmp)>>>(((tmp = 101438098, tmp)>>(((tmp = -2736502951, tmp)<<((tmp = -3084561882.368902, tmp)&(tmp = 1491700884, tmp)))|x))&(tmp = 1627412882.6404104, tmp)))>>>(tmp = 1039002116.6784904, tmp))<<((tmp = -2840130800, tmp)-(tmp = -740035567, tmp))))))&(tmp = -416316142, tmp))>>x)))); - assertEquals(86, x >>>= (tmp = -293489896.5572462, tmp)); - assertEquals(172, x += (x%((((-2635082487.364155)|((-2361650420.634912)&(-2147095650.7451198)))<<((tmp = 2258905145.9231243, tmp)%((((tmp = -1365987098.5130103, tmp)*(((((((932437391)/x)/(289270413.0780891))%(x-x))+((((2194986374.917528)>>(((((tmp = -1553805025, tmp)|x)^(((x>>(-564400586.0780811))^(tmp = 1738428582.0238137, tmp))>>(tmp = 1717774140, tmp)))&(tmp = -2789427438, tmp))%(((tmp = -1386118057, tmp)*(-2333221237.7915535))*(x>>>(((((41346648.46438944)&x)%(-478973697.6792319))|(tmp = 2108106738, tmp))/x)))))-(tmp = -133437701.64136505, tmp))>>>x))+(tmp = -1567210003, tmp))*(x+((x&x)-(2942851671)))))>>>(tmp = -446377136, tmp))*((((((tmp = 1597203255, tmp)>>>(619157171))|(-2766246629.005985))>>((tmp = 3130227370, tmp)%x))*(tmp = 2072227901.6101904, tmp))|((tmp = 1369019520, tmp)^(759659487))))))>>>x))); - assertEquals(1996475731, x ^= ((1456327892.2281098)|(1728022827))); - assertEquals(0, x %= x); - assertEquals(0, x &= (1323847974)); - assertEquals(3076829073.8848357, x += (3076829073.8848357)); - assertEquals(9569842648396755000, x *= (3110293883.2782717)); - assertEquals(9569842646260304000, x -= (2136450372.9038036)); - assertEquals(9.158188827418242e+37, x *= x); - assertEquals(0, x <<= ((x&(tmp = -2241179286, tmp))+((tmp = 2553144081, tmp)&((tmp = -1914709694, tmp)^(tmp = -1469651409.0651562, tmp))))); - assertEquals(0, x <<= x); - assertEquals(0, x /= (2177840666.276347)); - assertEquals(0, x %= (-690827104)); - assertEquals(0, x >>>= x); - assertEquals(0, x ^= x); - assertEquals(-0, x /= (tmp = -803415280, tmp)); - assertEquals(-2355576914.316743, x += (-2355576914.316743)); - assertEquals(-833671722514674000, x *= ((3053388806.692315)-(tmp = 2699474775.081724, tmp))); - assertEquals(1, x /= x); - assertEquals(1898147684, x += ((tmp = 1898147683, tmp)|(x<<x))); - assertEquals(2.192324660388075, x %= ((tmp = 2630187518, tmp)/((2868794982.790862)|(490860748)))); - assertEquals(0, x >>>= ((2751021779)/(-952522559))); - assertEquals(321040461, x ^= ((321040461.153594)-x)); - assertEquals(-2.3814602031636922, x /= ((tmp = -170472190, tmp)|x)); - assertEquals(-1, x >>= (2200125174.177402)); - assertEquals(-2964432647.9379396, x += (-2964432646.9379396)); - assertEquals(-370116502.93793964, x %= (tmp = -518863229, tmp)); - assertEquals(777927355.2283959, x -= (-1148043858.1663356)); - assertEquals(0, x *= ((tmp = 1134913539, tmp)&(((x>>>((tmp = -989822787, tmp)>>>x))%x)&(tmp = 1078636160.7313156, tmp)))); - assertEquals(-1089245637, x ^= (3205721659.3548856)); - assertEquals(-1192493056, x <<= (-1173291054)); - assertEquals(78013832, x += ((tmp = 2462999944, tmp)+x)); - assertEquals(0, x %= x); - assertEquals(0, x >>>= (1794908927.7409873)); - assertEquals(1708338504, x += ((-2586628792.3484306)<<x)); - assertEquals(12, x >>= (-545794789.3827574)); - assertEquals(0, x &= ((2753207225)<<(((-1776581207.557251)+((tmp = -2414140402, tmp)*x))+(x<<(x|(tmp = 772358560.3022032, tmp)))))); - assertEquals(0, x <<= ((tmp = -2755724712.152605, tmp)/((x>>(-732875466))&x))); - assertEquals(NaN, x *= (((tmp = 2617815318.1134562, tmp)/x)%(x|((((((-851659337.194871)<<(tmp = 2072294700, tmp))%((x+(2193880878.5566335))^((tmp = 3005338026, tmp)-(2947963290))))/x)/(x+(2091745239.4210382)))-(x>>x))))); - assertEquals(NaN, x /= (tmp = -427684595.0278094, tmp)); - assertEquals(NaN, x /= (tmp = -263945678, tmp)); - assertEquals(0, x <<= x); - assertEquals(0, x <<= x); - assertEquals(0, x -= (((x>>((x&x)-(tmp = -673697315, tmp)))>>(((1575095242.2330558)/(x-(-1816886266)))%(-1580195729)))>>>x)); - assertEquals(0, x >>>= x); - assertEquals(0, x >>= (-2815518206)); - assertEquals(0, x -= (x/(1795634670.692437))); - assertEquals(-2753579891, x += (tmp = -2753579891, tmp)); - assertEquals(2.7773776150171776, x /= (tmp = -991431585, tmp)); - assertEquals(5.554755230034355, x += x); - assertEquals(3.362161997528237e-9, x /= (1652137890.4758453)); - assertEquals(3.362161997528237e-9, x %= (tmp = -10848734.527020693, tmp)); - assertEquals(1, x /= x); - assertEquals(-2978012493, x -= (x+(2978012493))); - assertEquals(-5.158905851797543, x /= (((x+((tmp = -2548840164, tmp)>>x))<<(x^((tmp = -533281232.7294345, tmp)&x)))&(tmp = -1502692171, tmp))); - assertEquals(-5.158905851797543, x %= (-3009435255.5612025)); - assertEquals(-20971520, x <<= ((tmp = -2728812464, tmp)%(2619809573.672677))); - assertEquals(-1900019712, x &= (2398099552)); - assertEquals(-1991377, x %= ((tmp = 1562364373.7334614, tmp)>>>(((x-(-946283217))<<(-2044590694))^(((tmp = 1681238509, tmp)>>(-2801649769))-x)))); - assertEquals(1, x /= x); - assertEquals(1, x %= (x/(x-x))); - assertEquals(1.3525631913093335e-9, x /= (739336991)); - assertEquals(0, x &= ((x&(x|(-1530424204)))<<((((tmp = -295143065.9115021, tmp)>>x)+x)<<x))); - assertEquals(0, x <<= (-1311017801)); - assertEquals(-0, x /= (-667133339.1918633)); - assertEquals(1038307283, x += (1038307283)); - assertEquals(506985, x >>>= ((tmp = 1550624472.9157984, tmp)^x)); - assertEquals(506985, x >>>= ((254646626)<<(tmp = 1572845412.744642, tmp))); - assertEquals(32447040, x <<= (tmp = -2427326042, tmp)); - assertEquals(0, x -= (x<<((x|x)>>>x))); - assertEquals(0, x &= x); - assertEquals(0, x &= ((-484420357)|((tmp = 807540590.6132902, tmp)/(x/x)))); - assertEquals(-890607324, x ^= ((tmp = -890607324, tmp)>>((((-2876826295)>>x)<<((tmp = 2351495148.117994, tmp)>>(tmp = 1368611893.274765, tmp)))*(tmp = 1531795251, tmp)))); - assertEquals(-729075363, x += (x+(tmp = 1052139285, tmp))); - assertEquals(531550884933581760, x *= x); - assertEquals(1980836332, x ^= ((-746269795.2320724)-((2400458512)>>((1290672548)>>>((((1536843439.5629003)&(3185059975.158061))*(tmp = -1339249276.2667086, tmp))&x))))); - assertEquals(941373096, x %= ((x+(-451098412))^(tmp = 1725497732, tmp))); - assertEquals(-1766019323, x += (tmp = -2707392419, tmp)); - assertEquals(2528947973, x >>>= (x^(-896237435.3809054))); - assertEquals(-263192576, x <<= (-866361580)); - assertEquals(-2008, x >>= (-2608071791)); - assertEquals(-88, x %= (((-1076807218.4792447)&((tmp = 601044863, tmp)>>((tmp = 1228976729, tmp)+((((-2711426325)*x)|x)|(x%(-2700007330.3266068))))))&(tmp = 3147972836.778858, tmp))); - assertEquals(1762886843, x ^= (tmp = 2532080403, tmp)); - assertEquals(1762886843, x %= ((((((tmp = -2059247788, tmp)>>x)/x)+(x<<x))^x)>>>(-1969283040.3683646))); - assertEquals(4812334726.587896, x += (tmp = 3049447883.587897, tmp)); - assertEquals(1, x /= x); - assertEquals(1, x *= x); - assertEquals(-2150507334, x -= ((tmp = 1578221999, tmp)+(tmp = 572285336, tmp))); - assertEquals(-4546475858941548500, x *= ((tmp = -931533139.5546813, tmp)^(tmp = 3061503275, tmp))); - assertEquals(-269064192, x |= ((207217276.91936445)<<(tmp = -957353678.4997551, tmp))); - assertEquals(1, x /= x); - assertEquals(1, x <<= (((1463856021.8616743)%(x*(tmp = -2286419102, tmp)))/(-2852887593))); - assertEquals(2223868564.8383617, x *= (tmp = 2223868564.8383617, tmp)); - assertEquals(918797189.9033995, x -= ((1305071374.9349623)%(x+(2211992629)))); - assertEquals(-2212004787.4668465, x -= (tmp = 3130801977.370246, tmp)); - assertEquals(31783, x >>= (2951958960)); - assertEquals(31783, x ^= ((((tmp = -2441511566, tmp)&((tmp = 91427553.90168321, tmp)+((tmp = 3001737720.327718, tmp)%x)))>>>(-2263859841))>>>((2109161329)>>(tmp = -2816295136.7443414, tmp)))); - assertEquals(4068224, x <<= (x%((tmp = -682576250.4464607, tmp)*(x/(((x-x)>>>(x&((((x<<(x<<x))>>>((((2243036981.528562)/(((-1839328916.9411087)>>(-1907748022.162144))<<(x+x)))+((tmp = 2362574171, tmp)<<(tmp = 1987834539, tmp)))|(-444329240)))|(399451601.1717081))>>x)))&(968363335.6089249)))))); - assertEquals(0.0030991932898194294, x /= ((tmp = 1067316540.5529796, tmp)^(-2388640366))); - assertEquals(0, x >>= x); - assertEquals(0, x >>>= (tmp = -393433349.1636851, tmp)); - assertEquals(0, x *= (((x^(((1806955787.471396)<<x)^((517668047.55566347)>>>(x%(x<<(tmp = -276586733.4844558, tmp))))))%(1661242196.1472542))|x)); - assertEquals(0, x |= (x>>x)); - assertEquals(-155236210, x |= (tmp = -155236210.19366312, tmp)); - assertEquals(-606392, x >>= ((tmp = -1533446042.97781, tmp)^x)); - assertEquals(-1, x >>= (936126810)); - assertEquals(2325115611, x -= (-2325115612)); - assertEquals(0, x -= x); - assertEquals(0, x >>= (tmp = -354826623, tmp)); - assertEquals(-0, x *= (-1232528947.7321298)); - assertEquals(0, x |= x); - assertEquals(0, x <<= (((tmp = 187758893.4254812, tmp)&(x-(tmp = 648201576, tmp)))&(385106597))); - assertEquals(0, x >>= (tmp = 2554891961, tmp)); - assertEquals(-1311492611.2970417, x += (-1311492611.2970417)); - assertEquals(-688179220.3221785, x += (623313390.9748632)); - assertEquals(1416835528, x &= (tmp = 1953739224, tmp)); - assertEquals(-11.04719252755072, x /= (-128252995)); - assertEquals(-6.287413042114223e-9, x /= (tmp = 1757033052.1558928, tmp)); - assertEquals(-4231171, x |= (((((2022730885.7773404)*((-2495777565.221855)|(tmp = 274627292, tmp)))<<(-3072596920.4902725))>>>((-2215057529)+(-1134713759.4247034)))^((tmp = -1888181788, tmp)/(572025985.2748461)))); - assertEquals(-4194305, x |= ((tmp = 167328318.038759, tmp)>>>(153800904.34551537))); - assertEquals(-1316525687, x -= (1312331382)); - assertEquals(1448723245.7863903, x += (2765248932.7863903)); - assertEquals(1.7219707102205526, x /= (tmp = 841317008, tmp)); - assertEquals(1872027792.5217001, x *= (x|(tmp = 1087142645.6665378, tmp))); - assertEquals(3504488055973669400, x *= x); - assertEquals(-1075254784, x |= x); - assertEquals(-5, x >>= (((844461331.8957539)-((x&x)<<((tmp = 1443904777, tmp)+(tmp = 736164505.3670597, tmp))))-(((tmp = 1348422110, tmp)>>((tmp = -2878252514, tmp)/(-1175443113)))|((-2138724317)%(2057081133))))); - assertEquals(-3.038875804165675e-9, x /= (1645345292.8698258)); - assertEquals(1.25204541454491e-18, x /= (-2427129055.274914)); - assertEquals(-1.7151576137235622e-9, x *= (-1369884505.6247284)); - assertEquals(1590804618, x ^= (1590804618.4910607)); - assertEquals(5061318665300252000, x *= (x+x)); - assertEquals(5061318665300252000, x %= ((tmp = 1102144242, tmp)*x)); - assertEquals(-7, x >>= (2772167516.624264)); - assertEquals(16383, x >>>= (-2979259214.5855684)); - assertEquals(47108415435, x *= ((2944456517.839616)>>>(1041288554.5330646))); - assertEquals(61, x >>>= (x^(((-1305163705)<<((948566605)-x))-x))); - assertEquals(0, x %= x); - assertEquals(0, x ^= (((tmp = 1918861879.3521824, tmp)/((x%(tmp = 945292773.7188392, tmp))%(x|x)))>>x)); - assertEquals(-0, x *= ((((x|((2810775287)|(tmp = 1265530406, tmp)))^((tmp = 3198912504.175658, tmp)-(((tmp = 1422607729.281712, tmp)<<(tmp = 2969836271.8682737, tmp))&x)))<<((tmp = 844656612, tmp)*(((((tmp = -828311659, tmp)%(((-2083870654)>>>(x^(((((933133782)-(tmp = 1033670745, tmp))-(629026895.4391923))%((-605095673.8097742)*((((-227510375.38460112)*x)+x)&(((((tmp = 472873752.68609154, tmp)^(tmp = 2815407038.712165, tmp))+((x>>>((tmp = -1331030665.3510115, tmp)>>>(2281234581)))-(x>>>x)))&(tmp = -2160840573.325921, tmp))&x))))<<(tmp = 1411888595, tmp))))|(((tmp = -915703839.0444739, tmp)/((x+(418836101.8158506))%(-1112605325.4404268)))&((-3098311830.6721926)-x))))-((49446671.477988124)*(-2522433127)))+((tmp = 443068797, tmp)>>(tmp = 418030554.97275746, tmp)))*((tmp = 38931296.738208175, tmp)+(1842742215.3282685)))))-((tmp = 1325672181.205841, tmp)^(tmp = 669284428, tmp)))); - assertEquals(-0, x *= (tmp = 93843030, tmp)); - assertEquals(0, x ^= x); - assertEquals(0, x ^= x); - assertEquals(0, x <<= x); - assertEquals(0, x >>>= (x%((((((tmp = -107458601, tmp)>>(x*((x|((tmp = 2117286494, tmp)>>((x^(tmp = 114214295.42048478, tmp))>>>(tmp = 1032826615, tmp))))&((x*x)&(-225386977.67686415)))))^((-780566702.5911419)+(-1113319771)))|(((x^x)<<(1288064444))>>(-2292704291.619477)))>>(365125945))-((tmp = -1986270727.235776, tmp)/x)))); - assertEquals(-0, x *= (((-18925517.67125845)|((((-1975220517)+(tmp = -1250070128.296064, tmp))+(1085931410.5895243))<<(((x|(((x*(tmp = 160207581.50536323, tmp))|(tmp = 1798744469.7958293, tmp))-x))>>>(((x+((x%x)&((((x^x)<<((tmp = 2538012074.623554, tmp)^x))*x)&x)))/(x+(tmp = -2563837407, tmp)))/(tmp = 2189564730, tmp)))/(((-1703793330.5770798)<<((176432492)|x))<<(1347017755.345185)))))<<(((tmp = -577100582.7258489, tmp)&x)/(-31246973)))); - assertEquals(0, x >>>= x); - assertEquals(NaN, x %= ((x*(tmp = 1167625971, tmp))&(((tmp = -770445060, tmp)>>((339248786)^((2058689781.2387645)-((-2381162024)*(660448066)))))&x))); - assertEquals(NaN, x += ((3088519732.515986)-(-267270786.06493092))); - assertEquals(0, x &= (tmp = 2748768426.3393354, tmp)); - assertEquals(-1109969306, x ^= ((-1109969306)>>>x)); - assertEquals(-1109969306, x %= (tmp = 1150376563.581773, tmp)); - assertEquals(-2058145178, x &= (-2057586057)); - assertEquals(-850185626, x |= ((x^(tmp = 1223093422, tmp))&((-589909669)<<(2299786170)))); - assertEquals(1489215443, x += (2339401069)); - assertEquals(-23592960, x <<= x); - assertEquals(2063937322, x ^= (-2053296342.2317986)); - assertEquals(12922122, x %= (x^((-2259987830)>>(x*(((tmp = -799867804.7716949, tmp)&(tmp = -1068744142, tmp))*(((((1091932754.8596292)-((tmp = -1778727010, tmp)>>(((tmp = 1207737073.2689717, tmp)-(x-(tmp = -1191958946, tmp)))+(-631801383.7488799))))-(-618332177))>>>(-156558558))>>>(3032101547.6262517))))))); - assertEquals(12922122, x &= x); - assertEquals(Infinity, x /= (x%x)); - assertEquals(0, x &= (x*(-227800722.62070823))); - assertEquals(-865648691, x ^= (-865648691)); - assertEquals(1, x /= (x%(tmp = 1524739353.8907173, tmp))); - assertEquals(16, x <<= (x<<(2335214658.789205))); - assertEquals(0, x &= ((tmp = 570332368.1239192, tmp)^(-2278439501))); - assertEquals(1881145344, x -= (((-569715735.8853142)+(2093355159))<<(tmp = 2788920949, tmp))); - assertEquals(0, x ^= x); - assertEquals(NaN, x -= ((tmp = -1427789954, tmp)%((((((411038329.49866784)-x)-(x<<((-1330832247)+x)))/x)^((x*(845763550.2134092))>>(tmp = 1427987604.5938706, tmp)))>>>(1857667535)))); - assertEquals(NaN, x /= (-313793473)); - assertEquals(0, x >>>= (x/x)); - assertEquals(1869358566, x -= (-1869358566)); - assertEquals(-1901664519209545200, x += ((tmp = 944729941.3936644, tmp)*(-2012918653))); - assertEquals(-1901664519209545200, x += ((tmp = 1348246793, tmp)/(x&x))); - assertEquals(-1576791552, x &= (tmp = 2719250966.739456, tmp)); - assertEquals(-305087899, x ^= (-2955630491.030272)); - assertEquals(0, x ^= (x%(1575252839.559443))); - assertEquals(4184604407, x += ((((tmp = -244720076.17657042, tmp)|(2819320515))^((((tmp = 1222623743.9184055, tmp)*(-95662379.577173))/(x/(x+(((x-(tmp = -3024718107.6310973, tmp))^(-1494390781))&(tmp = 2284054218.8323536, tmp)))))>>>(tmp = 2090069761, tmp)))>>>(x%x))); - assertEquals(3148907440, x -= (((tmp = -332379100.7695112, tmp)-(-1145399547))^(((((((tmp = 3133792677.785844, tmp)+x)<<(2306999139.5799255))>>((tmp = -2051266106, tmp)*(((((x+(((-728654312.8954825)>>(x>>>(((x%x)&(-1587152364))|(((((-2114138294)&x)&(1547554688))^x)-(-1856094268)))))*(((-1135018784)&((x+(tmp = -1444020289, tmp))|x))+x)))>>x)&x)/(2449005489))<<((131073798.64314616)%(x>>>((-2592101383.2205048)^(tmp = -757096673.0381112, tmp)))))))^(2766467316.8307915))-(-2465892914.515834))-((((tmp = 234064056, tmp)^((x>>>(1622627548.7944543))+(-1750474146)))|(-1959662039.4687617))^((-1222880974)&(-2794536175.906498)))))); - assertEquals(-1157627488, x &= (-1156639323)); - assertEquals(-1342170624, x <<= ((x/((((1829945345.0613894)/(x*((tmp = 1278865203.0854595, tmp)/(((tmp = -2298274086.519347, tmp)+(tmp = -545203761, tmp))-(tmp = 2712195820, tmp)))))>>>((tmp = 240870798.9384452, tmp)-(tmp = -3188865300.4768195, tmp)))>>>(x%((648799266)>>>(tmp = 24460403.864815235, tmp)))))|((tmp = 232533924, tmp)|x))); - assertEquals(-2684341248, x += x); - assertEquals(1073755136, x &= (((-662718514.9245079)>>(tmp = -1915462105, tmp))+(tmp = 1478850441.8689613, tmp))); - assertEquals(-1073755136, x /= (x|((tmp = -1767915185, tmp)|((325827419.1430224)|(((-1343423676)|(tmp = -1929549501, tmp))|(-866933068.9585254)))))); - assertEquals(-1073755136, x %= ((tmp = 547342356, tmp)-((tmp = 2213249646.7047653, tmp)-((((((-2463314705)^(tmp = -993331620, tmp))^(((x%x)>>(tmp = 1798026491.3658786, tmp))-(((1024072781)/(tmp = -2407354455, tmp))%(1973295010))))<<(-1966787233))^x)|(-1787730004))))); - assertEquals(-1073754452, x |= (tmp = 3099823788.077907, tmp)); - assertEquals(-1540683096, x &= (-1540674632.7013893)); - assertEquals(-1540683052, x ^= ((tmp = -126183090, tmp)>>>((-622437575.5788481)|((((tmp = -2947914022, tmp)%(((tmp = 2512586745, tmp)>>x)>>>((27238232.23677671)/(tmp = 3203958551, tmp))))/(tmp = 2906005721.402535, tmp))^((((tmp = 1763897860.737334, tmp)^(1445562340.2485332))/x)+(-2393501217.716533)))))); - assertEquals(-1258599433, x |= (tmp = 351291767.59661686, tmp)); - assertEquals(-1241560065, x |= (626346046.5083935)); - assertEquals(-1241560065, x ^= ((2263372092)/((tmp = -2868907862, tmp)>>>x))); - assertEquals(-893685228, x -= (tmp = -347874837, tmp)); - assertEquals(3401282068, x >>>= (x*x)); - assertEquals(0, x %= x); - assertEquals(0, x >>>= x); - assertEquals(-2079237393, x ^= (tmp = 2215729903, tmp)); - assertEquals(NaN, x %= ((((tmp = 3203450436, tmp)/(2867575150.6528325))&(1864945829))&((x&((((tmp = -1927086741.3438427, tmp)|x)|(-1783290909.3240588))*((-1074778499.0697656)*(x-((tmp = -848983542.8456669, tmp)^(tmp = -1324673961, tmp))))))>>(tmp = -2144580304.245896, tmp)))); - assertEquals(-43334009, x |= (x^(-43334009.72683525))); - assertEquals(-43334009, x &= x); - assertEquals(-43334009, x %= (tmp = 1252450645.060542, tmp)); - assertEquals(-43334009, x |= (((((((tmp = 968062202, tmp)/(x|(tmp = 2766801984, tmp)))*((2173353793.938968)>>(((tmp = -2459317247, tmp)<<(tmp = -2333601397, tmp))>>>((tmp = -578254251.8969193, tmp)*(tmp = 839964110.7893236, tmp)))))&(((1675305119)&(tmp = -929153707, tmp))*((x*x)*x)))/x)|(x/(tmp = 384740559.43867135, tmp)))%(1657362591))); - assertEquals(0, x -= x); - assertEquals(0, x %= (-1334758781.1087842)); - assertEquals(0, x -= x); - assertEquals(-54, x += ((tmp = -1787151355.470972, tmp)>>((tmp = 237028977, tmp)>>(((2829473542)<<(x>>>(((((((x-(-1950724753))*(((x>>>(2807353513.6283565))<<((-583810779.1155353)>>(x*x)))>>(-1068513265)))^(x^(-696263908.5131407)))%(((tmp = -1325619399, tmp)<<((tmp = -1030194450, tmp)-x))^x))+((-2852768585.3718724)>>(tmp = -3160022361, tmp)))%(x&x))>>(tmp = 2667222702.5454206, tmp))))+((804998368.8915854)<<x))))); - assertEquals(-54, x %= (-1601267268.4306633)); - assertEquals(1, x >>>= (tmp = -543199585.579128, tmp)); - assertEquals(4.732914708226396e-10, x /= (tmp = 2112862922, tmp)); - assertEquals(-4266932650, x -= ((((x^((((tmp = 2784618443, tmp)^(tmp = -2271260297.9010153, tmp))|((((tmp = -599752639.7516592, tmp)*(2751967680.3680997))^(tmp = -1478450055.578217, tmp))*x))-x))&((tmp = -520061982, tmp)-((tmp = 1400176711.9637299, tmp)^(((2100417541)|(x+(tmp = -674592897.0420957, tmp)))>>x))))^(tmp = -365650686.7947228, tmp))>>>((-2943521813)&(((tmp = -1888789582, tmp)>>(tmp = 700459655.488978, tmp))+(tmp = -1725725703.655931, tmp))))); - assertEquals(224277168, x <<= (tmp = 2885115011.8229475, tmp)); - assertEquals(224277168, x %= (tmp = -2655345206.442777, tmp)); - assertEquals(850395136, x <<= (x-(((((-769868538.1729524)/((tmp = -298603579, tmp)%(x^x)))+((2691475692)|(((x>>>(628995710.4745524))^(x<<(((tmp = -1046054749, tmp)|(919868171))-x)))^((-1377678789.8170452)&((3065147797)%(tmp = 2638804433, tmp))))))^(tmp = -2036295169, tmp))&(((tmp = -157844758.08476114, tmp)*(tmp = -2819601496, tmp))&((((tmp = 78921441, tmp)<<(653551762.5197772))/(1801316098))*(-1479268961.8276927)))))); - assertEquals(1645565728, x ^= (tmp = 1353013024, tmp)); - assertEquals(1645565728, x >>>= x); - assertEquals(3020513544, x += (1374947816)); - assertEquals(0, x %= x); - assertEquals(0, x %= ((((((tmp = -304228072.4115715, tmp)>>>((-90523260.45975709)-(tmp = -3013349171.084838, tmp)))%((-1640997281)*((tmp = -1600634553, tmp)%((tmp = 557387864, tmp)<<((888796080.766409)|(x^((((x%(((((tmp = 1164377954.1041703, tmp)*x)|(2742407432.192806))&((tmp = 1707928950, tmp)<<(1279554132.4481683)))+(tmp = -2108725405.7752397, tmp)))%(tmp = -465060827, tmp))^((tmp = 2422773793, tmp)+x))^((((((((tmp = -1755376249, tmp)^((-267446806)^x))/(((tmp = -1808578662.4939392, tmp)+((tmp = -1997100217, tmp)+x))+(((tmp = -2469853122.411479, tmp)/x)>>(tmp = 660624616.7956645, tmp))))%((x<<((((((tmp = -1701946558, tmp)-(tmp = 133302235, tmp))>>>x)/(738231394))<<(-1060468151.4959564))&(((((-1877380837.4678264)|(tmp = 2366186363, tmp))%x)>>>(-2382914822.1745577))>>((-1874291848.9775913)<<(tmp = 2522973186, tmp)))))<<(-2672141993)))|(tmp = 732379966, tmp))%x)^x)^x))))))))%(tmp = 2385998902.7287374, tmp))*x)+(tmp = -2195749866.017106, tmp))); - assertEquals(401488, x ^= (((-320896627)>>>(tmp = 2812780333.9572906, tmp))&(tmp = -2088849328, tmp))); - assertEquals(-1661116571.0046256, x += (tmp = -1661518059.0046256, tmp)); - assertEquals(-1616122720, x <<= x); - assertEquals(-1616122720, x >>= x); - assertEquals(-390439413, x %= (tmp = -1225683307, tmp)); - assertEquals(-84189205, x |= ((x|(2054757858))^(((x<<(((x|x)|(((x>>>((-2938303938.1397676)<<((2993545056)^((tmp = -643895708.5427527, tmp)/((1371449825.5345795)-(1896270238.695752))))))-(tmp = 1061837650, tmp))+(x+(tmp = 3072396681, tmp))))>>(x-((((tmp = -1877865355.1550744, tmp)&x)%(-2766344937))>>>(2055121782)))))-((x<<x)|(tmp = -2742351880.1974454, tmp)))<<((-2600270279.219802)>>(-1625612979))))); - assertEquals(-168378410, x += x); - assertEquals(-168378410, x &= x); - assertEquals(-1534983792, x &= (-1501412943)); - assertEquals(-1821543761, x ^= (938439487)); - assertEquals(-1821543761, x &= (x^(((tmp = -4237854, tmp)>>x)/x))); - assertEquals(2358, x >>>= (2954252724.620632)); - assertEquals(4716, x <<= ((-75522382.8757689)/((tmp = 1074334479, tmp)|((tmp = -720387522, tmp)>>(x>>>(-3085295162.6877327)))))); - assertEquals(-1313079316, x |= (2981887904.020387)); - assertEquals(-1957790646, x -= (644711330)); - assertEquals(17831, x >>>= ((tmp = -2550108342, tmp)-(((tmp = 454671414.0146706, tmp)+(-661129693.9333956))>>(x>>>(((tmp = 1752959432.3473055, tmp)*(-2619510342.1812334))%(tmp = -456773274.2411971, tmp)))))); - assertEquals(689287937.6879716, x -= ((tmp = -397126863.6879716, tmp)-(((x>>x)^(x/(-1387467129.6278908)))|((x>>((tmp = -2361114214.8413954, tmp)<<(tmp = -805670024.4717407, tmp)))<<(-2724018098))))); - assertEquals(1378575875.3759432, x += x); - assertEquals(84112428460187.8, x *= (((((2681425112.3513584)%(tmp = -1757945333, tmp))|x)>>(-1793353713.0003397))%x)); - assertEquals(-3221, x >>= (-1976874128)); - assertEquals(-3221, x %= (((tmp = 2318583056.834932, tmp)|((tmp = -1016115125, tmp)+((-472566636.32567954)+x)))|(tmp = 3135899138.065598, tmp))); - assertEquals(-6596608, x <<= x); - assertEquals(-1249902592, x <<= (((tmp = -2025951709.5051148, tmp)/((-465639441)<<(-2273423897.9682302)))*((tmp = -2408892408.0294642, tmp)-(tmp = 1017739741, tmp)))); - assertEquals(73802092170444800, x *= (tmp = -59046275, tmp)); - assertEquals(-1619001344, x <<= x); - assertEquals(0, x <<= (tmp = 1610670303, tmp)); - assertEquals(-0, x *= ((((x+(tmp = 2039867675, tmp))|(tmp = 399355061, tmp))<<(1552355369.313559))^x)); - assertEquals(0, x *= x); - assertEquals(0, x >>>= (((2875576018.0610805)>>x)%(tmp = -2600467554, tmp))); - assertEquals(2290405226.139538, x -= (-2290405226.139538)); - assertEquals(0, x %= x); - assertEquals(0, x ^= (((tmp = 2542309844.485515, tmp)-x)%((-2950029429.0027323)/(tmp = 2943628481, tmp)))); - assertEquals(0, x += x); - assertEquals(0, x -= x); - assertEquals(0, x >>>= (tmp = 2337330038, tmp)); - assertEquals(0, x += (x/(((292272669.0808271)&(tmp = 2923699026.224247, tmp))^(tmp = 367745855, tmp)))); - assertEquals(0, x &= x); - assertEquals(0, x %= ((tmp = 1565155613.3644123, tmp)<<(-308403859.5844681))); - assertEquals(-1845345399.3731332, x += (tmp = -1845345399.3731332, tmp)); - assertEquals(5158590659731951000, x *= (-2795460763.8680177)); - assertEquals(-364664, x >>= (1837745292.5701954)); - assertEquals(1, x /= x); - assertEquals(-860616114.8182092, x += ((tmp = 2076961323.1817908, tmp)+(-2937577439))); - assertEquals(-860616115, x ^= ((x*(tmp = 2841422442.583121, tmp))>>>((tmp = 1929082917.9039137, tmp)>>(-2602087246.7521305)))); - assertEquals(-38387843, x |= (3114677624)); - assertEquals(2927507837, x += (tmp = 2965895680, tmp)); - assertEquals(1, x /= x); - assertEquals(-1792887531, x *= (-1792887531)); - assertEquals(-0, x %= ((x^x)+x)); - assertEquals(-0, x %= (tmp = 2800752702.562547, tmp)); - assertEquals(1384510548, x ^= (tmp = 1384510548, tmp)); - assertEquals(42251, x >>= (1645421551.363844)); - assertEquals(0, x >>>= (17537561)); - assertEquals(-2076742862, x ^= (tmp = 2218224434, tmp)); - assertEquals(-2.790313825067623, x /= (744268563.3934636)); - assertEquals(5313538, x &= (((((tmp = -2406579239.0691676, tmp)+((-1470174628)+(((tmp = -783981599, tmp)<<(tmp = -1789801141.272646, tmp))^(((((((tmp = -844643189.5616491, tmp)&(tmp = -252337862, tmp))&(x|x))%((-3159642145.7728815)+(tmp = 2149920003.9525595, tmp)))&(x>>(1737589807.9431858)))-((((((((1610161800)<<(497024994))>>x)<<x)/x)>>>x)&x)-(757420763.2141517)))-(tmp = -3061016994.9596977, tmp)))))/(tmp = 1810041920.4089384, tmp))&(tmp = 5887654.786785364, tmp))&((tmp = 1626414403.2432103, tmp)+(x%x)))); - assertEquals(-2147483648, x <<= (tmp = 1304102366.8011155, tmp)); - assertEquals(-208418816, x %= (((((-2850404799)*(x+(3158771063.226051)))*(-2017465205))/(x>>x))>>(x%(tmp = 2760203322, tmp)))); - assertEquals(-2189223477, x -= (1980804661)); - assertEquals(-859239912, x ^= (tmp = 2974421971.3544703, tmp)); - assertEquals(-1599850415, x ^= (tmp = -2475871671.140151, tmp)); - assertEquals(-1600636847, x += ((((tmp = -1311002944, tmp)<<((tmp = -1137871342, tmp)<<(tmp = 115719116, tmp)))/(413107255.6242596))<<(x>>((((-1908022173)&(((-1519897333)^((x>>(x*(tmp = -2886087774.426503, tmp)))*(tmp = 530910975, tmp)))+(-2579617265.889692)))+((2518127437.127563)>>>((tmp = 481642471.56441486, tmp)>>>(792447239))))^(x<<(248857393.6819017)))))); - assertEquals(-191, x >>= (-1591265193)); - assertEquals(-192.27421813247196, x += ((tmp = 2627329028.207775, tmp)/(tmp = -2061914644.9523563, tmp))); - assertEquals(1230613220, x ^= (tmp = 3064354212.307105, tmp)); - assertEquals(1230613220, x &= x); - assertEquals(1230613220, x %= (1833479205.1064768)); - assertEquals(1230613220, x >>>= ((((1559450742.1425748)|((2151905260.956583)*(1213275165)))%(514723483.12764716))>>>x)); - assertEquals(1230613493, x |= ((((3004939197.578903)*(tmp = -576274956, tmp))+((tmp = 1037832416.2243971, tmp)^x))>>>(tmp = 2273969109.7735467, tmp))); - assertEquals(2461226986, x += x); - assertEquals(-27981, x >>= ((692831755.8048055)^((tmp = -1593598757, tmp)%(x-((((-1470536513.882593)|((tmp = -2716394020.466401, tmp)|(tmp = 2399097686, tmp)))&x)%x))))); - assertEquals(-1.4660454948034359e+23, x *= (((x>>>((((((tmp = -3056016696, tmp)<<(-2882888332))*(2041143608.321916))&(((tmp = -634710040, tmp)|(tmp = -2559412457, tmp))>>(1916553549.7552106)))%((-2150969350.3643866)*x))<<((x*(tmp = 2657960438.247278, tmp))|x)))%((tmp = 526041379, tmp)*(tmp = 2514771352.4509397, tmp)))*(1219908294.8107886))); - assertEquals(-1.4660454948034359e+23, x -= ((1709004428)>>(((x|(-422745730.626189))%x)>>x))); - assertEquals(-2247766068, x %= (-3105435508)); - assertEquals(-386845856.0649812, x -= (-1860920211.9350188)); - assertEquals(-386846803.0649812, x -= ((((-3214465921)|((tmp = -1326329034, tmp)+(((tmp = -1203188938.9833462, tmp)%((((((-1318276502)+(x+x))^((x<<x)%(x>>>x)))+(tmp = -439689881, tmp))+((-1455448168.695214)^(x-((-388589993)>>((((940252202)^(-2218777278))|x)/(tmp = -1007511556, tmp))))))&(-140407706.28176737)))-(x/((888903270.7746506)-((tmp = -2885938478.632409, tmp)<<(((((tmp = -1750518830.270917, tmp)>>(((((((tmp = 868557365.7908674, tmp)/(tmp = -2805687195.5172157, tmp))*x)|((((((-1342484550)-((tmp = 1089284576, tmp)^(tmp = 120651272, tmp)))<<(tmp = 2230578669.4642825, tmp))-(x*x))%(x^(((tmp = -3177941534, tmp)+(x>>(-1595660968)))/(-1738933247))))>>>(tmp = 2860175623, tmp)))-(((2392690115.8475947)>>>(tmp = -1754609670.2068992, tmp))>>>(tmp = 2615573062, tmp)))-(tmp = 2590387730, tmp))^((x+((((x-(tmp = -2823664112.4548965, tmp))*(200070977))>>>(((x|((((tmp = 1361398, tmp)>>((tmp = 1649209268, tmp)%x))+x)+(x>>>(tmp = -2379989262.1245675, tmp))))|(x^((tmp = -647953298.7526417, tmp)-x)))&(tmp = -1881232501.1945808, tmp)))>>>x))%(x^(tmp = -1737853471.005935, tmp)))))>>>(427363558))>>>((tmp = -3076726422.0846386, tmp)^(-1518782569.1853383)))/x)))))))|x)>>>(1854299126))); - assertEquals(-386846803.0649812, x -= (x%x)); - assertEquals(238532, x >>>= (-448890706.10774803)); - assertEquals(232, x >>>= (-791593878)); - assertEquals(232, x <<= (((x^((x-x)&(tmp = 1219114201, tmp)))/(tmp = -427332955, tmp))%(tmp = 1076283154, tmp))); - assertEquals(210, x ^= (x>>>((2975097430)>>>x))); - assertEquals(1, x /= x); - assertEquals(2317899531, x *= (2317899531)); - assertEquals(1131786, x >>>= x); - assertEquals(2301667519.6379366, x += ((tmp = 193109669.63793683, tmp)+(tmp = 2107426064, tmp))); - assertEquals(3842614963.6379366, x += (((-1676516834)>>>(tmp = -1817478916.5658965, tmp))^(((tmp = 1122659711, tmp)>>>(tmp = -2190796437, tmp))|(tmp = -2754023244, tmp)))); - assertEquals(-452352333, x &= x); - assertEquals(-863, x >>= x); - assertEquals(-3.777863669459606e-7, x /= (2284359827.424491)); - assertEquals(-3.777863669459606e-7, x %= ((tmp = -2509759238, tmp)>>>x)); - assertEquals(0, x <<= (-814314066.6614306)); - assertEquals(0, x %= (tmp = 190720260, tmp)); - assertEquals(2301702913, x += (2301702913)); - assertEquals(-249158048, x >>= (tmp = -2392013853.302008, tmp)); - assertEquals(-249158048, x >>= x); - assertEquals(-498316096, x += x); - assertEquals(-498316096, x %= (tmp = 2981330372.914731, tmp)); - assertEquals(106616.2199211318, x *= (((((tmp = 1020104482.2766557, tmp)^((tmp = -416114189.96786, tmp)>>>(1844055704)))|(tmp = 1665418123, tmp))>>(1826111980.6564898))/(-2446724367))); - assertEquals(106616, x |= x); - assertEquals(1094927345, x -= (((-1229759420)|(741260479.7854375))-x)); - assertEquals(8353, x >>= x); - assertEquals(0, x >>>= (tmp = -327942828, tmp)); - assertEquals(-953397616.8888416, x += (tmp = -953397616.8888416, tmp)); - assertEquals(-1906641240.7776833, x += (x+((-3033450184.9106326)>>>(tmp = 2090901325.5617187, tmp)))); - assertEquals(-1906641240.7776833, x %= (tmp = 2584965124.3953505, tmp)); - assertEquals(-1098907671, x |= (tmp = -1272590495, tmp)); - assertEquals(-1.8305258600334393, x /= (600323489)); - assertEquals(-1, x &= x); - assertEquals(-1, x |= ((x+x)-x)); - assertEquals(1, x *= x); - assertEquals(867473898, x ^= (tmp = 867473899.0274491, tmp)); - assertEquals(6, x >>>= (tmp = 1174763611.341228, tmp)); - assertEquals(0, x >>= ((689882795)^(2250084531))); - assertEquals(0, x /= (tmp = 2545625607, tmp)); - assertEquals(0, x >>= x); - assertEquals(0, x += x); - assertEquals(0, x -= (x*(-1098372339.5157008))); - assertEquals(NaN, x %= x); - assertEquals(NaN, x -= (tmp = -1797344676.375759, tmp)); - assertEquals(1121476698, x |= (tmp = 1121476698, tmp)); - assertEquals(1, x /= x); - assertEquals(1, x &= (-191233693)); - assertEquals(330137888.92595553, x += (330137887.92595553)); - assertEquals(-1792236714, x ^= (tmp = 2256609910, tmp)); - assertEquals(269000724, x &= (316405813.62093115)); - assertEquals(256, x >>= x); - assertEquals(256, x %= ((2556320341.54669)|(1066176021.2344948))); - assertEquals(256, x |= x); - assertEquals(131072, x <<= ((-1650561175.8467631)|x)); - assertEquals(-286761951, x -= ((tmp = 287024095, tmp)-((-2293511421)&(x|x)))); - assertEquals(-1561852927, x &= (3002663949.0989227)); - assertEquals(-460778761, x %= (tmp = -550537083, tmp)); - assertEquals(-3023749308.0492287, x += (tmp = -2562970547.0492287, tmp)); - assertEquals(-481313332.04922867, x %= ((x|((tmp = -855929299, tmp)%((2181641323)%(x|(220607471.33018696)))))&x)); - assertEquals(17510668, x &= (tmp = 363557663, tmp)); - assertEquals(12552, x &= (3020225307)); - assertEquals(1814655896, x |= ((x<<(((-1475967464)*(-3122830185))*x))+(x^(-2480340864.2661023)))); - assertEquals(-3209124403525266400, x -= ((1146847590)*(tmp = 2798213497, tmp))); - assertEquals(-6418248807050533000, x += x); - assertEquals(1.1856589432073933e+28, x *= (-1847324681.313275)); - assertEquals(-1238853292, x ^= (-1238853292)); - assertEquals(-77428331, x >>= (x&((((2043976651.8514216)>>>x)^(x>>>(((tmp = -1785122464.9720652, tmp)%x)<<(1570073474.271266))))*x))); - assertEquals(2011, x >>>= x); - assertEquals(2011, x &= x); - assertEquals(0, x >>= (-2682377538)); - assertEquals(-1.1367252770299785, x -= (((tmp = 2704334195.566802, tmp)/(2379056972))%((((-1764065164)*((((468315142.8822602)>>((x%(((tmp = 2537190513.506641, tmp)+((x&(x|((tmp = -947458639, tmp)^(2653736677.417406))))*((x<<((1243371170.1759553)>>>(((tmp = 1572208816, tmp)<<((tmp = 963855806.1090456, tmp)>>>x))%((-3078281718.7743487)*x))))^(-1154518374))))^(-2839738226.6314087)))^((-2865141241.190915)*(-2400659423.8207664))))>>((tmp = 32940590, tmp)/(tmp = 2917024064.570817, tmp)))+(((27601850)/(tmp = 3168834986, tmp))>>x)))+(tmp = 2528181032.600125, tmp))/(3162473952)))); - assertEquals(-1697395408.7948515, x -= (1697395407.6581264)); - assertEquals(1536992607912062500, x *= (tmp = -905500627.5781817, tmp)); - assertEquals(102759872, x >>= (tmp = -707887133.4484048, tmp)); - assertEquals(102759872, x %= (tmp = -1764067619.7913327, tmp)); - assertEquals(12543, x >>>= (-144142995.1469829)); - assertEquals(-2059555229.2592103, x += ((-2059555229.2592103)-x)); - assertEquals(-537022593, x |= (tmp = -2770761410.407701, tmp)); - assertEquals(23777505, x ^= (-560496738.6854918)); - assertEquals(-64329014115772310, x *= ((tmp = -2729234369.198843, tmp)+x)); - assertEquals(189083830, x ^= (tmp = 933619934, tmp)); - assertEquals(189083830, x %= ((tmp = -2918083254, tmp)-(x|(x^(-2481479224.0329475))))); - assertEquals(378167660, x += x); - assertEquals(-0.45833387791900504, x /= ((tmp = 2727991875.241294, tmp)<<(tmp = 2570034571.9084663, tmp))); - assertEquals(0, x <<= x); - assertEquals(-0, x /= (tmp = -67528553.30662966, tmp)); - assertEquals(0, x <<= (938440044.3983492)); - assertEquals(-945479171, x ^= (tmp = -945479171, tmp)); - assertEquals(-225632619284361200, x *= (238643670.00884593)); - assertEquals(-0, x %= x); - assertEquals(-585826304, x ^= ((-1256265560)<<(tmp = 1144713549, tmp))); - assertEquals(-671583855, x ^= (183333265.1468178)); - assertEquals(-484311040, x <<= x); - assertEquals(-3969762.62295082, x /= ((((tmp = -1164308668.931008, tmp)-x)%x)>>>(((397816647)>>(-1605343671.4070785))<<x))); - assertEquals(758097879, x ^= ((tmp = -2871307491, tmp)^(-2043176492.646442))); - assertEquals(0, x *= ((x>>(tmp = 1983292927, tmp))&(tmp = -860505131.4484091, tmp))); - assertEquals(0, x <<= x); - assertEquals(0, x &= x); - assertEquals(0, x %= ((3132981707)-(-2832016477))); - assertEquals(0, x >>= (x<<((1830195133.0342631)>>>(tmp = -1003969250, tmp)))); - assertEquals(NaN, x %= x); - assertEquals(NaN, x += (tmp = 273271019.87603223, tmp)); - assertEquals(NaN, x += (625749326.1155348)); - assertEquals(0, x >>= (tmp = -531039433.3702333, tmp)); - assertEquals(0, x -= (((tmp = 2029464099, tmp)-(x-(tmp = -329058111.411458, tmp)))*(x<<x))); - assertEquals(-0, x *= ((-1112957170.5613296)|((tmp = 847344494, tmp)>>>(tmp = 2735119927, tmp)))); - assertEquals(-0, x /= (tmp = 544636506, tmp)); - assertEquals(0, x >>>= (x^(545093699))); - assertEquals(0, x %= (((tmp = -2208409647.5052004, tmp)+(3083455385.374988))+(((-482178732.7077277)*x)>>>((2661060565)*(-2125201239))))); - assertEquals(0, x >>>= (-212334007.34016395)); - assertEquals(0.7004300865203454, x -= ((2032883941)/(-2902336693.0154715))); - assertEquals(0, x <<= (x<<((265868133.50175047)>>>(1162631094)))); - assertEquals(604920272.4394834, x -= (-604920272.4394834)); - assertEquals(604920272, x &= x); - assertEquals(0, x <<= (((-1961880051.1127694)%(tmp = 1715021796, tmp))|((tmp = 2474759639.4587016, tmp)|(243416152.55635)))); - assertEquals(-46419074, x |= (((tmp = -518945938.5238774, tmp)%((x+(tmp = 242636408, tmp))+(-1974062910)))|(1546269242.0259726))); - assertEquals(-46419074, x += ((-629802130)*((tmp = -658144149, tmp)%((-905005358.5370393)>>>x)))); - assertEquals(-46419074, x |= (x%(-1103652494))); - assertEquals(7892881050983985, x *= (-170035297.36469936)); - assertEquals(1105701997.4273424, x %= ((((-490612260.0023911)>>>(tmp = 1803426906, tmp))^(x%(2725270344.2568116)))-(1010563167.8934317))); - assertEquals(1088619532, x &= (-2232199650)); - assertEquals(1073807364, x &= (-888024506.5008001)); - assertEquals(1153062254980628500, x *= x); - assertEquals(1153062255703627000, x -= (tmp = -722998613.897227, tmp)); - assertEquals(-1141418584, x |= (3017232552.4814596)); - assertEquals(-373464140, x ^= (-2914372068)); - assertEquals(994050048, x <<= x); - assertEquals(0, x ^= x); - assertEquals(0, x &= (tmp = -3166402389, tmp)); - assertEquals(0, x &= ((-1760842506.337213)|(tmp = 2538748127.795164, tmp))); - assertEquals(-0, x /= (-2635127769.808626)); - assertEquals(0, x &= ((((tmp = 1414701581, tmp)^(((2425608769)/((x<<x)^(x-x)))^((tmp = -2641946468.737288, tmp)|(tmp = -313564549.1754241, tmp))))*(tmp = -2126027460, tmp))|(-2255015479))); - assertEquals(225482894, x ^= (225482894.8767246)); - assertEquals(0, x ^= x); - assertEquals(306216231, x += (tmp = 306216231, tmp)); - assertEquals(306216231, x -= ((-465875275.19848967)&((-806775661.4260025)/((((-184966089.49763203)>>>((x>>x)+((tmp = -1951107532, tmp)|x)))%x)*((2704859526.4047284)%((x*x)>>x)))))); - assertEquals(30754, x &= (1706162402.033193)); - assertEquals(30454.010307602264, x -= (((590456519)>>>(tmp = 2713582726.8181214, tmp))/x)); - assertEquals(8419062, x |= ((2848886788)<<(tmp = 2993383029.402275, tmp))); - assertEquals(16, x >>= (tmp = -1651287021, tmp)); - assertEquals(1, x /= x); - assertEquals(-1407643485, x ^= (-1407643486)); - assertEquals(2, x >>>= (-1126004674)); - assertEquals(470812081, x ^= ((-2411718964)>>>x)); - assertEquals(550443688.6407901, x += (tmp = 79631607.6407901, tmp)); - assertEquals(3669092443.64079, x -= (-3118648755)); - assertEquals(-625874853, x <<= (((tmp = -1640437346, tmp)/(((x*x)>>>x)<<x))/x)); - assertEquals(-1431439050363516700, x *= (2287101077)); - assertEquals(-1921660672, x |= ((((((((-1912249689.9978154)&(-1676922742.5343294))*(2625527768))<<((820676465)^(((x+(tmp = -852743692, tmp))&((x-((((1361714551)/(311531668))>>>(tmp = -1330495518.8175917, tmp))<<(((tmp = 1369938417.8760853, tmp)*(-1217947853.8942266))<<(-2048029668))))-(-513455284)))>>>(tmp = 1980267333.6201067, tmp))))<<(((1503464217.2901971)>>(tmp = 2258265389, tmp))>>>(1868451148)))&(x-(x^(tmp = -1565209787, tmp))))*x)<<(tmp = -2426550685, tmp))); - assertEquals(-1921660672, x %= (((tmp = 523950472.3315773, tmp)+(((2971865706)^x)-x))&(-1773969177))); - assertEquals(420176973.1169958, x += (2341837645.116996)); - assertEquals(420176973, x >>>= (((tmp = -2485489141, tmp)<<((tmp = -2520928568.360244, tmp)+x))&(543950045.0932506))); - assertEquals(50, x ^= (x|((tmp = 2001660699.5898843, tmp)>>>(tmp = 1209151128, tmp)))); - assertEquals(138212770720.96973, x *= (2764255414.4193945)); - assertEquals(-28683, x |= (((-535647551)|x)>>((((2065261509)>>(-354214733))*x)+(-3218217378.2592907)))); - assertEquals(1627048838, x ^= (tmp = -1627044749, tmp)); - assertEquals(-839408795, x ^= (2903337187.480303)); - assertEquals(-1000652427, x += (tmp = -161243632, tmp)); - assertEquals(740237908.4196916, x += ((tmp = 1587000348, tmp)+(tmp = 153889987.41969144, tmp))); - assertEquals(Infinity, x /= (((((-615607376.1012697)&(57343184.023578644))+((-1967741575)|(-3082318496)))<<(((tmp = -958212971.99792, tmp)>>(tmp = 2962656321.3519197, tmp))-(x|(x*(969365195)))))<<(tmp = -1739470562.344624, tmp))); - assertEquals(-Infinity, x /= ((tmp = -1736849852, tmp)%x)); - assertEquals(0, x <<= x); - assertEquals(0, x %= (tmp = -226505646, tmp)); - assertEquals(1982856549, x -= (((x+(-1982856549))%(-2274946222))>>(x%(((tmp = -1289577208.9097936, tmp)>>x)^(778147661))))); - assertEquals(1648018703, x ^= ((3085618856)+((tmp = 1546283467, tmp)&(((x|((-2376306530)*(((((((tmp = -2807616416, tmp)%(((((tmp = 347097983.1491085, tmp)<<x)|(((((1135380667)/(x>>>(tmp = 1679395106, tmp)))^((1277761947)<<((tmp = -1614841203.5244312, tmp)>>x)))%((tmp = 1552249234.2065845, tmp)>>>x))>>>(tmp = -1677859287, tmp)))>>>(2605907565))/(tmp = 2291657422.221277, tmp)))%(((tmp = 425501732.6666014, tmp)>>>(1327403879.455553))+x))>>((tmp = -3075752653.2474413, tmp)&(x-(tmp = -71834630, tmp))))|((((2532199449.6500597)*(-842197612.4577162))%x)>>x))*(((1220047194.5100307)<<((tmp = 1642962251, tmp)<<((-662340)>>>((tmp = -1672316631.3251066, tmp)<<((tmp = 1762690952.542441, tmp)-(x/(1904755683.3277364)))))))>>x))|(((((tmp = 1625817700.7052522, tmp)%(tmp = -2990984460, tmp))|(2395645662))-((2619930607.550086)>>x))^(tmp = 130618712, tmp)))))&((-3142462204.4628367)/(1078126534.8819227)))%(((tmp = -256343715.2267704, tmp)+x)^(tmp = 2009243755, tmp)))))); - assertEquals(1937698223, x |= (((tmp = 866354374.7435778, tmp)+(tmp = 2751925259.3264275, tmp))%(-2252220455))); - assertEquals(0, x -= x); - assertEquals(-823946290.6515498, x -= (tmp = 823946290.6515498, tmp)); - assertEquals(706970324, x ^= (-457174758)); - assertEquals(32916, x &= (25740724)); - assertEquals(0, x >>>= ((-1658933418.6445677)|(tmp = -846929510.4794133, tmp))); - assertEquals(0, x ^= ((-834208600)/((-1256752740)&(tmp = 1973248337.8973258, tmp)))); - assertEquals(-1639195806, x += (-1639195806)); - assertEquals(-1559416478, x ^= ((tmp = 1349893449.0193534, tmp)*(tmp = 2044785568.1713037, tmp))); - assertEquals(0, x &= ((x>>(tmp = 1720833612, tmp))/((x+(-1305879952.5854573))^x))); - assertEquals(-0, x *= (tmp = -1713182743, tmp)); - assertEquals(0, x >>= x); - assertEquals(NaN, x /= (((x%((x>>>(((-1515761763.5499895)^(-3076528507.626539))<<(tmp = 1293944457.8983147, tmp)))<<(tmp = 276867491.8483894, tmp)))>>(tmp = -2831726496.6887417, tmp))%((((tmp = 1780632637.3666987, tmp)^x)%((208921173.18897665)>>(tmp = 633138136, tmp)))+x))); - assertEquals(0, x >>= (tmp = -2755513767.0561147, tmp)); - assertEquals(0, x |= x); - assertEquals(840992300.0324914, x -= ((-840992300.0324914)+x)); - assertEquals(840992300, x &= x); - assertEquals(-1094140277, x ^= (2364029095)); - assertEquals(-Infinity, x /= ((((((1257084956)<<(2009241695))>>(x+x))*x)>>>x)>>>(205318919.85870552))); - assertEquals(-Infinity, x -= (((x>>>(tmp = 3037168809.20163, tmp))&x)*(x&(((806151109)*x)-(tmp = -1741679480.58333, tmp))))); - assertEquals(400659949, x ^= (tmp = 400659949, tmp)); - assertEquals(5, x >>= (tmp = 1175519290, tmp)); - assertEquals(5, x |= x); - assertEquals(0, x >>= x); - assertEquals(0, x >>= ((1317772443)&(x<<x))); - assertEquals(-1123981819, x ^= (tmp = 3170985477, tmp)); - assertEquals(1123864651, x ^= ((x%(((x&x)&(-2606227299.7590737))<<((tmp = -2018123078.1859496, tmp)*x)))|(x+(((((1935939774.8139446)/((-1303958190)/(2802816697.32639)))<<((2880056582)*x))+x)+x)))); - assertEquals(1543368927, x |= (-2795691884)); - assertEquals(NaN, x /= (x%((tmp = -1129915114, tmp)<<x))); - assertEquals(NaN, x += (tmp = -3045743135, tmp)); - assertEquals(NaN, x -= (tmp = -2849555731.8207827, tmp)); - assertEquals(NaN, x /= (((((2127485827)>>>((((tmp = 363239924, tmp)>>x)|((((tmp = -1419142286.0523334, tmp)-(x<<x))^(tmp = -1990365089.8283136, tmp))*((tmp = 2780242444.0739098, tmp)>>>(((-2336511023.342298)&x)/(tmp = 2296926221.402897, tmp)))))>>((tmp = 1378982475.6839466, tmp)>>(tmp = -816522530, tmp))))&(x^(tmp = -1668642255.0586753, tmp)))%(((tmp = 921249300.1500335, tmp)^x)*(tmp = -2228816905, tmp)))>>x)); - assertEquals(-1460685191, x |= (tmp = 2834282105, tmp)); - assertEquals(-1463439264, x &= (tmp = 2881860064.146755, tmp)); - assertEquals(20.98100714963762, x /= (((3017150580.7875347)^((250499372.5339837)<<(tmp = -42767556.30788112, tmp)))|(x%(-2829281526)))); - assertEquals(1, x /= x); - assertEquals(2, x += x); - assertEquals(8, x <<= x); - assertEquals(0, x >>>= ((730174750)>>>x)); - assertEquals(0, x ^= x); - assertEquals(-1459637373, x ^= (2835329923.456409)); - assertEquals(-1233115861, x ^= (511678120)); - assertEquals(95682857, x >>>= ((tmp = 1534570885, tmp)|(tmp = -414425499.3786578, tmp))); - assertEquals(70254633, x &= (-1502067585)); - assertEquals(51384749748909710, x *= (tmp = 731407276, tmp)); - assertEquals(9390482.873469353, x %= (tmp = -592576964.7982686, tmp)); - assertEquals(4695241, x >>>= (tmp = -1879898431.5395758, tmp)); - assertEquals(-3129811912538149000, x += (((-727481809)^((3106908604)%x))*((((tmp = -1218123690, tmp)^(x>>((-942923806)^x)))/(x+x))>>>(-1508881888.969373)))); - assertEquals(1596870236, x ^= (-1135673764.9721224)); - assertEquals(0, x ^= x); - assertEquals(2133782410, x |= (((-2202469371)>>((tmp = 1327588406.183342, tmp)/(tmp = 253581265.7246865, tmp)))-((tmp = 2226575446.838795, tmp)^x))); - assertEquals(-81895217.83608055, x -= (tmp = 2215677627.8360806, tmp)); - assertEquals(812089344, x <<= ((tmp = 882824005, tmp)/(((x>>((((((((tmp = 1211145185, tmp)/((-137817273)-(((tmp = 2165480503.1144185, tmp)-(-1840859887.1288517))*((155886014.8393339)>>((-1984526598)<<(tmp = 1331249058.3246582, tmp))))))>>(x*x))%(2830324652))%(933701061))|(1346496215))^(tmp = -988800810, tmp))+x))>>>x)<<(-2372088384)))); - assertEquals(812089344, x <<= x); - assertEquals(8472, x %= ((((x|(((x%(tmp = 2772099481.664402, tmp))+(2894690616))-x))&(x&(((-715790638.6454093)>>(tmp = -1447931029, tmp))-(tmp = 1761027889, tmp))))^x)%(((tmp = 830969811, tmp)|x)|((-1102267929)-(3193018687))))); - assertEquals(-0.0000028559857417864914, x /= (-2966401364)); - assertEquals(0, x >>= x); - assertEquals(-701800392, x += (tmp = -701800392, tmp)); - assertEquals(2034756873, x -= (tmp = -2736557265, tmp)); - assertEquals(-0.9475075048394501, x /= (((((82879340.27231383)+((tmp = -2876678920.653639, tmp)*(-2801097850)))<<x)>>>((x<<(((((x|x)&(tmp = -1572694766, tmp))>>(x+(x/((x-(((tmp = 1435301275, tmp)|(tmp = 983577854.212041, tmp))>>(tmp = 632633852.1644179, tmp)))+x))))>>>x)|(-850932021)))>>x))<<(-821983991))); - assertEquals(0, x >>= (x>>(2424003553.0883207))); - assertEquals(2599386349, x -= (-2599386349)); - assertEquals(-68157441, x |= (((tmp = -1170343454.9327996, tmp)+((((tmp = 448468098, tmp)|(x>>(x>>(((x>>(((x/(x&(x<<x)))<<(2436876051.2588806))^(3010167261)))%((tmp = 2577616315.7538686, tmp)>>>(-2953152591.015912)))%((tmp = -1304628613, tmp)/(x&((x|((-2000952119)%((691146914)/((tmp = 1480966978.7766845, tmp)<<((tmp = 2644449477.392441, tmp)|(-2143869305.871568))))))+(tmp = -315254308, tmp))))))))&(-2060205555))|((-604140518.8186448)^(x*x))))%(x*((tmp = 1383244000.2807684, tmp)/(3195793656))))); - assertEquals(-68157441, x |= x); - assertEquals(-1, x >>= x); - assertEquals(-2147483648, x <<= x); - assertEquals(-1.5257198286933313, x /= (tmp = 1407521622, tmp)); - assertEquals(1149084989.47428, x += (((tmp = 1149084991.9004865, tmp)&x)^((((((2797053000)/(x^x))*(-2829253694))>>>((tmp = -610924351, tmp)>>x))>>>(tmp = -675681012, tmp))<<(2812852729)))); - assertEquals(0, x %= x); - assertEquals(0, x <<= ((tmp = -584069073, tmp)*(-2953140326))); - assertEquals(0, x <<= (tmp = -481515023.6404002, tmp)); - assertEquals(-1441535370, x ^= (2853431926)); - assertEquals(2853431926, x >>>= (((((((tmp = 2215663525.9620194, tmp)%((-1102832735.9274108)/x))>>x)&(3220898702.76322))&(((2077584946)*((x>>x)<<((tmp = 1845701049, tmp)-x)))/(tmp = 1947184202.5737212, tmp)))|(((tmp = 2976351488, tmp)^(-42517339))%((2648230244.410125)^(1520051731.31089))))/(1761635964))); - assertEquals(43539, x >>>= (tmp = 1361671184.7432632, tmp)); - assertEquals(21769, x >>= ((tmp = -804932298.9572575, tmp)>>((((tmp = 1749006993.253409, tmp)+(276536978))^x)|(2698166994)))); - assertEquals(1103025563, x |= (tmp = 1103007891, tmp)); - assertEquals(1327594607, x += (tmp = 224569044, tmp)); - assertEquals(1327594607, x |= x); - assertEquals(-478674944, x <<= (((672378508)&x)^(((-2070209708.6470091)|x)|(x>>>x)))); - assertEquals(-478674943, x ^= ((-1832457698.6345716)>>>((tmp = -3077714019, tmp)/(1809383028)))); - assertEquals(229129701056053250, x *= x); - assertEquals(1, x /= x); - assertEquals(2, x <<= (-1522529727)); - assertEquals(2, x &= x); - assertEquals(-2016989182, x |= ((((tmp = -1267845511, tmp)*(1225350332))+((tmp = -1397690831.5717893, tmp)>>>(tmp = -2575382994, tmp)))+x)); - assertEquals(-241, x >>= (tmp = 931869591, tmp)); - assertEquals(-1048087547, x &= (tmp = -1048087403.1163051, tmp)); - assertEquals(-4004486369.844599, x += (tmp = -2956398822.844599, tmp)); - assertEquals(-4004486368.844599, x -= (((2701878498)>>x)|(x|(-1079354967)))); - assertEquals(1, x >>= (tmp = -1583689092, tmp)); - assertEquals(1, x *= (x>>(x%x))); - assertEquals(0, x %= x); - assertEquals(-0, x *= (-120818969)); - assertEquals(0, x >>= ((tmp = 1794099660, tmp)/(((x&(((-321906091)^(tmp = -3009885933.8449526, tmp))&((tmp = -140917780, tmp)|(2037803173.4075825))))&x)&(tmp = -745357154, tmp)))); - assertEquals(0, x <<= (563984257.3493614)); - assertEquals(NaN, x %= ((((x>>(tmp = -2190891392.320677, tmp))-x)<<(462714956))<<((tmp = -84413570, tmp)|((x|(-2787022855))-((tmp = 2028532622, tmp)|(tmp = 1103757073.9178817, tmp)))))); - assertEquals(NaN, x *= ((2137674085.3142445)|((tmp = -1054749859.2353804, tmp)%x))); - assertEquals(NaN, x /= (x>>>(((((tmp = 597103360.9069608, tmp)>>>(-2850217714.1866236))-((tmp = 1125150527, tmp)*x))%(tmp = -982662312, tmp))|((x/(((968656808.6069037)*(((128484784.15362918)>>x)^x))&((((x/((((tmp = 748775979, tmp)*((x-(((tmp = 709571811.9883962, tmp)%(-2083567026))%(x/(tmp = -680467505, tmp))))/((tmp = -167543858, tmp)/(tmp = -3113588783, tmp))))/x)<<(-2605415230)))>>>(tmp = 3133054172, tmp))%(tmp = -1904650393, tmp))*((x|(-1193709562))*(tmp = -1731312795.718104, tmp)))))/((tmp = -672386301, tmp)/(tmp = 808898833.4163612, tmp)))))); - assertEquals(-9, x |= (((((tmp = 150377964.57195818, tmp)/(tmp = 2161910879.0514045, tmp))-(-2381625849))>>(-2715928517))/(((452113643)^(-2502232011))/((-3076471740)^(((tmp = 1664851172, tmp)*(((-1460011714)>>>x)<<((-2870606437)%x)))*((tmp = -2836565755.609597, tmp)-((x/(tmp = -871461415, tmp))-(2278867564)))))))); - assertEquals(-1, x >>= x); - assertEquals(-1, x |= ((-1319927272)>>>(-2866709980))); - assertEquals(-1, x >>= ((2345179803.155703)&(-978025218.2243443))); - assertEquals(1, x /= x); - assertEquals(-260730973, x |= (tmp = -260730973, tmp)); - assertEquals(1174405120, x <<= (2681054073)); - assertEquals(1174405120, x &= x); - assertEquals(1073741824, x &= (tmp = 2017166572.7622075, tmp)); - assertEquals(1073741824, x |= x); - assertEquals(168806102, x %= ((((tmp = -2939969193.950067, tmp)|((-2325174027.614815)/(-2329212715)))*(x/(((((-2927776738)/(x|x))+(x%(tmp = -3007347037.698492, tmp)))<<(-1898633380))>>(tmp = 204338085.45241892, tmp))))^x)); - assertEquals(168806102, x %= ((-832849739.5197744)&(tmp = -141908598, tmp))); - assertEquals(-401033205.05225074, x -= (tmp = 569839307.0522507, tmp)); - assertEquals(-401033205, x &= x); - assertEquals(-401130402, x ^= ((x*(tmp = 311418759.22436893, tmp))>>x)); - assertEquals(793533469, x ^= (-950312893.5201888)); - assertEquals(756, x >>>= (-1096189516)); - assertEquals(711, x += ((tmp = -753105189, tmp)>>(599823192.5381484))); - assertEquals(0, x >>>= ((tmp = -2859668634.4641137, tmp)+(-1160392986.1521513))); - assertEquals(2427599726.176195, x -= (-2427599726.176195)); - assertEquals(1942312465.2523103, x -= (485287260.92388475)); - assertEquals(0, x >>>= ((tmp = -1740656456, tmp)/(tmp = 1339746799.9335847, tmp))); - assertEquals(0, x <<= ((-7017077.38786912)*((-699490904.4551768)^x))); - assertEquals(0, x <<= (tmp = 715662384, tmp)); - assertEquals(0, x *= (x>>>(2149735450.0758677))); - assertEquals(NaN, x /= x); - assertEquals(0, x >>= ((397078885)*((851639692.8982519)-x))); - assertEquals(0, x &= (-2526654445)); - assertEquals(0, x %= (-1204924598)); - assertEquals(251639720, x ^= (x|(tmp = 251639720, tmp))); - assertEquals(695433573, x ^= (663539405)); - assertEquals(-1038050104, x -= (1733483677)); - assertEquals(0, x ^= x); - assertEquals(NaN, x %= x); - assertEquals(0, x &= (392107269)); - assertEquals(0, x %= (-3084908458.241551)); - assertEquals(0, x ^= x); - assertEquals(-2121660509, x ^= (tmp = -2121660509.7861986, tmp)); - assertEquals(2285041855588855800, x *= (x|(3209046634))); - assertEquals(54915072, x >>>= (x%(((((x%((((tmp = -1429433339.5078833, tmp)|(tmp = 2906845137, tmp))^(3207260333))&(-848438650)))-(-2721099735))&(141851917.19978714))+x)/x))); - assertEquals(54915072, x &= x); - assertEquals(54915072, x %= (x+(1855489160))); - assertEquals(70078753, x ^= ((((((-1648661736)+(x%((-1421237596)+(tmp = 2053180992.3857927, tmp))))+(tmp = 38606889, tmp))<<((-241334284)%((x>>(215316122))*(tmp = 396488307, tmp))))+((tmp = -2900704565, tmp)^x))^(((1103481003.1111188)^x)-(tmp = 1304113534, tmp)))); - assertEquals(1149501440, x <<= ((x>>(tmp = 3203172843, tmp))*(tmp = -192535531, tmp))); - assertEquals(0, x ^= x); - assertEquals(0, x >>= ((tmp = 2751499787, tmp)&((tmp = 2217654798, tmp)*(tmp = -2798728014, tmp)))); - assertEquals(NaN, x /= ((((-2019592425)>>>((((-1571930240.741224)>>>((-183952981)/((((1990518443.672842)>>(((((2051371284)%(685322833.6793983))>>>(2662885938))<<(-1212029669.6675105))|((-2790877875)<<(1546643473))))<<x)-(tmp = 804296674.4579233, tmp))))-(tmp = -417759051.68770766, tmp))/((-621859758)>>>x)))&x)<<(tmp = -48558935.55320549, tmp))); - assertEquals(0, x <<= (x&x)); - assertEquals(0, x *= (x%(tmp = 301196068, tmp))); - assertEquals(398290944, x |= (((tmp = 1904146839, tmp)+(1521017178))*(-3174245888.562067))); - assertEquals(1256401076, x ^= (1566464180)); - assertEquals(149620758, x %= ((tmp = 532626355, tmp)^(tmp = -382971203, tmp))); - assertEquals(149620791, x |= (x>>x)); - assertEquals(-0.07034576194938641, x /= ((tmp = -1977313182.7573922, tmp)-x)); - assertEquals(0, x <<= x); - assertEquals(0, x &= x); - assertEquals(0, x /= ((2182424851.139966)%(((-2768516150)+x)>>>x))); - assertEquals(0, x %= (-504299638.53962016)); - assertEquals(-0, x *= (-2915134629.6909094)); - assertEquals(0, x <<= ((tmp = 952692723.402582, tmp)%(2146335996.785011))); - assertEquals(230457472, x |= ((tmp = -574776101.8681948, tmp)*(683185125))); - assertEquals(933795934, x ^= (tmp = 974395614, tmp)); - assertEquals(933801974, x ^= (x>>>((-148683729)*(((tmp = 2912596991.415531, tmp)^(-2883672328))/x)))); - assertEquals(222, x >>= (-3060224682)); - assertEquals(27, x >>>= (1429156099.1338701)); - assertEquals(754519106, x ^= (tmp = 754519129.7281355, tmp)); - assertEquals(188629776, x >>>= ((x>>>((1247267193)<<(tmp = -936228622, tmp)))%((tmp = 978604324.8236886, tmp)*((tmp = -3018953108, tmp)^(((tmp = 259650195, tmp)>>>(tmp = 2762928902.7901163, tmp))*(x>>((tmp = 787444263.5542864, tmp)/(x>>>(((-2039193776)<<(tmp = -1408159169, tmp))-(1238893783)))))))))); - assertEquals(188629775.33987066, x += ((tmp = 1040520414, tmp)/((-1576237184)|((tmp = -970083705, tmp)&(((tmp = -312062761.12228274, tmp)|(1171754278.2968853))<<(-2069846597.7723892)))))); - assertEquals(1473670, x >>>= ((tmp = 202409672, tmp)^x)); - assertEquals(2171703268900, x *= (x>>(((tmp = 840468550, tmp)&(-3208057101.2136793))/x))); - assertEquals(0, x ^= x); - assertEquals(0, x ^= (x&((tmp = 2569871408.2405066, tmp)|((tmp = -3149374622, tmp)<<(x-(x|((tmp = -821239139.1626894, tmp)>>>x))))))); - assertEquals(NaN, x /= x); - assertEquals(NaN, x %= (tmp = 1926106354, tmp)); - assertEquals(0, x >>= ((x/(-2848416))/(tmp = 2484293767, tmp))); - assertEquals(0, x <<= ((tmp = -2484137114, tmp)>>>(tmp = -887083772.8318355, tmp))); - assertEquals(0, x >>= (tmp = -2651389432, tmp)); - assertEquals(0, x ^= x); - assertEquals(1041871201, x += ((tmp = 1041871201.9272791, tmp)|(x<<(-1136959830)))); - assertEquals(651390879501530900, x *= ((tmp = 1250424964.0346212, tmp)>>x)); - assertEquals(1965815296.245636, x %= ((2650603245.655831)+((-1610821947.8640454)>>>(((878987151.6917406)*((((784630543)%(((1448720244)>>(((tmp = 3036767847, tmp)+((tmp = 1012548422, tmp)<<(1957000200)))-x))/(x>>x)))<<((tmp = 914710268, tmp)*(((x^(1559603121))<<(tmp = 3181816736, tmp))|((-1964115655)+x))))-(-1055603890)))&(946797797.0616649))))); - assertEquals(1965815296.245636, x %= (tmp = -2601038357.593118, tmp)); - assertEquals(-769384440.872302, x += (-2735199737.117938)); - assertEquals(-769384440.872302, x %= (2193123162)); - assertEquals(1, x /= x); - assertEquals(1, x -= (((x>>>(-1968465925))*((tmp = 563037904, tmp)>>((tmp = 3009534415.769578, tmp)>>((-2567240601.7038674)<<(tmp = -1258402723.4150183, tmp)))))%(3112239470.276867))); - assertEquals(1, x |= x); - assertEquals(1505461527, x ^= (tmp = 1505461526.5858076, tmp)); - assertEquals(406553877, x &= (tmp = 2558242293, tmp)); - assertEquals(406553877, x |= x); - assertEquals(-574902339, x |= ((-709809495)%(tmp = -2880884811.410611, tmp))); - assertEquals(-20281777.349363208, x %= (22184822.46602547)); - assertEquals(1, x /= x); - assertEquals(-4360732, x ^= ((x|(tmp = 3178620274, tmp))>>(((2686286888)&(((-1107223053.8716578)/(((-2955575332.3675404)+(-2770518721))|(-2705016953.640522)))-x))^((1473641110.4633303)*((((-1466496401)<<x)+x)%(1805868749.082736)))))); - assertEquals(-1158545408, x <<= ((((x/((-2710098221.691819)-(-2421462965.788145)))/(((((x>>>(tmp = 1994541591.1032422, tmp))+(tmp = -1276676679.9747126, tmp))&((tmp = 1764029634.2493339, tmp)+((x|(tmp = -3050446156, tmp))-((tmp = -9441859, tmp)/(((-2072420232)&x)*(-1003199889))))))+(tmp = -2443230628, tmp))*x))*((x&((((x|(747566933))*(((2039741506)>>>((tmp = -2456000554, tmp)>>>(-1566360933.7788877)))^((tmp = 960600745, tmp)/x)))&(x^(((-2649310348.777452)^((2224282875)-(tmp = -2129141087.3182096, tmp)))<<((x<<x)+((-1307892509.3874407)-(x|(tmp = -2831643528.9720087, tmp)))))))/(((tmp = -35502946, tmp)<<((tmp = 1091279222, tmp)>>(((-2686069468.8930416)-x)+(tmp = 367442353.2904701, tmp))))%(1218262628))))/x))^(-919079153.7857773))); - assertEquals(747, x >>>= (1229157974)); - assertEquals(747, x |= x); - assertEquals(NaN, x %= (((3086718766.4715977)*((7912648.497568846)*((-2713828337.1659327)*(-176492425.4011252))))<<(tmp = -1074475173, tmp))); - assertEquals(0, x >>>= ((((444923201)<<x)>>>(-883391420.2142565))*((((617245412)<<x)>>>x)*(-913086143.2793813)))); - assertEquals(1941802406, x ^= (tmp = -2353164890, tmp)); - assertEquals(14, x >>>= (-1600311077.4571416)); - assertEquals(-18229482703.7246, x += (((x+(-993157139.7880647))%x)*(1862419512.1781366))); - assertEquals(-14.531388114858734, x /= ((tmp = -1649072797.951641, tmp)<<x)); - assertEquals(0, x ^= x); - assertEquals(0, x >>= ((x/x)^x)); - assertEquals(2, x ^= ((-1597416259)/(-738770020))); - assertEquals(0, x >>= (tmp = -387850072.74833393, tmp)); - assertEquals(0, x >>>= ((2491085477.186817)>>(x*(((tmp = -1592498533, tmp)+(tmp = 2086841852, tmp))&(-3174019330.8288536))))); - assertEquals(0, x >>= x); - assertEquals(0, x >>>= (tmp = -3045348659.45243, tmp)); - assertEquals(-1208573479, x |= ((3086393817)-x)); - assertEquals(1460649854142163500, x *= x); - assertEquals(1588199424, x <<= (-1902076952)); - assertEquals(1586102272, x &= (tmp = 2139876091.9142454, tmp)); - assertEquals(-460908552.5528109, x -= (tmp = 2047010824.552811, tmp)); - assertEquals(-460908552.5528109, x %= (tmp = 507904117.09368753, tmp)); - assertEquals(-460908552.5528109, x %= (2749577642.527038)); - assertEquals(234012, x >>>= (-340465746.91275)); - assertEquals(0, x >>>= x); - assertEquals(0, x %= (tmp = -2601875531, tmp)); - assertEquals(0, x %= (x|(tmp = 650979981.1158671, tmp))); - assertEquals(0, x %= (tmp = -2286020987, tmp)); - assertEquals(0, x |= x); - assertEquals(0, x &= (x|((tmp = 2568101411, tmp)-(-1438002403)))); - assertEquals(0, x >>>= (1399248574)); - assertEquals(0, x %= (-1906670287.2043698)); - assertEquals(0, x >>= (1019286379.6962404)); - assertEquals(0, x |= (x/(tmp = -82583591.62643051, tmp))); - assertEquals(NaN, x %= x); - assertEquals(NaN, x *= (x^(1874776436))); - assertEquals(NaN, x -= ((-1238826797)-(-2971588236.7228813))); - assertEquals(0, x <<= (2064632559)); - assertEquals(-0.5967273958864694, x += (((tmp = 1502995019, tmp)>>x)/(-2518729707))); - assertEquals(0, x >>>= x); - assertEquals(-0, x /= (-1923030890)); - assertEquals(NaN, x %= x); - assertEquals(0, x >>= (tmp = 1081732779.9449487, tmp)); - assertEquals(-820183066, x |= ((tmp = -3169007292.4721155, tmp)|(-1912588318))); - assertEquals(0, x -= x); - assertEquals(NaN, x %= x); - assertEquals(NaN, x /= (tmp = 287181840, tmp)); - assertEquals(0, x &= (x/((tmp = -1139766051, tmp)<<(x&(tmp = 2779004578, tmp))))); - assertEquals(0, x >>= (((tmp = -1816938028, tmp)+(-224851993.3139863))*(-2933829524))); - assertEquals(0, x |= ((((tmp = 305077929.1808746, tmp)&((x-(((((tmp = 2122810346.7475111, tmp)<<(717271979))*(tmp = 256854043.72633624, tmp))%((x+(tmp = -318657223.9992106, tmp))*((1993144830)<<(2594890698.603228))))^((((tmp = 257370667, tmp)>>>((((x^(3160746820))>>>(2049640466.8116226))>>>(2543930504.7117066))^(x-x)))^(x%(964838975)))^x)))%(x*x)))>>>x)*(tmp = -46861540, tmp))); - assertEquals(747575633, x ^= ((-2406502427)-(-3154078060.3794584))); - assertEquals(0, x *= (x%x)); - assertEquals(0, x <<= (1313773705.3087234)); - assertEquals(0, x >>>= ((x+x)>>>(3068164056))); - assertEquals(-0, x *= (tmp = -1771797797, tmp)); - assertEquals(1784146970, x ^= (tmp = 1784146970, tmp)); - assertEquals(1784146970, x >>>= (tmp = -2219972320.7195597, tmp)); - assertEquals(1744830464, x <<= ((((-2769476584)-(((1798431604)>>(tmp = 1337687914.799577, tmp))>>>((-2802941943.15014)>>x)))>>>(tmp = 646033678, tmp))-x)); - assertEquals(3044433348102455300, x *= x); - assertEquals(0, x >>= ((tmp = 1592076570.1900845, tmp)-((645774223.6317859)>>x))); - assertEquals(0, x >>= (x>>>(-3045822290.1536255))); - assertEquals(-0, x *= (tmp = -2450298800.986624, tmp)); - assertEquals(0, x >>= (tmp = 1379605393, tmp)); - assertEquals(0, x &= (((x-((((tmp = 837939461.6683749, tmp)+((((-813261853.3247359)|(x&(((-2565113940)*(tmp = -2725085381.240134, tmp))|x)))%(-1457259320))-(x+((tmp = -273947066, tmp)%((1164825698.879649)>>(1653138880.3434052))))))>>>(2823967606.411492))>>>((((((((1189235604.9646997)/(tmp = -2875620103.4002438, tmp))-(tmp = -801261493, tmp))<<(((1832556579.5095325)<<x)|((tmp = -2740330665, tmp)>>(tmp = -2352814025, tmp))))-(tmp = -1445043552.99499, tmp))&(x<<(((((445325471)*(1293047043.1808558))>>>(((1901837408.5910044)-(tmp = -2349093446.5313253, tmp))>>>(tmp = 1000847053.1861948, tmp)))*(x>>>(1771853406.6567078)))>>x)))>>>x)>>>(x^((tmp = 2813422715, tmp)-(x+(-342599947)))))))&(x>>>x))*x)); - assertEquals(NaN, x %= ((tmp = -3027713526, tmp)-((((x%(((((x/((2711155710)^(((((x>>>x)%((1098599291.155015)^(((((tmp = 1855724377.8987885, tmp)/(x|x))*((-1963179786)*((x-((-1634717702)%x))<<x)))>>(2008859507))>>((tmp = 2635024299.7983694, tmp)^(tmp = -602049246, tmp)))))*(x>>x))&(tmp = -1925103609, tmp))*((tmp = 2106913531.2828505, tmp)%((tmp = -200970069, tmp)*(-2809001910.951446))))))%x)*((1990098169)>>((x<<(2303347904.2601404))%x)))|(2767962065.9846206))+(201589933.301661)))>>(((tmp = 1921071149.5140274, tmp)>>(1054558799.1731887))|x))*(x/((((-2833879637.345674)>>>(tmp = 2849099601, tmp))%x)+(x%(x%(((tmp = 1983018049, tmp)^(tmp = -2659637454, tmp))>>((-1335497229.6945198)-(x+(((((tmp = 1136612609.848967, tmp)%(2471741030.01762))<<(x|(((tmp = 1644081190.1972675, tmp)&(-1422527338))^(2379264356.265957))))/(tmp = 2979299484.1884174, tmp))/x)))))))))*((tmp = 1858298882, tmp)^((tmp = -547417134.9651439, tmp)*x))))); - assertEquals(-7664, x |= ((2286000258.825538)>>(1716389170))); - assertEquals(-1, x >>= x); - assertEquals(-1231640486.3023372, x += ((tmp = 1231640485.3023372, tmp)*x)); - assertEquals(-2463280972.6046743, x += x); - assertEquals(1746, x >>>= x); - assertEquals(1746, x >>>= (((tmp = -562546488.0669937, tmp)*((-2475357745.8508205)&((x%(821425388.8633704))%((((-2315481592.687686)&(((tmp = 3130530521.7453523, tmp)+x)-x))^(-973033390.1773088))/x))))<<x)); - assertEquals(1746, x %= (-1544973951.076033)); - assertEquals(27936, x <<= (-525441532.33816123)); - assertEquals(27936, x %= (x*((tmp = 344991423.5336287, tmp)+(-2267207281)))); - assertEquals(27, x >>>= (tmp = 1249792906, tmp)); - assertEquals(0, x >>>= (tmp = -1068989615, tmp)); - assertEquals(0, x >>>= (tmp = 347969658.92579734, tmp)); - assertEquals(-2656611892, x -= (2656611892)); - assertEquals(1944539596, x |= (((tmp = 3000889963, tmp)-x)<<((tmp = 2917390580.5323124, tmp)^(-996041439)))); - assertEquals(1944539596, x |= x); - assertEquals(-739740167.0752468, x -= ((1712009965.0752468)+(x>>((tmp = -740611560.99014, tmp)>>>((tmp = -1033267419.6253037, tmp)&(862184116.3583733)))))); - assertEquals(-1479480334.1504936, x += x); - assertEquals(-4294967296.150494, x -= (x>>>((1219235492.3661718)&(3138970355.0665245)))); - assertEquals(0, x >>= (x*x)); - assertEquals(-0, x *= ((-2202530054.6558375)-(-676578695))); - assertEquals(-0, x %= (1336025846)); - assertEquals(0, x &= x); - assertEquals(0, x /= (1759366510)); - assertEquals(630007622, x |= (630007622)); - assertEquals(-0.22460286863455903, x /= (tmp = -2804984753, tmp)); - assertEquals(1102410276.775397, x -= (-1102410277)); - assertEquals(1102410276.775397, x %= ((((-2569525203)&x)*(x|(-1932675298)))/((-2376634450)>>>(x>>>(tmp = 936937604.9491489, tmp))))); - assertEquals(33642, x >>= (3028252527)); - assertEquals(2181106522.688034, x -= (-2181072880.688034)); - assertEquals(-2113861630, x &= (2523921542)); - assertEquals(-2147483646, x &= (-1996601566.9370148)); - assertEquals(-2147483648, x &= (tmp = -665669175.1968856, tmp)); - assertEquals(-2858673260.1367273, x -= (tmp = 711189612.1367272, tmp)); - assertEquals(350657, x >>= (tmp = -170243892.25474262, tmp)); - assertEquals(-0.0001405571562140975, x /= (-2494764474.7868776)); - assertEquals(0, x ^= x); - assertEquals(NaN, x /= ((x&(-2041236879))*((tmp = -2182530229, tmp)^((1274197078)*x)))); - assertEquals(0, x |= (x&(x-(1794950303)))); - assertEquals(1222105379, x |= (tmp = 1222105379, tmp)); - assertEquals(729884484, x ^= (tmp = 1666645607.6907792, tmp)); - assertEquals(729884484, x %= (tmp = -2896922082, tmp)); - assertEquals(8768, x &= ((tmp = 358940932, tmp)>>>(3159687631.3308897))); - assertEquals(1892384495, x |= (-2402591569)); - assertEquals(1892470533, x += ((((x^(-2266612043))>>>(tmp = -531009952, tmp))<<(x>>>((-1365315963.5698428)>>>((x+((-3168207800.184341)-(tmp = 1776222157.609917, tmp)))+(-1588857469.3596382)))))>>>x)); - assertEquals(143587205, x += (tmp = -1748883328, tmp)); - assertEquals(0, x ^= x); - assertEquals(0, x >>= (tmp = 2334880462.3195543, tmp)); - assertEquals(0, x &= ((tmp = 1819359625.4396145, tmp)|(tmp = -1323513565, tmp))); - assertEquals(-1102259874, x ^= (3192707422)); - assertEquals(2567457772588852700, x *= (-2329267202)); - assertEquals(-16783687, x |= ((-2212476227.060922)^(378973700.78452563))); - assertEquals(4278183609, x >>>= ((((((((tmp = 1766363150.197206, tmp)*(-2774552871))%x)>>>((3071429820)&((((((tmp = 351068445.27642524, tmp)<<(tmp = 2646575765, tmp))^(806452682))<<((x>>>(-2217968415.505327))<<(1564726716)))|x)-(tmp = -3110814468.9023848, tmp))))+x)^x)>>>(tmp = -617705282.0788529, tmp))>>>x)); - assertEquals(4314933530, x -= ((1032195469.789219)|(tmp = -448053861.9531791, tmp))); - assertEquals(9709850, x %= (((tmp = -3056286252.5853324, tmp)*x)&x)); - assertEquals(9709850, x %= (tmp = -2596800940, tmp)); - assertEquals(2655489828.9461126, x -= (tmp = -2645779978.9461126, tmp)); - assertEquals(369266212, x &= (((335712316.24874604)|(tmp = 33648215, tmp))-((x/(2639848695))<<((-499681175)<<(-2490554556))))); - assertEquals(-2147483648, x <<= (-834465507)); - assertEquals(1073741824, x >>>= (((tmp = 3018385473.1824775, tmp)>>(x*(-2574502558.216812)))|(((tmp = -1742844828, tmp)*(1698724455))&x))); - assertEquals(-270818218, x += (-1344560042)); - assertEquals(360710144, x <<= x); - assertEquals(0, x <<= (tmp = 612718075, tmp)); - assertEquals(0, x <<= x); - assertEquals(-0, x /= (tmp = -1922423684, tmp)); - assertEquals(-0, x *= ((((tmp = 741806213.3264687, tmp)%(-711184803.2022421))+((tmp = -3209040938, tmp)&(525355849.044886)))&(x<<(tmp = -698610297, tmp)))); - assertEquals(0, x <<= (-482471790)); - assertEquals(0, x &= ((-921538707)/(tmp = -482498765.988616, tmp))); - assertEquals(0, x ^= (x^x)); - assertEquals(-351721702, x ^= (-351721702.8850286)); - assertEquals(726242219625599900, x -= ((2064820612)*x)); - assertEquals(1452484439251199700, x += x); - assertEquals(2.52318299412847e-15, x %= ((((x<<((2508143285)+x))>>(-2493225905.011774))%(1867009511.0792103))/((((x<<(2542171236))>>((x|x)&(tmp = -384528563, tmp)))+((-1168755343)*(1731980691.6745195)))+(tmp = -1608066022.71164, tmp)))); - assertEquals(79905008, x += ((((-2702081714.590131)&(x+(tmp = -1254725471.2121565, tmp)))*(3088309981))%(((tmp = 1476844981.1453142, tmp)|((((tmp = -1243556934.7291331, tmp)%x)^(-1302096154))+((660489180)/(tmp = -681535480.8642154, tmp))))^(tmp = -8410710, tmp)))); - assertEquals(1215822204, x ^= ((-3008054900)>>>(tmp = -1990206464.460693, tmp))); - assertEquals(-394790532, x |= ((((-1334779133.2038574)+(tmp = -1407958866.832946, tmp))<<(1699208315))-(((x^(x%x))<<(3216443))>>(x+((((2576716374.3081336)|((tmp = 2316167191.348064, tmp)&((51086351.20208645)&((x|(tmp = -357261999, tmp))^(x/x)))))*(-45901631.10155654))*(((-439588079)>>>((-2358959768.7634916)|(1613636894.9373643)))+(((-908627176)<<x)%(x%((-1669567978)>>>((x>>(1289400876))+(tmp = 2726174270, tmp))))))))))); - assertEquals(-0.17717467607696327, x /= (2228255982.974148)); - assertEquals(-1905616474, x ^= (tmp = 2389350822.851587, tmp)); - assertEquals(-0, x %= x); - assertEquals(2818124981.508915, x -= (-2818124981.508915)); - assertEquals(-1476842315, x |= x); - assertEquals(73408564, x &= (-3147390604.3453345)); - assertEquals(70, x >>>= x); - assertEquals(1, x >>= x); - assertEquals(3086527319.899181, x *= (3086527319.899181)); - assertEquals(-145, x >>= x); - assertEquals(-145, x %= (tmp = -2500421077.3982406, tmp)); - assertEquals(-1, x >>= (tmp = -2970678326.712191, tmp)); - assertEquals(-1, x %= ((tmp = -535932632.4668834, tmp)+(((-1226598339.347982)<<((tmp = 616949449, tmp)/(tmp = 2779464046, tmp)))/(214578501.67984307)))); - assertEquals(1, x *= x); - assertEquals(1, x >>= ((tmp = 11080208, tmp)<<(460763913))); - assertEquals(-1.8406600706723492e-19, x /= ((tmp = -2334126306.1720915, tmp)*(tmp = 2327566272.5901165, tmp))); - assertEquals(856681434186007200, x -= ((tmp = -2286974992.8133907, tmp)*(374591518))); - assertEquals(3126084224, x >>>= x); - assertEquals(-1160460669, x |= (tmp = 181716099, tmp)); - assertEquals(873988096, x <<= (tmp = 406702419, tmp)); - assertEquals(0, x <<= ((tmp = 802107965.4672925, tmp)-((tmp = 1644174603, tmp)>>((tmp = 604679952, tmp)+(tmp = -515450096.51425123, tmp))))); - assertEquals(NaN, x %= ((x>>(tmp = 2245570378, tmp))*(tmp = 1547616585, tmp))); - assertEquals(NaN, x /= ((tmp = -776657947.0382309, tmp)&(tmp = 163929332.28270507, tmp))); - assertEquals(NaN, x *= (tmp = 243725679.78916526, tmp)); - assertEquals(NaN, x /= (x>>x)); - assertEquals(0, x <<= ((tmp = -1293291295.5735884, tmp)%(((((63309078)>>>x)&(x&(-2835108260.025297)))+x)>>>(-1317213424)))); - assertEquals(0, x *= ((((tmp = -1140319441.0068483, tmp)*(tmp = 2102496185, tmp))&(-2326380427))<<(tmp = -2765904696, tmp))); - assertEquals(0, x /= (tmp = 2709618593, tmp)); - assertEquals(0, x >>= (-1753085095.7670164)); - assertEquals(1766381484, x |= (-2528585812)); - assertEquals(1766381484, x %= (2735943476.6363373)); - assertEquals(1766381484, x %= (x*(tmp = 2701354268, tmp))); - assertEquals(-2147483648, x <<= (-323840707.4949653)); - assertEquals(4611686018427388000, x *= (x<<x)); - assertEquals(0, x <<= (3066735113)); - assertEquals(0, x ^= ((((x*x)^(tmp = -2182795086.39927, tmp))<<(x^(tmp = 1661144992.4371827, tmp)))<<((((-2885512572.176741)*(tmp = 609919485, tmp))|(tmp = 929399391.0790694, tmp))>>>((((((((((399048996)>>((-107976581.61751771)>>>x))|(((-1502100015)<<(tmp = -1108852531.9494338, tmp))&(x/(tmp = -3198795871.7239237, tmp))))+((-2627653357)>>x))>>>x)*(1066736757.2718519))%(tmp = 1326732482.201604, tmp))/(tmp = 2513496019.814191, tmp))>>>((1694891519)>>>(-2860217254.378931)))<<(tmp = 31345503, tmp))))); - assertEquals(0, x ^= (x/((-2556481161)>>>(x/(x%(x&(1302923615.7148068))))))); - assertEquals(NaN, x /= x); - assertEquals(NaN, x += (tmp = 846522031, tmp)); - assertEquals(0, x >>= (x+(-1420249556.419045))); - assertEquals(0, x ^= (((x%(-1807673170))&x)-x)); - assertEquals(-3484.311990686845, x -= ((((((-510347602.0068991)>>>x)<<((tmp = 1647999950, tmp)&(((305407727)>>((1781066601.791009)&x))<<((tmp = -998795238, tmp)%(((x/x)+x)<<(((2586995491.434947)<<x)-((((tmp = 545715607.9395425, tmp)*x)>>>x)>>>(((((2332534960.4595165)^(-3159493972.3695474))<<(tmp = 867030294, tmp))|(2950723135.753855))^(((3150916666)<<x)>>((tmp = 414988690, tmp)|((tmp = -1879594606, tmp)/(tmp = 1485647336.933429, tmp))))))))))))>>(tmp = -2676293177, tmp))%(617312699.1995015))/((((tmp = -1742121185, tmp)^((((x&x)<<(tmp = 698266916, tmp))/(-1860886248))+((-213304430)%((((((-2508973021.1333447)+(tmp = 2678876318.4903, tmp))&(tmp = -43584540, tmp))-x)^(-2251323850.4611115))-x))))>>>(tmp = 2555971284, tmp))%((((tmp = 16925106, tmp)^x)&x)|((x/((x|(tmp = -2787677257.125139, tmp))<<(-853699567)))+(tmp = -1721553520, tmp)))))); - assertEquals(-447873933.26863855, x += (-447870448.9566479)); - assertEquals(200591060101520900, x *= x); - assertEquals(200591062202483420, x -= (-2100962536)); - assertEquals(-5.261023346568228e+24, x *= ((tmp = -419641692.6377077, tmp)>>(tmp = -224703100, tmp))); - assertEquals(1269498660, x |= (195756836)); - assertEquals(1269498660, x |= x); - assertEquals(1269498660, x |= x); - assertEquals(-37.75978948486164, x /= (((tmp = -595793780, tmp)+((tmp = 2384365752, tmp)>>>(1597707155)))|((968887032)^(tmp = 2417905313.4337964, tmp)))); - assertEquals(-37.75978948486164, x %= (tmp = -1846958365.291661, tmp)); - assertEquals(1102319266.6421175, x += (1102319304.401907)); - assertEquals(-1664202255175155200, x -= ((x^(tmp = 407408729, tmp))*x)); - assertEquals(-752874653, x ^= (tmp = 314673507, tmp)); - assertEquals(-72474761, x |= (tmp = -2538726025.8884344, tmp)); - assertEquals(-72474761, x |= x); - assertEquals(-122849418, x += ((tmp = -2332080457, tmp)|(((((30496388.145492196)*(((-1654329438.451212)|(-2205923896))&(x>>(tmp = -1179784444.957002, tmp))))&(tmp = 319312118, tmp))*(651650825))|(((-2305190283)|x)>>>(-428229803))))); - assertEquals(994, x >>>= x); - assertEquals(614292, x *= (((((2565736877)/((tmp = 649009094, tmp)>>>(((x>>>(2208471260))>>(x>>>x))%x)))&(tmp = 357846438, tmp))<<(tmp = -2175355851, tmp))%x)); - assertEquals(1792008118, x |= (tmp = 1791924774.5121183, tmp)); - assertEquals(1246238208, x &= (tmp = 1264064009.9569638, tmp)); - assertEquals(-88877082, x ^= (2969289190.285704)); - assertEquals(0.044923746573582474, x /= ((tmp = -3057438043, tmp)^(-1009304907))); - assertEquals(0, x <<= ((-828383918)-((((x>>(734512101))*(tmp = -3108890379, tmp))-(x|((tmp = 3081370585.3127823, tmp)^((-271087194)-(x/(tmp = -2777995324.4073873, tmp))))))%x))); - assertEquals(1604111507.3365753, x -= (-1604111507.3365753)); - assertEquals(-1721314970, x ^= (tmp = -956686859, tmp)); - assertEquals(-102247425, x |= (tmp = -2535095555, tmp)); - assertEquals(-102247425, x %= (-955423877)); - assertEquals(1053144489850425, x *= (((tmp = 1583243590.9550207, tmp)&(1356978114.8592746))|(tmp = -10299961.622774363, tmp))); - assertEquals(-0.0043728190668037336, x /= ((-1196259252.435701)*(((-689529982)|(tmp = -1698518652.4373918, tmp))<<x))); - assertEquals(-2, x ^= (((x+(tmp = 2961627388, tmp))>>(tmp = 231666110.84104693, tmp))|x)); - assertEquals(-1, x >>= (tmp = -83214419.92958307, tmp)); - assertEquals(-1, x %= (-1303878209.6288595)); - assertEquals(2944850457.5213213, x -= (tmp = -2944850458.5213213, tmp)); - assertEquals(-1.6607884436053055, x /= (-1773164107)); - assertEquals(-0.6607884436053055, x %= ((x>>(1240245489.8629928))%(tmp = -3044136221, tmp))); - assertEquals(-0, x *= ((x*x)>>>((1069542313.7656753)+x))); - assertEquals(0, x >>>= (tmp = -202931587.00212693, tmp)); - assertEquals(-0, x *= (-375274420)); - assertEquals(0, x |= ((x/(((tmp = -876417141, tmp)*(x>>>x))&(-2406962078)))<<x)); - assertEquals(0, x &= ((tmp = -650283599.0780096, tmp)*(tmp = 513255913.34108484, tmp))); - assertEquals(3027255453.458466, x += (3027255453.458466)); - assertEquals(-12568623413253943000, x *= (((x-(198689694.92141533))|x)-x)); - assertEquals(-12568623410285185000, x -= (tmp = -2968758030.3694654, tmp)); - assertEquals(-2008903680, x &= (3111621747.7679076)); - assertEquals(-110045263.26583672, x += (tmp = 1898858416.7341633, tmp)); - assertEquals(15964, x >>>= (1141042034)); - assertEquals(31928, x += x); - assertEquals(0, x ^= x); - assertEquals(-1159866377, x |= (-1159866377)); - assertEquals(0, x ^= x); - assertEquals(3072699529.4306993, x -= (tmp = -3072699529.4306993, tmp)); - assertEquals(1, x /= x); - assertEquals(-1471195029, x |= (2823772267.429641)); - assertEquals(-4152937108, x += (-2681742079)); - assertEquals(142030188, x |= x); - assertEquals(270, x >>= (tmp = 1013826483, tmp)); - assertEquals(0, x >>>= (529670686)); - assertEquals(-2912300367, x -= (2912300367)); - assertEquals(2213791134963007500, x *= (x<<((((-3214746140)>>(tmp = -588929463, tmp))+((tmp = -3084290306, tmp)>>x))>>x))); - assertEquals(2213791133466809900, x -= (tmp = 1496197641, tmp)); - assertEquals(69834416, x >>>= (x|(((2755815509.6323137)^(x%(((x*((((tmp = 375453453, tmp)<<(x*x))>>(tmp = -973199642, tmp))*x))>>((tmp = -356288629, tmp)>>(tmp = 2879464644, tmp)))<<((((1353647167.9291127)>>>(x/x))<<((2919449101)/(2954998123.5529594)))^x))))&((-2317273650)>>>(tmp = 34560010.71060455, tmp))))); - assertEquals(69834416, x >>>= (x^(-2117657680.8646245))); - assertEquals(2217318064, x -= ((tmp = 2035883891, tmp)<<(tmp = -1884739265, tmp))); - assertEquals(-1272875686, x ^= (tmp = 805889002.7165648, tmp)); - assertEquals(-1272875686, x >>= (x&(((1750455903)*x)>>((722098015)%((tmp = 1605335626, tmp)>>(tmp = -565369634, tmp)))))); - assertEquals(-1274351316, x -= (x>>>((tmp = 2382002632, tmp)-((tmp = -2355012843, tmp)+(1465018311.6735773))))); - assertEquals(-2982908522.4418216, x -= ((tmp = 1635549038.4418216, tmp)+(((1952167017.720186)&((tmp = -2284822073.1002254, tmp)>>(-1403893917)))%(tmp = 655347757, tmp)))); - assertEquals(312, x >>>= x); - assertEquals(1248, x <<= (2376583906)); - assertEquals(0, x ^= x); - assertEquals(0, x *= ((((tmp = 1914053541.881434, tmp)>>>(tmp = 1583032186, tmp))>>>(-2511688231))%(tmp = -2647173031, tmp))); - assertEquals(0, x >>>= (tmp = -2320612994.2421227, tmp)); - assertEquals(0, x %= (((x+(tmp = -720216298.5403998, tmp))<<(414712685))>>(tmp = 480416588, tmp))); - assertEquals(0, x >>= ((((3039442014.271272)<<x)%(-2402430612.9724464))&((-2141451461.3664773)%((x>>(1361764256))/((tmp = -1723952801.9320493, tmp)%(477351810.2485285)))))); - assertEquals(-0, x /= (tmp = -1627035877, tmp)); - assertEquals(0, x >>>= (tmp = 1745193212, tmp)); - assertEquals(0, x >>>= (2309131575)); - assertEquals(NaN, x %= (((x*(tmp = -1730907131.6124666, tmp))%((((1481750041)|(x>>((((x>>>(tmp = 3128156522.5936565, tmp))/(tmp = -1277222645.9880452, tmp))^(tmp = -2327254789, tmp))+x)))>>>(-1161176960))>>>(tmp = 3135906272.5466847, tmp)))*(((((-2230902834.464362)^(1822893689.8183987))+(((tmp = 1597326356, tmp)/(x&((tmp = -3044163063.587389, tmp)>>(tmp = 2844997555, tmp))))%(x^x)))>>((x|x)/x))^(2634614167.2529745)))); - assertEquals(0, x &= (3081901595)); - assertEquals(0, x &= (-2453019214.8914948)); - assertEquals(0, x &= x); - assertEquals(0, x >>>= (-596810618.3666217)); - assertEquals(0, x >>= (((908276623)|x)/x)); - assertEquals(0, x ^= x); - assertEquals(958890056, x |= (tmp = 958890056.474458, tmp)); - assertEquals(1325436928, x <<= (tmp = -2474326583, tmp)); - assertEquals(711588532333838300, x *= ((-148161646.68183947)<<(tmp = -1149179108.8049204, tmp))); - assertEquals(0, x ^= (((2862565506)%x)/(tmp = -2865813112, tmp))); - assertEquals(-2064806628, x += (((tmp = -2677361175.7317276, tmp)/((817159440)>>>(tmp = 1895467706, tmp)))^(x|(tmp = -2309094859, tmp)))); - assertEquals(-69806982479424, x *= ((x&(tmp = 2857559765.1909904, tmp))&(-3166908966.754988))); - assertEquals(-430255744, x %= ((((((-2968574724.119535)<<x)<<((tmp = 1603913671, tmp)%((-1495838556.661653)^(tmp = 1778219751, tmp))))*(-400364265))<<((((1607866371.235576)-(1961740136))|(1259754297))&(tmp = -1018024797.1352971, tmp)))^x)); - assertEquals(6.828637393208647e-7, x /= (x*(tmp = 1464421, tmp))); - assertEquals(0, x &= x); - assertEquals(-0, x *= (((tmp = -2510016276, tmp)-(2088209546))<<((tmp = -1609442851.3789036, tmp)+(tmp = 1919930212, tmp)))); - assertEquals(-0, x %= (tmp = 1965117998, tmp)); - assertEquals(-290294792.53186846, x += ((tmp = -2361555894.5318685, tmp)%(2071261102))); - assertEquals(-70873, x >>= (tmp = 2206814124, tmp)); - assertEquals(-141746, x += x); - assertEquals(-141733.9831459089, x -= (((tmp = -806523527, tmp)>>>(tmp = 1897214891, tmp))/x)); - assertEquals(-141733.9831459089, x %= ((tmp = 1996295696, tmp)<<(tmp = 3124244672, tmp))); - assertEquals(141733.9831459089, x /= (x>>(2688555704.561076))); - assertEquals(3196954517.3075542, x -= (tmp = -3196812783.3244085, tmp)); - assertEquals(-19929155, x |= (((x|x)+x)^((tmp = 391754876, tmp)-(((((((tmp = -3051902902.5100636, tmp)*(x/(1546924993)))|(tmp = 1494375949, tmp))/((((-795378522)/(tmp = 509984856, tmp))>>>(tmp = -106173186, tmp))+x))|x)|(1916921307))>>>x)))); - assertEquals(1279271449, x &= ((tmp = 1289446971, tmp)&(tmp = 1836102619, tmp))); - assertEquals(17876992, x <<= (-207633461)); - assertEquals(0, x >>= (tmp = -903885218.9406946, tmp)); - assertEquals(0, x >>>= x); - assertEquals(-2999, x -= (((754533336.2183633)%(tmp = 557970276.0537136, tmp))>>(tmp = -1171045520, tmp))); - assertEquals(-0.000003020470363504361, x /= (tmp = 992891715.2229724, tmp)); - assertEquals(1, x /= x); - assertEquals(0.45768595820301217, x %= ((tmp = 673779031, tmp)/(tmp = -1242414872.3263657, tmp))); - assertEquals(-980843052.1872087, x += (tmp = -980843052.6448946, tmp)); - assertEquals(-Infinity, x /= ((((tmp = 317747175.8024508, tmp)&(x&(((tmp = 1632953053, tmp)>>x)/x)))%x)/(3145184986))); - assertEquals(0, x &= (x<<x)); - assertEquals(0, x ^= (x-((2969023660.5619783)/x))); - assertEquals(0, x *= x); - assertEquals(NaN, x %= (x/(((x-x)/((tmp = -1622970458.3812745, tmp)-(1626134522)))&((((((tmp = 1384729039.4149384, tmp)^(x%(tmp = -2736365959, tmp)))+((-1465172172)%x))>>(tmp = -1839184810.2603343, tmp))^(((tmp = 1756918419, tmp)>>>(x+(x%(tmp = -2011122996.9794662, tmp))))<<(-3026600748.902623)))*((tmp = -2040286580, tmp)>>(-2899217430.655154)))))); - assertEquals(0, x >>>= (tmp = 2100066003.3046467, tmp)); - assertEquals(1362012169, x ^= (tmp = 1362012169, tmp)); - assertEquals(1476312683, x |= ((457898409)>>>(-3079768830.723079))); - assertEquals(1441711, x >>>= (905040778.7770994)); - assertEquals(2078530607521, x *= x); - assertEquals(-208193103, x |= ((tmp = -241750000, tmp)^x)); - assertEquals(745036378, x ^= (((tmp = -1737151062.4726632, tmp)<<x)|(tmp = -1900321813, tmp))); - assertEquals(1744830464, x <<= x); - assertEquals(212992, x >>>= ((1210741037)-(x-(x>>>((x^(-1273817997.0036907))+((2401915056.5471)%(x<<(tmp = 1696738364.277438, tmp)))))))); - assertEquals(0.0001604311565639742, x /= (1327622418)); - assertEquals(0, x <<= (tmp = 166631979.34529006, tmp)); - assertEquals(0, x *= ((((tmp = 657814984, tmp)/(((-831055031)>>>(1531978379.1768064))|((tmp = 2470027754.302619, tmp)^(-223467597))))/(tmp = 1678697269.468965, tmp))&(tmp = -1756260071.4360774, tmp))); - assertEquals(-2049375053, x ^= (tmp = -2049375053, tmp)); - assertEquals(-1879109889, x |= (tmp = -1963586818.0436726, tmp)); - assertEquals(718239919, x ^= (tmp = -1523550640.1925273, tmp)); - assertEquals(-1361085185, x |= (-1939964707)); - assertEquals(2, x >>>= (1864136030.7395325)); - assertEquals(0.794648722849246, x %= ((-668830999)*(((-2227700170.7193384)%(x^(x>>>x)))/(tmp = 399149892, tmp)))); - assertEquals(0, x >>= x); - assertEquals(0, x *= x); - assertEquals(0, x &= ((tmp = -2389008496.5948563, tmp)|((((tmp = -2635919193.905919, tmp)*((-64464127)<<(2136112830.1317358)))>>((184057979)*(-1204959085.8362718)))>>>(-442946870.3341484)))); - assertEquals(-243793920, x -= ((tmp = 3002998032, tmp)<<((537875759)<<x))); - assertEquals(0, x -= x); - assertEquals(0, x *= ((((66852616.82442963)/((((x^x)&(2975318321.223734))+(((tmp = -1388210811.1249495, tmp)^((((-680567297.7620237)%(x-(tmp = -672906716.4672911, tmp)))-x)*(tmp = -1452125821.0132627, tmp)))*(((2770387154.5427895)%x)%x)))-x))<<((-1481832432.924325)>>(tmp = 3109693867, tmp)))>>>(x/(((((((tmp = 928294418, tmp)^(((-1018314535)/(tmp = -3167523001, tmp))%((((((tmp = -1639338126, tmp)-(tmp = -2613558829, tmp))&x)/x)%(tmp = 513624872, tmp))/((-520660667)&x))))*(2620452414))^((tmp = 2337189239.5949326, tmp)*(3200887846.7954993)))>>>((tmp = 1173330667, tmp)^x))<<x)>>(((tmp = -2475534594.982338, tmp)*x)|x))))); - assertEquals(0, x /= (2520915286)); - assertEquals(0, x &= x); - assertEquals(0, x >>= (-1908119327)); - assertEquals(0, x >>>= (tmp = 549007635, tmp)); - assertEquals(0, x >>= (-994747873.8117285)); - assertEquals(0, x <<= ((((x>>>((-3084793026.846681)%((1107295502)&(tmp = -296613957.8133817, tmp))))&((19637717.166736007)/(x+x)))+x)/(-2479724242))); - assertEquals(-695401420, x += (-695401420)); - assertEquals(-695401394, x += (x>>>(tmp = 2340097307.6556053, tmp))); - assertEquals(-555745552, x -= (x|(-483851950.68644))); - assertEquals(-17825792, x <<= x); - assertEquals(-17825792, x >>= x); - assertEquals(-17, x %= ((tmp = 1799361095, tmp)|((x>>(((-1201252592)<<((((543273288)+(-2859945716.606924))*x)<<((-3030193601)<<(3081129914.9217644))))|((1471431587.981769)>>(-246180750))))|(((tmp = -2689251055.1605787, tmp)>>x)&(((2131333169)^x)-((tmp = -951555489, tmp)/x)))))); - assertEquals(-8912896, x <<= (1146444211)); - assertEquals(2854567584, x += (tmp = 2863480480, tmp)); - assertEquals(426232502.24151134, x %= (1214167540.8792443)); - assertEquals(1806802048, x ^= (-2368317898)); - assertEquals(432537600, x <<= (tmp = 2831272652.589364, tmp)); - assertEquals(432537600, x %= (((1713810619.3880467)-x)&((-2853023009.553296)&(tmp = -3158798098.3355417, tmp)))); - assertEquals(-509804066, x += (tmp = -942341666, tmp)); - assertEquals(-509804066, x %= (-732349220)); - assertEquals(259900185710132350, x *= x); - assertEquals(711598501.7021885, x %= ((tmp = 2020395586.2280731, tmp)-(tmp = 3031459563.1386633, tmp))); - assertEquals(711598503.0618857, x += ((tmp = 967558548.4141241, tmp)/x)); - assertEquals(711598503, x &= x); - assertEquals(711598503, x ^= (((((1609355669.1963444)+((((tmp = -2660082403.258437, tmp)+(tmp = -235367868, tmp))&(x/x))*((-2595932186.69466)|((tmp = -3039202860, tmp)<<x))))>>>(-951354869))-((tmp = -691482949.6335375, tmp)/(tmp = -1735502400, tmp)))/(tmp = 798440377, tmp))); - assertEquals(558262613882868500, x *= (784519095.4299527)); - assertEquals(558262611968479000, x -= ((((tmp = 1039039153.4026555, tmp)/(-3138845051.6240187))*(tmp = 633557994, tmp))&(1981507217))); - assertEquals(1170427648, x |= ((x>>((((-1086327124)%((tmp = -1818798806.368613, tmp)^(tmp = 2183576654.9959817, tmp)))>>x)&((((((tmp = 1315985464.0330539, tmp)&(2774283689.333836))%x)*((2722693772.8994813)&(tmp = -2720671984.945404, tmp)))^(tmp = -76808019, tmp))<<((tmp = 685037799.2336662, tmp)^((tmp = 1057250849, tmp)&(tmp = 1469205111.2989025, tmp))))))+(x*(((tmp = 448288818.47173154, tmp)-(-2527606231))-((8387088.402292728)>>x))))); - assertEquals(558, x >>>= (tmp = 2732701109, tmp)); - assertEquals(558, x &= x); - assertEquals(-0.00015855057024653912, x /= ((x+(((tmp = -1963815633, tmp)-(x>>x))-((x|x)>>x)))/x)); - assertEquals(1.3458861596445712e-13, x /= (-1178038492.4116466)); - assertEquals(0, x <<= (-104550232)); - assertEquals(0, x >>>= (x>>(tmp = -255275244.12613606, tmp))); - assertEquals(0, x >>= x); - assertEquals(375, x |= ((1576819294.6991196)>>>(-2570246122))); - assertEquals(96000, x <<= ((2252913843.0150948)>>>(-49239716))); - assertEquals(6144000, x <<= ((((tmp = -2478967279, tmp)&((x%((tmp = -1705332610.8018858, tmp)+(x+(tmp = 590766349, tmp))))<<(tmp = 1759375933, tmp)))+(-2024465658.849834))&(1564539207.3650014))); - assertEquals(-1149239296, x <<= (1862803657.7241006)); - assertEquals(-9, x >>= (((tmp = 463306384.05696774, tmp)^x)|((x>>((((-2098070856.799663)<<((-2054870274.9012866)<<(((-2582579691)/(829257170.0266814))<<(((((tmp = -1753535573.7074275, tmp)<<((x>>(-197886116))%((2487188445)%(tmp = 2465391564.873364, tmp))))&(((tmp = -500069832, tmp)&(tmp = 3016637032, tmp))&((tmp = 2525942628, tmp)|((((-920996215)|x)^((((tmp = -687548533.419106, tmp)&(1423222636.058937))<<((tmp = -1096532228, tmp)>>((((tmp = -3124481449.2740726, tmp)^(tmp = 2724328271.808975, tmp))>>x)*x)))+(-1661789589.5808442)))+(((x*(tmp = -1224371664.9549093, tmp))^((tmp = 3202970043, tmp)^x))/(tmp = 131494054.58501709, tmp))))))|(((tmp = -1654136720, tmp)<<x)>>((1652979932.362416)-(tmp = -863732721, tmp))))^(-113307998)))))^(-90820449.91417909))*((tmp = 641519890, tmp)-((((x<<(tmp = 2349936514.071881, tmp))*(2324420443.587892))^x)%(x<<((tmp = -1838473742, tmp)/(((-3154172718.4274178)-x)+x)))))))|(x>>>((tmp = 2096024376.4308293, tmp)<<x))))); - assertEquals(81, x *= x); - assertEquals(81, x &= x); - assertEquals(81, x %= (tmp = 2223962994, tmp)); - assertEquals(81, x ^= ((x/(((-1606183420.099584)|(-1242175583))&(((x|((tmp = 828718431.3311573, tmp)/(x>>x)))+(((-2207542725.4531174)^(x*x))*(tmp = 551575809.955105, tmp)))/x)))&((x>>x)&x))); - assertEquals(81, x %= (tmp = 279598358.6976975, tmp)); - assertEquals(101.72338484518858, x -= (((tmp = 2452584495.44003, tmp)%((-1181192721)+(((x>>(((x&x)^x)+((x>>>((x+(-2472793823.57181))/(((2854104951)>>(-1208718359.6554642))>>>(1089411895.694705))))/(x|(-2821482890.1780205)))))^(-1786654551))/(-29404242.70557475))))/(((-4352531)<<((-1227287545)<<x))%(-2558589438)))); - assertEquals(101.72338484518858, x %= (-943645643)); - assertEquals(0, x -= x); - assertEquals(0, x >>>= (-2440404084)); - assertEquals(0, x >>= (tmp = 1029680958.405923, tmp)); - assertEquals(0, x >>>= (1213820208.7204895)); - assertEquals(-0, x /= (tmp = -103093683, tmp)); - assertEquals(0, x >>>= (-2098144813)); - assertEquals(-0, x /= (((-3087283334)+(((tmp = -3129028112.6859293, tmp)%(tmp = 2413829931.1605015, tmp))-(2578195237.8071446)))|x)); - assertEquals(-15, x |= ((((-178926550.92823577)>>>(-965071271))^((tmp = -484633724.7237625, tmp)-(tmp = 473098919.1486404, tmp)))>>((-2264998310.203265)%(tmp = -499034672, tmp)))); - assertEquals(0, x ^= x); - assertEquals(0, x >>= (((-3207915976.698118)<<(tmp = 2347058630, tmp))|(tmp = -2396250098.559627, tmp))); - assertEquals(NaN, x %= x); - assertEquals(NaN, x *= (621843222)); - assertEquals(0, x >>= (((-2409032228.7238913)*x)-(tmp = -887793239, tmp))); - assertEquals(NaN, x /= x); - assertEquals(1193017666, x ^= (tmp = 1193017666, tmp)); - assertEquals(3.5844761899682753, x /= (tmp = 332829011.206393, tmp)); - assertEquals(-888572929, x |= (((tmp = 1032409228, tmp)+(tmp = -1920982163.7853453, tmp))+x)); - assertEquals(-1817051951333455600, x *= (((-1506265102)^(tmp = -775881816, tmp))-(tmp = -32116372.59181881, tmp))); - assertEquals(-1638479616, x |= x); - assertEquals(-114489, x %= (((tmp = -247137297.37866855, tmp)>>>((((((-322805409)-x)^x)>>((((((((x>>>(tmp = -900610424.7148039, tmp))/(-1155208489.6240904))|((-2874045803)|(tmp = 3050499811, tmp)))+(x/((tmp = -613902712, tmp)^((-982142626.2892077)*((((tmp = -3201753245.6026397, tmp)|((1739238762.0423079)^x))/(243217629.47237313))^((tmp = -11944405.987132788, tmp)/(tmp = 2054031985.633406, tmp)))))))*(tmp = 2696108952.450961, tmp))*x)>>>(tmp = 3058430643.0660386, tmp))>>(x<<x)))>>(-984468302.7450335))%((tmp = 1302320585.246251, tmp)>>>x)))%(tmp = -2436842285.8208156, tmp))); - assertEquals(2047, x >>>= (2380161237)); - assertEquals(0, x >>= x); - assertEquals(0, x &= (tmp = 980821012.975836, tmp)); - assertEquals(-1090535537, x -= ((-3064511503.1214876)&((tmp = -2598316939.163751, tmp)<<((tmp = -969452391.8925576, tmp)*x)))); - assertEquals(-2181071074, x += x); - assertEquals(1, x >>>= ((2902525386.449062)>>x)); - assertEquals(1, x += (x&(tmp = -2643758684.6636515, tmp))); - assertEquals(1, x %= ((tmp = -2646526891.7004848, tmp)/x)); - assertEquals(448735695.7888887, x -= (tmp = -448735694.7888887, tmp)); - assertEquals(1, x /= x); - assertEquals(1, x >>= ((-480385726)<<(2641021142))); - assertEquals(1, x %= (375099107.9200462)); - assertEquals(1, x >>= (((x&((tmp = -2402469116.9903326, tmp)%(tmp = -2862459555.860298, tmp)))*(tmp = -2834162871.0586414, tmp))%(((x>>>(tmp = 721589907.5073895, tmp))*(x^x))%(((tmp = 2844611489.231776, tmp)^((983556913)&(906035409.6693488)))^(x>>>(1239322375)))))); - assertEquals(268435456, x <<= (tmp = 178807644.80966163, tmp)); - assertEquals(44, x %= ((tmp = 2527026779.081539, tmp)>>>(2736129559))); - assertEquals(88, x += x); - assertEquals(0, x >>>= x); - assertEquals(0, x -= x); - assertEquals(-1523121602, x |= (2771845694)); - assertEquals(-2, x >>= x); - assertEquals(-4, x += x); - assertEquals(-256, x <<= (((2522793132.8616533)>>(tmp = 77232772.94058788, tmp))+(3118669244.49152))); - assertEquals(4294967040, x >>>= x); - assertEquals(-256, x &= x); - assertEquals(1278370155.835435, x -= (-1278370411.835435)); - assertEquals(-3.488228054921667, x /= (tmp = -366481243.6881058, tmp)); - assertEquals(1.162742684973889, x /= ((x|(((((2404819175.562809)*(tmp = -2524589506, tmp))&(tmp = -675727145, tmp))>>>(x*x))&((-413250006)<<(tmp = 2408322715, tmp))))|((2940367603)>>>x))); - assertEquals(0, x >>>= ((2513665793)-(tmp = 1249857454.3367786, tmp))); - assertEquals(0, x ^= x); - assertEquals(0, x ^= x); - assertEquals(1989998348.6336238, x -= (-1989998348.6336238)); - assertEquals(903237918.986834, x %= (1086760429.6467898)); - assertEquals(-4.4185765232981975, x /= (-204418304)); - assertEquals(1471621914, x ^= (tmp = -1471621914.1771696, tmp)); - assertEquals(1471621914, x |= ((((((x<<(tmp = -2676407394.536844, tmp))%(((343324258)+(x/(x>>(((-221193011)>>>x)|x))))>>(((-2737713893)^((tmp = -49214797.00735545, tmp)+((-2818106123.172874)/(tmp = -2361786565.3028684, tmp))))<<(1859353297.6355076))))*(tmp = -751970685, tmp))|((tmp = 2502717391.425871, tmp)/(tmp = -2647169430, tmp)))*((tmp = -1647567294, tmp)&(((tmp = 1819557651, tmp)/x)>>((((-3073469753)/x)-(((tmp = -1973810496.6407511, tmp)&((x-(x+(tmp = -2986851659, tmp)))>>>(tmp = -2226975699, tmp)))|(418770782.142766)))<<x))))*(((((tmp = 125466732, tmp)/((((1453655756.398259)|(((874792086.7064595)-(194880772.91499102))>>>x))%(x<<(tmp = -1445557137, tmp)))<<x))>>>(tmp = -1953751906, tmp))/((tmp = -2140573172.2979035, tmp)*((-108581964)^x)))|(-481484013.0393069)))); - assertEquals(1454179065, x += ((tmp = 947147038.2829313, tmp)|(tmp = -154822975.3629098, tmp))); - assertEquals(1, x /= x); - assertEquals(1, x %= ((((((tmp = -2262250297.991866, tmp)-(tmp = 481953960, tmp))/(1629215187.6020458))|(2515244216))>>>((tmp = -3040594752.2184515, tmp)-(tmp = -1116041279, tmp)))^(((-182133502)-(1065160192.6609197))+(((((-1850040207)^(tmp = -1570328610, tmp))^(tmp = 20542725.09256518, tmp))*x)|(2386866629))))); - assertEquals(1, x &= (2889186303)); - assertEquals(0, x >>= (((-1323093107.050538)>>(x%x))-(((((((-1736522840)+(tmp = -2623890690.8318863, tmp))*(959395040.5565329))*(233734920))<<((x+(x%((tmp = -2370717284.4370327, tmp)%(tmp = 2109311949, tmp))))-(tmp = -1005532894, tmp)))|(861703605))>>>((2399820772)/x)))); - assertEquals(0, x >>= x); - assertEquals(57233408, x |= ((tmp = 2655923764.4179816, tmp)*(-1353634624.3025436))); - assertEquals(997939728, x |= (980552208.9005274)); - assertEquals(1859642592476610800, x *= (1863481872)); - assertEquals(-977190656, x <<= x); - assertEquals(4.378357529141239e+26, x *= ((((x/(((tmp = 2429520991, tmp)/(x/(tmp = 784592802, tmp)))-(tmp = -2704781982, tmp)))*(tmp = -2161015768.2322354, tmp))&((((-3164868762)>>(tmp = 2390893153.32907, tmp))^x)>>(-2422626718.322538)))*(tmp = 278291869, tmp))); - assertEquals(4.378357529141239e+26, x -= (1710777896.992369)); - assertEquals(0, x &= (((((tmp = -2532956158.400033, tmp)|((2195255831.279001)|(1051047432)))|(-1628591858))|(tmp = -2042607521.947963, tmp))>>((-1471225208)/(((-133621318)>>(1980416325.7358408))*((1741069593.1036062)-(x|(2133911581.991011))))))); - assertEquals(-0, x /= (-656083507)); - assertEquals(NaN, x += ((tmp = -1071410982.2789869, tmp)%x)); - assertEquals(NaN, x *= (tmp = -1513535145.3146675, tmp)); - assertEquals(0, x >>= ((2831245247.5267224)>>(x<<((x+(((3068824580.7922907)|(1708295544.275714))*((tmp = -1662930228.1170444, tmp)-(((tmp = 1979994889, tmp)<<(tmp = -1826911988, tmp))&((x/(x<<(1909384611.043981)))+(1958052414.7139997))))))<<(tmp = 2481909816.56558, tmp))))); - assertEquals(0, x *= (((tmp = -2979739958.1614842, tmp)&x)+x)); - assertEquals(-0, x *= ((-332769864.50313234)^x)); - assertEquals(0, x >>= ((((689018886.1436445)+(tmp = -2819546038.620694, tmp))|(((tmp = -1459669934.9066005, tmp)|x)/x))<<(((tmp = 2640360389, tmp)/((x%((-1947492547.9056122)%((1487212416.2083092)-(-1751984129))))^x))%(tmp = 2666842881, tmp)))); - assertEquals(-1801321460, x |= (tmp = 2493645836, tmp)); - assertEquals(-1801321460, x %= (2400405136)); - assertEquals(-2905399858195810300, x *= (tmp = 1612926911, tmp)); - assertEquals(-2905399858195810300, x -= (x>>(tmp = 1603910263.9593458, tmp))); - assertEquals(-238798848, x &= ((tmp = -2638646212.767516, tmp)/(((tmp = 1755616291.436998, tmp)>>>(tmp = 1083349775, tmp))-(x%(((tmp = 1728859105.53634, tmp)^(1931522619.0403612))/(tmp = 712460587.0025489, tmp)))))); - assertEquals(-2363873607.2302856, x += (-2125074759.230286)); - assertEquals(1712665, x &= (((117229515)>>>(((1707090894.1915488)>>>((-1696008695)>>(((-1045367326.7522249)<<(tmp = -209334716, tmp))-x)))|(-1707909786.080653)))%(1260761349.172689))); - assertEquals(1073741824, x <<= (tmp = -289437762.34742975, tmp)); - assertEquals(1073741824, x &= (tmp = 2079141140, tmp)); - assertEquals(0, x <<= ((x^(-3139646716.1615124))-(((-362323071.74237394)|(tmp = 2989896849, tmp))*(tmp = -218217991, tmp)))); - assertEquals(0, x &= (tmp = -1476835288.425903, tmp)); - assertEquals(0, x >>>= (tmp = 61945262.70868635, tmp)); - assertEquals(0, x ^= x); - assertEquals(-2735263498.7189775, x -= (2735263498.7189775)); - assertEquals(-1182289920, x <<= (x+x)); - assertEquals(-1182289580, x ^= ((2858446263.2258)>>>(2387398039.6273785))); - assertEquals(696693056, x &= ((2178665823)*(-51848583))); - assertEquals(1652555776, x <<= (((tmp = 2943916975, tmp)-((-1544273901)>>(-1671503106.2896929)))|x)); - assertEquals(6455296, x >>>= (tmp = 1492638248.675439, tmp)); - assertEquals(2097152, x &= (((x|x)*(2873891571.7000637))^((2165264807)+(tmp = 451721563, tmp)))); - assertEquals(2097152, x %= (tmp = 1089484582.1455994, tmp)); - assertEquals(2097152, x <<= x); - assertEquals(2097152, x &= ((tmp = 119096343.4032247, tmp)^((-1947874541)*x))); - assertEquals(0, x &= (tmp = 2363070677, tmp)); - assertEquals(0, x &= ((tmp = -1897325383, tmp)>>>((2368480527)>>>((tmp = 1837528979, tmp)*(-1838904077))))); - assertEquals(-1898659416, x ^= (-1898659416.1125412)); - assertEquals(-725506048, x <<= x); - assertEquals(1392943104, x <<= (295287938.9104482)); - assertEquals(-63620329, x ^= ((tmp = -3175925826.5573816, tmp)-(tmp = 2474613927, tmp))); - assertEquals(-1135111726, x -= ((tmp = -1133259081, tmp)^(((tmp = -742228219, tmp)>>((-7801909.587711811)%((tmp = -642758873, tmp)+(tmp = 2893927824.6036444, tmp))))^((tmp = -2145465178.9142997, tmp)+x)))); - assertEquals(0, x ^= x); - assertEquals(660714589, x |= (660714589)); - assertEquals(660714676, x ^= ((-376720042.8047826)>>>(2196220344))); - assertEquals(660714676, x |= ((((((((x<<(-1140465568))-(tmp = -1648489774.1573918, tmp))%(((tmp = -2955505390.573639, tmp)*x)<<((((tmp = -1769375963, tmp)*(tmp = -440619797, tmp))&((tmp = 1904284066, tmp)%(-2420852665.0629807)))+(-324601009.2063596))))>>(tmp = 2317210783.9757776, tmp))^((tmp = 750057067.4541628, tmp)^(tmp = -1391814244.7286487, tmp)))>>((344544658.6054913)%((tmp = -1508630423.218488, tmp)&(tmp = 1918909238.2974637, tmp))))>>((-647746783.685822)&(tmp = 2444858958.3595476, tmp)))&x)); - assertEquals(-962337195, x ^= (tmp = -507358495.30825853, tmp)); - assertEquals(-182008925.58535767, x %= (tmp = -195082067.35366058, tmp)); - assertEquals(502070, x >>>= (tmp = 1459732237.1447744, tmp)); - assertEquals(-2391009930.7235765, x -= (tmp = 2391512000.7235765, tmp)); - assertEquals(1568669696, x <<= x); - assertEquals(0, x <<= (tmp = -571056688.2717848, tmp)); - assertEquals(1770376226, x ^= (tmp = 1770376226.0584736, tmp)); - assertEquals(0, x ^= x); - assertEquals(0, x &= ((((x<<x)>>>x)|x)|(((tmp = -2141573723, tmp)^x)|(64299956)))); - assertEquals(0, x ^= x); - assertEquals(0, x &= x); - assertEquals(0, x <<= (1106060336.7362857)); - assertEquals(-0, x /= (x|(tmp = 2760823963, tmp))); - assertEquals(0, x <<= ((-2436225757)|(-1800598694.4062433))); - assertEquals(0, x >>>= ((-728332508.9870625)<<x)); - assertEquals(-173377680, x ^= ((tmp = -173377680, tmp)%(tmp = -2843994892, tmp))); - assertEquals(-173377680, x |= ((((-819217898)&(tmp = -1321650255, tmp))&(x+((x^x)<<((1700753064)>>((((((-1038799327)>>((782275464)^x))-(tmp = -2113814317.8539028, tmp))>>(2143804838))&x)-((2970418921)/(-3073015285.6587048)))))))&((-1759593079.4077306)%((1699128805)-((tmp = -467193967, tmp)&(((2225788267.3466334)*(((2687946762.5504274)+x)>>>x))<<(-1853556066.880512))))))); - assertEquals(-0.5520657226957338, x /= ((tmp = -755493878, tmp)&(tmp = 918108389, tmp))); - assertEquals(0.30477656217556287, x *= x); - assertEquals(0, x &= ((tmp = -2746007517, tmp)<<(2749629340))); - assertEquals(0, x ^= ((x%(tmp = 1683077876, tmp))%(-162706778))); - assertEquals(0, x *= (tmp = 10203423, tmp)); - assertEquals(119043212.1461842, x += (tmp = 119043212.1461842, tmp)); - assertEquals(587202560, x <<= (tmp = 658697910.7051642, tmp)); - assertEquals(-138689730, x |= (x-(tmp = 1296317634.5661907, tmp))); - assertEquals(-138663011, x -= ((-1751010109.5506423)>>(152829872))); - assertEquals(-138663011, x %= (-1266200468)); - assertEquals(-138663011, x &= (x|((tmp = -571277275.622529, tmp)<<x))); - assertEquals(-138663011, x >>= ((971259905.1265712)*(tmp = 2203764981, tmp))); - assertEquals(-138663011, x %= (-904715829)); - assertEquals(-138663011, x |= ((tmp = -2823047885.283391, tmp)>>>(((tmp = 533217000, tmp)|(650754598.7836078))|(-1475565890)))); - assertEquals(-1610612736, x <<= x); - assertEquals(-1610612736, x &= x); - assertEquals(163840, x >>>= (-188885010)); - assertEquals(-1224224814, x |= (tmp = 3070742482, tmp)); - assertEquals(1498726395213334500, x *= x); - assertEquals(1723591210, x |= ((tmp = 615164458, tmp)|x)); - assertEquals(1721910480, x ^= (x>>>x)); - assertEquals(4505284605.764313, x -= (tmp = -2783374125.7643127, tmp)); - assertEquals(-9504912393868483000, x *= (((tmp = 2896651872, tmp)<<(-2896385692.9017262))&(((((tmp = -2081179810.20238, tmp)|(tmp = -2484863999, tmp))>>((tmp = 1560885110.2665749, tmp)/(((tmp = 934324123.4289343, tmp)<<((tmp = -1591614157.0496385, tmp)+x))/(((x%(((tmp = 1672629986.8055913, tmp)%x)>>(tmp = 2116315086.2559657, tmp)))/(((-2687682697.5806303)>>x)/(-2034391222.5029132)))%(x-((((((tmp = 2598594967, tmp)/(((((((2950032233)%x)/x)^(tmp = -2126753451.3732262, tmp))<<(tmp = -3019113473, tmp))+(tmp = -2021220129.2320697, tmp))%((((-587645875.4666483)>>(((((x+x)+x)&(tmp = 533801785, tmp))|x)-((tmp = -2224808495.678903, tmp)/(1501942300))))>>>(-2558947646))>>((2798508249.020792)>>>x))))>>>((1060584557)/((((((((x&x)|(1426725365))>>>(tmp = 1500508838, tmp))>>(-1328705938))*((tmp = -2288009425.598777, tmp)>>>(((2586897285.9759064)%((-1605651559.2122297)>>>(tmp = 1936736684.4887302, tmp)))+((tmp = 2316261040, tmp)^(570340750.353874)))))&(x^((tmp = -2266524143, tmp)-(tmp = 2358520476, tmp))))+(tmp = 1449254900.9222453, tmp))%((-100598196)%((tmp = -2985318242.153491, tmp)>>((620722274.4565848)>>(871118975)))))))<<x)*(tmp = -1287065606.4143271, tmp))>>>(1038059916.2438471)))))))+((x/(-276990308.1264961))&(tmp = 2471016351.2195315, tmp)))|(((((tmp = -1288792769.3210807, tmp)+((tmp = -641817194, tmp)*(x<<(((-1933817364)>>(((tmp = 2084673536, tmp)|x)&x))&(tmp = -2752464480, tmp)))))%((796026752)*x))+(((tmp = -3083359669, tmp)|x)-((715303522)|(tmp = 181297266, tmp))))*(-1691520182.3207517))))); - assertEquals(0, x <<= (-2322389800)); - assertEquals(0, x *= (tmp = 3188682235, tmp)); - assertEquals(0, x |= (x>>>((tmp = -2729325231.8288336, tmp)^((-393497076.96012783)*(x/(tmp = -2198942459.9466457, tmp)))))); - assertEquals(0, x ^= x); - assertEquals(0, x %= (2835024997.4447937)); - assertEquals(0, x <<= x); - assertEquals(0, x >>= (tmp = 1109824126, tmp)); - assertEquals(0, x <<= (3013043386)); - assertEquals(206825782.74659085, x -= (-206825782.74659085)); - assertEquals(-645346761227699500, x *= (-3120243292)); - assertEquals(6825462, x >>= ((tmp = 1457908135, tmp)<<x)); - assertEquals(-612366097.9189918, x -= (619191559.9189918)); - assertEquals(-612306090.9189918, x -= ((2328676543.893506)>>x)); - assertEquals(0, x ^= (x>>(((x>>>(1856200611.2269292))&(tmp = 2003217473, tmp))%((((((-107135673)+(((3062079356.170611)<<(tmp = -676928983, tmp))>>((tmp = -1487074941.2638814, tmp)|((-1601614031)/(1317006144.5025365)))))+x)*(((1163301641)>>>(448796567))/((x%((tmp = 72293197.34410787, tmp)+(-2304112723)))/((455610361)%(-2799431520)))))>>>(-217305041.09432888))<<(x-(tmp = -2168353649, tmp)))))); - assertEquals(0, x >>= x); - assertEquals(-Infinity, x -= (((-1651597599.8950624)+(1780404320))/x)); - assertEquals(0, x <<= (tmp = 2246420272.4321294, tmp)); - assertEquals(0, x *= ((2793605382)-(tmp = -272299011, tmp))); - assertEquals(0, x *= x); - assertEquals(0, x <<= x); - assertEquals(0, x >>= (tmp = 2556413090, tmp)); - assertEquals(0, x >>= ((tmp = -1784710085, tmp)%x)); - assertEquals(0, x %= (tmp = -1929880813, tmp)); - assertEquals(0, x *= (2586983368)); - assertEquals(0, x &= x); - assertEquals(0, x <<= (-2144588807)); - assertEquals(0, x ^= ((x<<(((((((-596537598)+((x-(((((((tmp = -3179604796, tmp)/((tmp = 1156725365.3543215, tmp)>>>(tmp = -2762144319, tmp)))%(x<<x))&((tmp = 1750241928.1271567, tmp)&(x/((tmp = 1781306819, tmp)|x))))+((((2893068644)/((tmp = -576164593.9720252, tmp)<<((2724671.48995471)&(tmp = -573132475, tmp))))%(tmp = -1355625108, tmp))&(tmp = -302869512.5880568, tmp)))+x)<<x))>>((tmp = -2569172808, tmp)/x)))^x)-(tmp = -1174006275.2213159, tmp))&x)&(((((((-2303274799)>>(tmp = -814839320, tmp))/(tmp = 183887306.09810615, tmp))>>(((tmp = 1054106394.3704875, tmp)|x)>>>x))-(x-(tmp = 1313696830, tmp)))-((tmp = 2373274399.0742035, tmp)|((((tmp = -3163779539.4902935, tmp)*(tmp = -3056125181.726942, tmp))&(((x^(x^(x/((tmp = -576441696.6015451, tmp)<<(tmp = -26223719.920306206, tmp)))))>>(tmp = -2332835940, tmp))|((-146303509.41093707)&(tmp = -2676964025, tmp))))/((((x*(tmp = 1059918020, tmp))|((((2341797349)|(tmp = -744763805.1381104, tmp))<<x)+((2991320875.552578)^(2920702604.701831))))^(-1721756138))^(((tmp = -2794367554, tmp)>>((-2671235923.2097874)<<(x&((((tmp = -621472314.0859051, tmp)-(((x*x)+x)>>>((tmp = 1834038956, tmp)+x)))*x)^(tmp = -2090567586.321468, tmp)))))<<(321395210))))))>>>(tmp = -1207661719, tmp)))+(-2877264053.3805156)))/(x%(tmp = -2226991657.709366, tmp)))); - assertEquals(0, x *= (tmp = 986904991.061398, tmp)); - assertEquals(0, x -= (x%(650819306.6671969))); - assertEquals(0, x >>>= (905893666.2871252)); - assertEquals(0, x += (((tmp = 2501942710.4804144, tmp)&x)/((tmp = -851080399.1751502, tmp)-(-1168623992)))); - assertEquals(-0, x *= (tmp = -2014577821.4554045, tmp)); - assertEquals(0, x &= (tmp = 1995246018, tmp)); - assertEquals(0, x %= (1724355237.7031958)); - assertEquals(-954696411, x += (((-2825222201)+(((1662353496.1795506)>>>(x-x))|(tmp = 225015046, tmp)))^(x&x))); - assertEquals(-2158427339993389800, x *= (2260852052.1539803)); - assertEquals(19559, x >>>= (-862409169.4978967)); - assertEquals(-0.000012241163878671237, x /= (x^(tmp = 2697144215.160239, tmp))); - assertEquals(0, x -= x); - assertEquals(1448177644, x |= (tmp = 1448177644.624848, tmp)); - assertEquals(1448177644, x %= (((-1497553637.4976408)+(402228446))<<x)); - assertEquals(2304640553, x -= (-856462909)); - assertEquals(152436736, x &= ((766686903)*(((tmp = 660964683.1744609, tmp)|((((tmp = 297369746, tmp)-(x+((tmp = -2677127146, tmp)/x)))>>(((((((x%(x<<x))-(((((529254728)|((x|(-1407086127.6088922))&(tmp = -1968465008.5000398, tmp)))/(x%x))&((((-2761805265.92574)-x)*(x^(tmp = 110730179, tmp)))%((177220657.06030762)*(((2532585190.671373)/x)+(-1465143151)))))<<((tmp = -3008848338, tmp)<<(-2475597073))))|((-192996756.38619018)|((((1445996780)|(x>>>((((tmp = -2482370545.791443, tmp)*(tmp = -270543594, tmp))^x)*((1346780586)/(tmp = -625613363.885356, tmp)))))-(x<<(x/(-562307527))))&(-125701272))))*((x&x)%(tmp = 752963070, tmp)))>>>(tmp = 17419750.79086232, tmp))*x)^(x^((-157821212.04674292)-(tmp = 503849221.598824, tmp)))))-(tmp = 1479418449, tmp)))>>>((((((-78138548.2193842)<<(((2319032860.806689)-(tmp = -1564963892.5137577, tmp))>>>(-73673322.28957987)))<<((1797573493.3467085)*x))>>(tmp = 759994997, tmp))>>>(-1066441220))&(((((((tmp = 1972048857, tmp)*(((x&((-1347017320.0747669)>>>x))*(-2332716925.705054))%(-376976019.24362826)))>>>((tmp = -466479974, tmp)+x))&(-2282789473.3675604))|(((((((((269205423.7510414)-(tmp = 21919626.105656862, tmp))*((x-(tmp = -378670528, tmp))>>(tmp = -1045706598, tmp)))>>(tmp = -3062647341.234485, tmp))>>>x)|(tmp = -285399599.9386575, tmp))%(tmp = 2731214562, tmp))|((((tmp = 837093165.3438574, tmp)|(tmp = -2956931321, tmp))+((1871874558.3292787)<<((x|((tmp = -3169147427, tmp)%(((x^x)%(1479885041))%((1769991217)%(tmp = -1899472458, tmp)))))*(tmp = -837098563.71806, tmp))))>>(tmp = -1866722748, tmp)))-(2037734340.8345597)))>>((tmp = -1262019180.5332131, tmp)+(x*(1274173993.9800131))))*(tmp = 2336989321.855402, tmp)))))); - assertEquals(4, x >>= (tmp = -2577728327, tmp)); - assertEquals(16, x *= (x<<((2622323372.580596)*(tmp = -1947643367, tmp)))); - assertEquals(33554432, x <<= (tmp = -2938370507, tmp)); - assertEquals(-2399497018.987414, x -= (tmp = 2433051450.987414, tmp)); - assertEquals(1, x /= x); - assertEquals(2, x <<= x); - assertEquals(0, x >>= (x&x)); - assertEquals(0, x <<= x); -} -f(); diff --git a/src/3rdparty/v8/test/mjsunit/object-define-property.js b/src/3rdparty/v8/test/mjsunit/object-define-property.js index fdaf82d..970a803 100644 --- a/src/3rdparty/v8/test/mjsunit/object-define-property.js +++ b/src/3rdparty/v8/test/mjsunit/object-define-property.js @@ -27,7 +27,7 @@ // Tests the object.defineProperty method - ES 15.2.3.6 -// Flags: --allow-natives-syntax +// Flags: --allow-natives-syntax --es5-readonly // Check that an exception is thrown when null is passed as object. var exception = false; @@ -1057,6 +1057,8 @@ assertEquals(999, o[999]); // Regression test: Bizzare behavior on non-strict arguments object. +// TODO(yangguo): Tests disabled, needs investigation! +/* (function test(arg0) { // Here arguments[0] is a fast alias on arg0. Object.defineProperty(arguments, "0", { @@ -1075,7 +1077,7 @@ assertEquals(999, o[999]); assertEquals(2, arg0); assertEquals(3, arguments[0]); })(0); - +*/ // Regression test: We should never observe the hole value. var objectWithGetter = {}; @@ -1085,3 +1087,106 @@ assertEquals(undefined, objectWithGetter.__lookupSetter__('foo')); var objectWithSetter = {}; objectWithSetter.__defineSetter__('foo', function(x) {}); assertEquals(undefined, objectWithSetter.__lookupGetter__('foo')); + +// An object with a getter on the prototype chain. +function getter() { return 111; } +function anotherGetter() { return 222; } + +function testGetterOnProto(expected, o) { + assertEquals(expected, o.quebec); +} + +obj1 = {}; +Object.defineProperty(obj1, "quebec", { get: getter, configurable: true }); +obj2 = Object.create(obj1); +obj3 = Object.create(obj2); + +testGetterOnProto(111, obj3); +testGetterOnProto(111, obj3); +%OptimizeFunctionOnNextCall(testGetterOnProto); +testGetterOnProto(111, obj3); +testGetterOnProto(111, obj3); + +Object.defineProperty(obj1, "quebec", { get: anotherGetter }); + +testGetterOnProto(222, obj3); +testGetterOnProto(222, obj3); +%OptimizeFunctionOnNextCall(testGetterOnProto); +testGetterOnProto(222, obj3); +testGetterOnProto(222, obj3); + +// An object with a setter on the prototype chain. +var modifyMe; +function setter(x) { modifyMe = x+1; } +function anotherSetter(x) { modifyMe = x+2; } + +function testSetterOnProto(expected, o) { + modifyMe = 333; + o.romeo = 444; + assertEquals(expected, modifyMe); +} + +obj1 = {}; +Object.defineProperty(obj1, "romeo", { set: setter, configurable: true }); +obj2 = Object.create(obj1); +obj3 = Object.create(obj2); + +testSetterOnProto(445, obj3); +testSetterOnProto(445, obj3); +%OptimizeFunctionOnNextCall(testSetterOnProto); +testSetterOnProto(445, obj3); +testSetterOnProto(445, obj3); + +Object.defineProperty(obj1, "romeo", { set: anotherSetter }); + +testSetterOnProto(446, obj3); +testSetterOnProto(446, obj3); +%OptimizeFunctionOnNextCall(testSetterOnProto); +testSetterOnProto(446, obj3); +testSetterOnProto(446, obj3); + +// Removing a setter on the prototype chain. +function testSetterOnProtoStrict(o) { + "use strict"; + o.sierra = 12345; +} + +obj1 = {}; +Object.defineProperty(obj1, "sierra", + { get: getter, set: setter, configurable: true }); +obj2 = Object.create(obj1); +obj3 = Object.create(obj2); + +testSetterOnProtoStrict(obj3); +testSetterOnProtoStrict(obj3); +%OptimizeFunctionOnNextCall(testSetterOnProtoStrict); +testSetterOnProtoStrict(obj3); +testSetterOnProtoStrict(obj3); + +Object.defineProperty(obj1, "sierra", + { get: getter, set: undefined, configurable: true }); + +exception = false; +try { + testSetterOnProtoStrict(obj3); +} catch (e) { + exception = true; + assertTrue(/which has only a getter/.test(e)); +} +assertTrue(exception); + +// Test assignment to a getter-only property on the prototype chain. This makes +// sure that crankshaft re-checks its assumptions and doesn't rely only on type +// feedback (which would be monomorphic here). + +function Assign(o) { + o.blubb = 123; +} + +function C() {} + +Assign(new C); +Assign(new C); +%OptimizeFunctionOnNextCall(Assign); +Object.defineProperty(C.prototype, "blubb", {get: function() { return -42; }}); +Assign(new C); diff --git a/src/3rdparty/v8/test/mjsunit/override-read-only-property.js b/src/3rdparty/v8/test/mjsunit/override-read-only-property.js index b8fa501..2876ae1 100644 --- a/src/3rdparty/v8/test/mjsunit/override-read-only-property.js +++ b/src/3rdparty/v8/test/mjsunit/override-read-only-property.js @@ -25,6 +25,8 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Flags: --es5_readonly + // According to ECMA-262, sections 8.6.2.2 and 8.6.2.3 you're not // allowed to override read-only properties, not even if the read-only // property is in the prototype chain. @@ -38,19 +40,19 @@ F.prototype = Number; var original_number_max = Number.MAX_VALUE; // Assignment to a property which does not exist on the object itself, -// but is read-only in a prototype takes effect. +// but is read-only in a prototype does not take effect. var f = new F(); assertEquals(original_number_max, f.MAX_VALUE); f.MAX_VALUE = 42; -assertEquals(42, f.MAX_VALUE); +assertEquals(original_number_max, f.MAX_VALUE); // Assignment to a property which does not exist on the object itself, -// but is read-only in a prototype takes effect. +// but is read-only in a prototype does not take effect. f = new F(); with (f) { MAX_VALUE = 42; } -assertEquals(42, f.MAX_VALUE); +assertEquals(original_number_max, f.MAX_VALUE); // Assignment to read-only property on the object itself is ignored. Number.MAX_VALUE = 42; diff --git a/src/3rdparty/v8/test/mjsunit/packed-elements.js b/src/3rdparty/v8/test/mjsunit/packed-elements.js new file mode 100644 index 0000000..cfcdf80 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/packed-elements.js @@ -0,0 +1,112 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax --smi-only-arrays --packed-arrays + +var has_packed_elements = !%HasFastHoleyElements(Array()); + +function test1() { + var a = Array(8); + assertTrue(%HasFastSmiOrObjectElements(a)); + assertTrue(%HasFastHoleyElements(a)); +} + +function test2() { + var a = Array(); + assertTrue(%HasFastSmiOrObjectElements(a)); + assertFalse(%HasFastHoleyElements(a)); +} + +function test3() { + var a = Array(1,2,3,4,5,6,7); + assertTrue(%HasFastSmiOrObjectElements(a)); + assertFalse(%HasFastHoleyElements(a)); +} + +function test4() { + var a = [1, 2, 3, 4]; + assertTrue(%HasFastSmiElements(a)); + assertFalse(%HasFastHoleyElements(a)); + var b = [1, 2,, 4]; + assertTrue(%HasFastSmiElements(b)); + assertTrue(%HasFastHoleyElements(b)); +} + +function test5() { + var a = [1, 2, 3, 4.5]; + assertTrue(%HasFastDoubleElements(a)); + assertFalse(%HasFastHoleyElements(a)); + var b = [1,, 3.5, 4]; + assertTrue(%HasFastDoubleElements(b)); + assertTrue(%HasFastHoleyElements(b)); + var c = [1, 3.5,, 4]; + assertTrue(%HasFastDoubleElements(c)); + assertTrue(%HasFastHoleyElements(c)); +} + +function test6() { + var x = new Object(); + var a = [1, 2, 3.5, x]; + assertTrue(%HasFastObjectElements(a)); + assertFalse(%HasFastHoleyElements(a)); + assertEquals(1, a[0]); + assertEquals(2, a[1]); + assertEquals(3.5, a[2]); + assertEquals(x, a[3]); + var b = [1,, 3.5, x]; + assertTrue(%HasFastObjectElements(b)); + assertTrue(%HasFastHoleyElements(b)); + assertEquals(1, b[0]); + assertEquals(undefined, b[1]); + assertEquals(3.5, b[2]); + assertEquals(x, b[3]); + var c = [1, 3.5, x,,]; + assertTrue(%HasFastObjectElements(c)); + assertTrue(%HasFastHoleyElements(c)); + assertEquals(1, c[0]); + assertEquals(3.5, c[1]); + assertEquals(x, c[2]); + assertEquals(undefined, c[3]); +} + +function test_with_optimization(f) { + // Run tests in a loop to make sure that inlined Array() constructor runs out + // of new space memory and must fall back on runtime impl. + for (i = 0; i < 25000; ++i) f(); + %OptimizeFunctionOnNextCall(f); + for (i = 0; i < 25000; ++i) f(); // Make sure GC happens +} + +if (has_packed_elements) { + test_with_optimization(test1); + test_with_optimization(test2); + test_with_optimization(test3); + test_with_optimization(test4); + test_with_optimization(test5); + test_with_optimization(test6); +} + diff --git a/src/3rdparty/v8/test/mjsunit/parse-int-float.js b/src/3rdparty/v8/test/mjsunit/parse-int-float.js index 2e4f648..5a9b6f3 100644 --- a/src/3rdparty/v8/test/mjsunit/parse-int-float.js +++ b/src/3rdparty/v8/test/mjsunit/parse-int-float.js @@ -29,10 +29,10 @@ assertEquals(0, parseInt('0')); assertEquals(0, parseInt(' 0')); assertEquals(0, parseInt(' 0 ')); -assertEquals(63, parseInt('077')); -assertEquals(63, parseInt(' 077')); -assertEquals(63, parseInt(' 077 ')); -assertEquals(-63, parseInt(' -077')); +assertEquals(77, parseInt('077')); +assertEquals(77, parseInt(' 077')); +assertEquals(77, parseInt(' 077 ')); +assertEquals(-77, parseInt(' -077')); assertEquals(3, parseInt('11', 2)); assertEquals(4, parseInt('11', 3)); diff --git a/src/3rdparty/v8/test/mjsunit/pixel-array-rounding.js b/src/3rdparty/v8/test/mjsunit/pixel-array-rounding.js index ef5a10b..0c307e6 100644..100755 --- a/src/3rdparty/v8/test/mjsunit/pixel-array-rounding.js +++ b/src/3rdparty/v8/test/mjsunit/pixel-array-rounding.js @@ -27,7 +27,7 @@ // Flags: --allow-natives-syntax -var pixels = new PixelArray(8); +var pixels = new Uint8ClampedArray(8); function f() { for (var i = 0; i < 8; i++) { diff --git a/src/3rdparty/v8/test/mjsunit/readonly.js b/src/3rdparty/v8/test/mjsunit/readonly.js new file mode 100644 index 0000000..4d06b7c --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/readonly.js @@ -0,0 +1,228 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax --harmony-proxies --es5_readonly + +// Different ways to create an object. + +function CreateFromLiteral() { + return {}; +} + +function CreateFromObject() { + return new Object; +} + +function CreateDefault() { + return Object.create(Object.prototype); +} + +function CreateFromConstructor(proto) { + function C() {} + (new C).b = 9; // Make sure that we can have an in-object property. + C.prototype = proto; + return function() { return new C; } +} + +function CreateFromApi(proto) { + return function() { return Object.create(proto); } +} + +function CreateWithProperty(proto) { + function C() { this.a = -100; } + C.prototype = proto; + return function() { return new C; } +} + +var bases = [CreateFromLiteral, CreateFromObject, CreateDefault]; +var inherits = [CreateFromConstructor, CreateFromApi, CreateWithProperty]; +var constructs = [CreateFromConstructor, CreateFromApi]; + +function TestAllCreates(f) { + // The depth of the prototype chain up the. + for (var depth = 0; depth < 3; ++depth) { + // Introduce readonly-ness this far up the chain. + for (var up = 0; up <= depth; ++up) { + // Try different construction methods. + for (var k = 0; k < constructs.length; ++k) { + // Construct a fresh prototype chain from above functions. + for (var i = 0; i < bases.length; ++i) { + var p = bases[i](); + // There may be a preexisting property under the insertion point... + for (var j = 0; j < depth - up; ++j) { + p = inherits[Math.floor(inherits.length * Math.random())](p)(); + } + // ...but not above it. + for (var j = 0; j < up; ++j) { + p = constructs[Math.floor(constructs.length * Math.random())](p)(); + } + // Create a fresh constructor. + var c = constructs[k](p); + f(function() { + var o = c(); + o.up = o; + for (var j = 0; j < up; ++j) o.up = Object.getPrototypeOf(o.up); + return o; + }) + } + } + } + } +} + + +// Different ways to make a property read-only. + +function ReadonlyByNonwritableDataProperty(o, name) { + Object.defineProperty(o, name, {value: -41, writable: false}); +} + +function ReadonlyByAccessorPropertyWithoutSetter(o, name) { + Object.defineProperty(o, name, {get: function() { return -42; }}); +} + +function ReadonlyByGetter(o, name) { + o.__defineGetter__("a", function() { return -43; }); +} + +function ReadonlyByFreeze(o, name) { + o[name] = -44; + Object.freeze(o); +} + +function ReadonlyByProto(o, name) { + var p = Object.create(o.__proto__); + Object.defineProperty(p, name, {value: -45, writable: false}); + o.__proto__ = p; +} + +function ReadonlyByProxy(o, name) { + var p = Proxy.create({ + getPropertyDescriptor: function() { + return {value: -46, writable: false, configurable: true}; + } + }); + o.__proto__ = p; +} + +var readonlys = [ + ReadonlyByNonwritableDataProperty, ReadonlyByAccessorPropertyWithoutSetter, + ReadonlyByGetter, ReadonlyByFreeze, ReadonlyByProto, ReadonlyByProxy +] + +function TestAllReadonlys(f) { + // Provide various methods to making a property read-only. + for (var i = 0; i < readonlys.length; ++i) { + print(" readonly =", i) + f(readonlys[i]); + } +} + + +// Different use scenarios. + +function Assign(o, x) { + o.a = x; +} + +function AssignStrict(o, x) { + "use strict"; + o.a = x; +} + +function TestAllModes(f) { + for (var strict = 0; strict < 2; ++strict) { + print(" strict =", strict); + f(strict); + } +} + +function TestAllScenarios(f) { + for (var t = 0; t < 100; t = 2*t + 1) { + print("t =", t) + f(function(strict, create, readonly) { + // Make sure that the assignments are monomorphic. + %DeoptimizeFunction(Assign); + %DeoptimizeFunction(AssignStrict); + %ClearFunctionTypeFeedback(Assign); + %ClearFunctionTypeFeedback(AssignStrict); + for (var i = 0; i < t; ++i) { + var o = create(); + assertFalse("a" in o && !("a" in o.__proto__)); + if (strict === 0) + Assign(o, i); + else + AssignStrict(o, i); + assertEquals(i, o.a); + } + %OptimizeFunctionOnNextCall(Assign); + %OptimizeFunctionOnNextCall(AssignStrict); + var o = create(); + assertFalse("a" in o && !("a" in o.__proto__)); + readonly(o.up, "a"); + assertTrue("a" in o); + if (strict === 0) + Assign(o, t + 1); + else + assertThrows(function() { AssignStrict(o, t + 1) }, TypeError); + assertTrue(o.a < 0); + }); + } +} + + +// Runner. + +TestAllScenarios(function(scenario) { + TestAllModes(function(strict) { + TestAllReadonlys(function(readonly) { + TestAllCreates(function(create) { + scenario(strict, create, readonly); + }); + }); + }); +}); + + +// Extra test forcing bailout. + +function Assign2(o, x) { o.a = x } + +(function() { + var p = CreateFromConstructor(Object.prototype)(); + var c = CreateFromConstructor(p); + for (var i = 0; i < 3; ++i) { + var o = c(); + Assign2(o, i); + assertEquals(i, o.a); + } + %OptimizeFunctionOnNextCall(Assign2); + ReadonlyByNonwritableDataProperty(p, "a"); + var o = c(); + Assign2(o, 0); + assertTrue(o.a < 0); +})(); diff --git a/src/3rdparty/v8/test/mjsunit/regexp-capture-3.js b/src/3rdparty/v8/test/mjsunit/regexp-capture-3.js index 9bdd600..b676f01 100644..100755 --- a/src/3rdparty/v8/test/mjsunit/regexp-capture-3.js +++ b/src/3rdparty/v8/test/mjsunit/regexp-capture-3.js @@ -162,7 +162,6 @@ assertEquals("*foo * baz", a); // string we can test that the relevant node is removed by verifying that // there is no hang. function NoHang(re) { - print(re); "This is an ASCII string that could take forever".match(re); } @@ -216,3 +215,5 @@ regex10.exec(input0); var regex11 = /^(?:[^\u0000-\u0080]|[0-9a-z?,.!&\s#()])+$/i; regex11.exec(input0); +var regex12 = /u(\xf0{8}?\D*?|( ? !)$h??(|)*?(||)+?\6((?:\W\B|--\d-*-|)?$){0, }?|^Y( ? !1)\d+)+a/; +regex12.exec(""); diff --git a/src/3rdparty/v8/test/mjsunit/regexp-capture.js b/src/3rdparty/v8/test/mjsunit/regexp-capture.js index 8aae717..3073094 100755 --- a/src/3rdparty/v8/test/mjsunit/regexp-capture.js +++ b/src/3rdparty/v8/test/mjsunit/regexp-capture.js @@ -56,3 +56,5 @@ assertEquals(["bbc", "b"], /^(b+|a){1,2}?bc/.exec("bbc")); assertEquals(["bbaa", "a", "", "a"], /((\3|b)\2(a)){2,}/.exec("bbaababbabaaaaabbaaaabba")); +// From crbug.com/128821 - don't hang: +"".match(/((a|i|A|I|u|o|U|O)(s|c|b|c|d|f|g|h|j|k|l|m|n|p|q|r|s|t|v|w|x|y|z|B|C|D|F|G|H|J|K|L|M|N|P|Q|R|S|T|V|W|X|Y|Z)*) de\/da([.,!?\s]|$)/); diff --git a/src/3rdparty/v8/test/mjsunit/regexp-global.js b/src/3rdparty/v8/test/mjsunit/regexp-global.js new file mode 100644 index 0000000..093dba1 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regexp-global.js @@ -0,0 +1,254 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +// Test that an optional capture is cleared between two matches. +var str = "ABX X"; +str = str.replace(/(\w)?X/g, function(match, capture) { + assertTrue(match.indexOf(capture) >= 0 || + capture === undefined); + return capture ? capture.toLowerCase() : "-"; + }); +assertEquals("Ab -", str); + +// Test zero-length matches. +str = "Als Gregor Samsa eines Morgens"; +str = str.replace(/\b/g, function(match, capture) { + return "/"; + }); +assertEquals("/Als/ /Gregor/ /Samsa/ /eines/ /Morgens/", str); + +// Test zero-length matches that have non-zero-length sub-captures. +str = "It was a pleasure to burn."; +str = str.replace(/(?=(\w+))\b/g, function(match, capture) { + return capture.length; + }); +assertEquals("2It 3was 1a 8pleasure 2to 4burn.", str); + +// Test multiple captures. +str = "Try not. Do, or do not. There is no try."; +str = str.replace(/(not?)|(do)|(try)/gi, + function(match, c1, c2, c3) { + assertTrue((c1 === undefined && c2 === undefined) || + (c2 === undefined && c3 === undefined) || + (c1 === undefined && c3 === undefined)); + if (c1) return "-"; + if (c2) return "+"; + if (c3) return "=" + }); +assertEquals("= -. +, or + -. There is - =.", str); + +// Test multiple alternate captures. +str = "FOUR LEGS GOOD, TWO LEGS BAD!"; +str = str.replace(/(FOUR|TWO) LEGS (GOOD|BAD)/g, + function(match, num_legs, likeability) { + assertTrue(num_legs !== undefined); + assertTrue(likeability !== undefined); + if (num_legs == "FOUR") assertTrue(likeability == "GOOD"); + if (num_legs == "TWO") assertTrue(likeability == "BAD"); + return match.length - 10; + }); +assertEquals("4, 2!", str); + + +// The same tests with UC16. + +//Test that an optional capture is cleared between two matches. +str = "AB\u1234 \u1234"; +str = str.replace(/(\w)?\u1234/g, + function(match, capture) { + assertTrue(match.indexOf(capture) >= 0 || + capture === undefined); + return capture ? capture.toLowerCase() : "-"; + }); +assertEquals("Ab -", str); + +// Test zero-length matches. +str = "Als \u2623\u2642 eines Morgens"; +str = str.replace(/\b/g, function(match, capture) { + return "/"; + }); +assertEquals("/Als/ \u2623\u2642 /eines/ /Morgens/", str); + +// Test zero-length matches that have non-zero-length sub-captures. +str = "It was a pleasure to \u70e7."; +str = str.replace(/(?=(\w+))\b/g, function(match, capture) { + return capture.length; + }); +assertEquals("2It 3was 1a 8pleasure 2to \u70e7.", str); + +// Test multiple captures. +str = "Try not. D\u26aa, or d\u26aa not. There is no try."; +str = str.replace(/(not?)|(d\u26aa)|(try)/gi, + function(match, c1, c2, c3) { + assertTrue((c1 === undefined && c2 === undefined) || + (c2 === undefined && c3 === undefined) || + (c1 === undefined && c3 === undefined)); + if (c1) return "-"; + if (c2) return "+"; + if (c3) return "=" + }); +assertEquals("= -. +, or + -. There is - =.", str); + +// Test multiple alternate captures. +str = "FOUR \u817f GOOD, TWO \u817f BAD!"; +str = str.replace(/(FOUR|TWO) \u817f (GOOD|BAD)/g, + function(match, num_legs, likeability) { + assertTrue(num_legs !== undefined); + assertTrue(likeability !== undefined); + if (num_legs == "FOUR") assertTrue(likeability == "GOOD"); + if (num_legs == "TWO") assertTrue(likeability == "BAD"); + return match.length - 7; + }); +assertEquals("4, 2!", str); + +// Test capture that is a real substring. +var str = "Beasts of England, beasts of Ireland"; +str = str.replace(/(.*)/g, function(match) { return '~'; }); +assertEquals("~~", str); + +// Test zero-length matches that have non-zero-length sub-captures that do not +// start at the match start position. +str = "up up up up"; +str = str.replace(/\b(?=u(p))/g, function(match, capture) { + return capture.length; + }); + +assertEquals("1up 1up 1up 1up", str); + + +// Create regexp that has a *lot* of captures. +var re_string = "(a)"; +for (var i = 0; i < 500; i++) { + re_string = "(" + re_string + ")"; +} +re_string = re_string + "1"; +// re_string = "(((...((a))...)))1" + +var regexps = new Array(); +var last_match_expectations = new Array(); +var first_capture_expectations = new Array(); + +// Atomic regexp. +regexps.push(/a1/g); +last_match_expectations.push("a1"); +first_capture_expectations.push(""); +// Small regexp (no capture); +regexps.push(/\w1/g); +last_match_expectations.push("a1"); +first_capture_expectations.push(""); +// Small regexp (one capture). +regexps.push(/(a)1/g); +last_match_expectations.push("a1"); +first_capture_expectations.push("a"); +// Large regexp (a lot of captures). +regexps.push(new RegExp(re_string, "g")); +last_match_expectations.push("a1"); +first_capture_expectations.push("a"); + +function test_replace(result_expectation, + subject, + regexp, + replacement) { + for (var i = 0; i < regexps.length; i++) { + // Overwrite last match info. + "deadbeef".replace(/(dead)beef/, "$1holeycow"); + // Conduct tests. + assertEquals(result_expectation, subject.replace(regexps[i], replacement)); + if (subject.length == 0) { + assertEquals("deadbeef", RegExp.lastMatch); + assertEquals("dead", RegExp["$1"]); + } else { + assertEquals(last_match_expectations[i], RegExp.lastMatch); + assertEquals(first_capture_expectations[i], RegExp["$1"]); + } + } +} + + +function test_match(result_expectation, + subject, + regexp) { + for (var i = 0; i < regexps.length; i++) { + // Overwrite last match info. + "deadbeef".replace(/(dead)beef/, "$1holeycow"); + // Conduct tests. + if (result_expectation == null) { + assertNull(subject.match(regexps[i])); + } else { + assertArrayEquals(result_expectation, subject.match(regexps[i])); + } + if (subject.length == 0) { + assertEquals("deadbeef", RegExp.lastMatch); + assertEquals("dead", RegExp["$1"]); + } else { + assertEquals(last_match_expectations[i], RegExp.lastMatch); + assertEquals(first_capture_expectations[i], RegExp["$1"]); + } + } +} + + +// Test for different number of matches. +for (var m = 0; m < 200; m++) { + // Create string that matches m times. + var subject = ""; + var test_1_expectation = ""; + var test_2_expectation = ""; + var test_3_expectation = (m == 0) ? null : new Array(); + for (var i = 0; i < m; i++) { + subject += "a11"; + test_1_expectation += "x1"; + test_2_expectation += "1"; + test_3_expectation.push("a1"); + } + + // Test 1a: String.replace with string. + test_replace(test_1_expectation, subject, /a1/g, "x"); + + // Test 1b: String.replace with function. + function f() { return "x"; } + test_replace(test_1_expectation, subject, /a1/g, f); + + // Test 2a: String.replace with empty string. + test_replace(test_2_expectation, subject, /a1/g, ""); + + // Test 3a: String.match. + test_match(test_3_expectation, subject, /a1/g); +} + + +// Test String hashing (compiling regular expression includes hashing). +var crosscheck = "\x80"; +for (var i = 0; i < 12; i++) crosscheck += crosscheck; +new RegExp(crosscheck); + +var subject = "ascii~only~string~here~"; +var replacement = "\x80"; +var result = subject.replace(/~/g, replacement); +for (var i = 0; i < 5; i++) result += result; +new RegExp(result); diff --git a/src/3rdparty/v8/test/mjsunit/regexp-results-cache.js b/src/3rdparty/v8/test/mjsunit/regexp-results-cache.js new file mode 100644 index 0000000..7ee8c3f --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regexp-results-cache.js @@ -0,0 +1,78 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Long string to trigger caching. +var string = +"Friends, Romans, countrymen, lend me your ears! \ + I come to bury Caesar, not to praise him. \ + The evil that men do lives after them, \ + The good is oft interred with their bones; \ + So let it be with Caesar. The noble Brutus \ + Hath told you Caesar was ambitious; \ + If it were so, it was a grievous fault, \ + And grievously hath Caesar answer'd it. \ + Here, under leave of Brutus and the rest- \ + For Brutus is an honorable man; \ + So are they all, all honorable men- \ + Come I to speak in Caesar's funeral. \ + He was my friend, faithful and just to me; \ + But Brutus says he was ambitious, \ + And Brutus is an honorable man. \ + He hath brought many captives home to Rome, \ + Whose ransoms did the general coffers fill. \ + Did this in Caesar seem ambitious? \ + When that the poor have cried, Caesar hath wept; \ + Ambition should be made of sterner stuff: \ + Yet Brutus says he was ambitious, \ + And Brutus is an honorable man. \ + You all did see that on the Lupercal \ + I thrice presented him a kingly crown, \ + Which he did thrice refuse. Was this ambition? \ + Yet Brutus says he was ambitious, \ + And sure he is an honorable man. \ + I speak not to disprove what Brutus spoke, \ + But here I am to speak what I do know. \ + You all did love him once, not without cause; \ + What cause withholds you then to mourn for him? \ + O judgement, thou art fled to brutish beasts, \ + And men have lost their reason. Bear with me; \ + My heart is in the coffin there with Caesar, \ + And I must pause till it come back to me."; + +var replaced = string.replace(/\b\w+\b/g, function() { return "foo"; }); +for (var i = 0; i < 3; i++) { + assertEquals(replaced, + string.replace(/\b\w+\b/g, function() { return "foo"; })); +} + +// Check that the result is in a COW array. +var words = string.split(" "); +assertEquals("Friends,", words[0]); +words[0] = "Enemies,"; +words = string.split(" "); +assertEquals("Friends,", words[0]); + diff --git a/src/3rdparty/v8/test/mjsunit/regexp.js b/src/3rdparty/v8/test/mjsunit/regexp.js index ec82c96..c2d9282 100644 --- a/src/3rdparty/v8/test/mjsunit/regexp.js +++ b/src/3rdparty/v8/test/mjsunit/regexp.js @@ -705,3 +705,14 @@ assertThrows("RegExp('(?!*)')"); // Test trimmed regular expression for RegExp.test(). assertTrue(/.*abc/.test("abc")); assertFalse(/.*\d+/.test("q")); + +// Test that RegExp.prototype.toString() throws TypeError for +// incompatible receivers (ES5 section 15.10.6 and 15.10.6.4). +assertThrows("RegExp.prototype.toString.call(null)", TypeError); +assertThrows("RegExp.prototype.toString.call(0)", TypeError); +assertThrows("RegExp.prototype.toString.call('')", TypeError); +assertThrows("RegExp.prototype.toString.call(false)", TypeError); +assertThrows("RegExp.prototype.toString.call(true)", TypeError); +assertThrows("RegExp.prototype.toString.call([])", TypeError); +assertThrows("RegExp.prototype.toString.call({})", TypeError); +assertThrows("RegExp.prototype.toString.call(function(){})", TypeError); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-1117.js b/src/3rdparty/v8/test/mjsunit/regress/regress-1117.js index b013a22..981a1b7 100644 --- a/src/3rdparty/v8/test/mjsunit/regress/regress-1117.js +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-1117.js @@ -25,11 +25,20 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Flags: --allow-natives-syntax + // Test that we actually return the right value (-0) when we multiply // constant 0 with a negative integer. function foo(y) {return 0 * y; } -for( var i = 0; i< 1000000; i++){ - foo(42); -} assertEquals(1/foo(-42), -Infinity); +assertEquals(1/foo(-42), -Infinity); +%OptimizeFunctionOnNextCall(foo); +assertEquals(1/foo(-42), -Infinity); + +function bar(x) { return x * 0; } +assertEquals(Infinity, 1/bar(5)); +assertEquals(Infinity, 1/bar(5)); +%OptimizeFunctionOnNextCall(bar); +assertEquals(-Infinity, 1/bar(-5)); + diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-1118.js b/src/3rdparty/v8/test/mjsunit/regress/regress-1118.js index 7e0461d..3e3920f 100644 --- a/src/3rdparty/v8/test/mjsunit/regress/regress-1118.js +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-1118.js @@ -25,7 +25,7 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Flags: --allow-natives-syntax +// Flags: --allow-natives-syntax --noparallel-recompilation // An exception thrown in a function optimized by on-stack replacement (OSR) // should be able to construct a receiver from all optimized stack frames. diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-115100.js b/src/3rdparty/v8/test/mjsunit/regress/regress-115100.js new file mode 100644 index 0000000..c917446 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-115100.js @@ -0,0 +1,36 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +function foo(obj) { obj.prop = 0; } +function mk() { return Object.create(null); } + +foo(mk()); +foo(mk()); +%OptimizeFunctionOnNextCall(foo); +foo(mk()); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-117409.js b/src/3rdparty/v8/test/mjsunit/regress/regress-117409.js index 9222191..98aab5a 100644 --- a/src/3rdparty/v8/test/mjsunit/regress/regress-117409.js +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-117409.js @@ -36,7 +36,7 @@ var literal = [1.2]; KeyedStoreIC(literal); KeyedStoreIC(literal); -// Trruncate array to 0 elements, at which point backing store will be replaced +// Truncate array to 0 elements, at which point backing store will be replaced // with empty fixed array. literal.length = 0; diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-1199637.js b/src/3rdparty/v8/test/mjsunit/regress/regress-1199637.js index 9c560a9..8b02a65 100644 --- a/src/3rdparty/v8/test/mjsunit/regress/regress-1199637.js +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-1199637.js @@ -25,7 +25,7 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Flags: --allow-natives-syntax +// Flags: --allow-natives-syntax --es52_globals // Make sure that we can introduce global variables (using // both var and const) that shadow even READ_ONLY variables @@ -74,5 +74,3 @@ assertEquals(5678, z); assertEquals(1234, w); eval("with({}) { const w = 5678; }"); assertEquals(5678, w); - - diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-128146.js b/src/3rdparty/v8/test/mjsunit/regress/regress-128146.js index 5c22b4e..730dd91 100644 --- a/src/3rdparty/v8/test/mjsunit/regress/regress-128146.js +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-128146.js @@ -25,14 +25,9 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Define accessor properties, resulting in an AccessorPair with 2 transitions. Object.defineProperty({},"foo",{set:function(){},configurable:false}); Object.defineProperty({},"foo",{get:function(){},configurable:false}); -Object.defineProperty({},"foo",{}); - -// From WebKit layout tests (fast/js/prototypes.html) -var wasSet = false; -var o = { }; -o.__defineGetter__("__proto__", function() { wasSet = true }); -o.__proto__; -assertFalse(wasSet); +// Define a data property under the same name. +Object.defineProperty({},"foo",{}); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-131923.js b/src/3rdparty/v8/test/mjsunit/regress/regress-131923.js new file mode 100644 index 0000000..58da07c --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-131923.js @@ -0,0 +1,30 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +assertFalse(/\u9999{4}/.test("")); +assertTrue(/\u9999{0,4}/.test("")); +assertFalse(/\u9999{4,}/.test("")); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-131994.js b/src/3rdparty/v8/test/mjsunit/regress/regress-131994.js new file mode 100644 index 0000000..8347653 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-131994.js @@ -0,0 +1,70 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-debug-as debug + +// Test that a variable in the local scope that shadows a context-allocated +// variable is correctly resolved when being evaluated in the debugger. + +Debug = debug.Debug; + +var exception = false; + +function listener(event, exec_state, event_data, data) { + if (event != Debug.DebugEvent.Break) return; + var breakpoint = exec_state.frame(0); + try { + // Assert correct break point. + assertTrue(breakpoint.sourceLineText().indexOf("// Break") > -1); + // Assert correct value. + assertEquals(3, breakpoint.evaluate('x').value()); + } catch (e) { + exception = e; + } +} + +Debug.setListener(listener); + +function h() { + var x; // Context-allocated due to g(). + + var g = function g() { + x = -7; + }; + + var f = function f() { + var x = 3; // Allocated in the local scope. + debugger; // Break. + }; + + f(); +} + +h(); + +assertFalse(exception); + diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-133211.js b/src/3rdparty/v8/test/mjsunit/regress/regress-133211.js new file mode 100644 index 0000000..f9473d1 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-133211.js @@ -0,0 +1,35 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Make sure we don't leak maps when reading intermediate property descriptors. + +var o = {}; +var x = {}; +Object.defineProperty(o, "foo", { get: undefined }); +Object.defineProperty(x, "foo", { get: undefined, set: undefined }); +var pd = Object.getOwnPropertyDescriptor(o, "foo"); +assertEquals(undefined, pd.set); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-133211b.js b/src/3rdparty/v8/test/mjsunit/regress/regress-133211b.js new file mode 100644 index 0000000..87e35f4 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-133211b.js @@ -0,0 +1,39 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-gc + +setter = function(x) { return; } +var o = {}; +Object.defineProperty(o, "foo", { set: setter }); +var x = {}; +Object.defineProperty(x, "foo", { set: setter }); +x.bar = 20; +x = {}; +gc(); +o.foo = 20; +assertEquals(undefined, o.foo); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-136048.js b/src/3rdparty/v8/test/mjsunit/regress/regress-136048.js new file mode 100644 index 0000000..c9972e9 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-136048.js @@ -0,0 +1,34 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +try { + /foo/\u0069 +} catch (e) { + assertEquals( + "SyntaxError: Invalid flags supplied to RegExp constructor '\\u0069'", + e.toString()); +} diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-137768.js b/src/3rdparty/v8/test/mjsunit/regress/regress-137768.js new file mode 100644 index 0000000..9fbd7f3 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-137768.js @@ -0,0 +1,73 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +// Create elements in a constructor function to ensure map sharing. +function TestConstructor() { + this[0] = 1; + this[1] = 2; + this[2] = 3; +} + +function bad_func(o,a) { + var s = 0; + for (var i = 0; i < 1; ++i) { + o.newFileToChangeMap = undefined; + var x = a[0]; + s += x; + } + return s; +} + +o = new Object(); +a = new TestConstructor(); +bad_func(o, a); + +// Make sure that we're out of pre-monomorphic state for the member add of +// 'newFileToChangeMap' which causes a map transition. +o = new Object(); +a = new TestConstructor(); +bad_func(o, a); + +// Optimize, before the fix, the element load and subsequent tagged-to-i were +// hoisted above the map check, which can't be hoisted due to the map-changing +// store. +o = new Object(); +a = new TestConstructor(); +%OptimizeFunctionOnNextCall(bad_func); +bad_func(o, a); + +// Pass in a array of doubles. Before the fix, the optimized load and +// tagged-to-i will treat part of a double value as a pointer and de-ref it +// before the map check was executed that should have deopt. +o = new Object(); +// Pass in an elements buffer where the bit representation of the double numbers +// are two adjacent small 32-bit values with the lowest bit set to one, causing +// tagged-to-i to SIGSEGV. +a = [2.122e-314, 2.122e-314, 2.122e-314]; +bad_func(o, a); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-143967.js b/src/3rdparty/v8/test/mjsunit/regress/regress-143967.js new file mode 100644 index 0000000..7c12e67 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-143967.js @@ -0,0 +1,34 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Check that Accessors::FunctionGetPrototype traverses the prototype +// chain correctly and doesn't get stuck. + +var functionWithoutProto = [].filter; +var obj = Object.create(functionWithoutProto); +functionWithoutProto.__proto__ = function() {}; +assertEquals(functionWithoutProto.prototype, obj.prototype); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-145201.js b/src/3rdparty/v8/test/mjsunit/regress/regress-145201.js new file mode 100644 index 0000000..7fe7bce --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-145201.js @@ -0,0 +1,107 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Fix some corner cases in skipping native methods using caller. +var net = []; + + +var x = 0; + +function collect () { + function item(operator) { + binary(operator, 1, false); + binary(operator, 1, true); + binary(operator, '{}', false); + binary(operator, '{}', true); + binary(operator, '"x"', false); + binary(operator, '"x"', true); + unary(operator, ""); + } + + function unary(op, after) { + // Capture: + try { + eval(op + " custom " + after); + } catch(e) { + } + } + + function binary(op, other_side, inverted) { + // Capture: + try { + if (inverted) { + eval("custom " + op + " " + other_side); + } else { + eval(other_side + " " + op + " custom"); + } + } catch(e) { + } + } + + function catcher() { + var caller = catcher.caller; + if (/native/i.test(caller) || /ADD/.test(caller)) { + net[caller] = 0; + } + } + + var custom = Object.create(null, { + toString: { value: catcher }, + length: { get: catcher } + }); + + item('^'); + item('~'); + item('<<'); + item('<'); + item('=='); + item('>>>'); + item('>>'); + item('|'); + item('-'); + item('*'); + item('&'); + item('%'); + item('+'); + item('in'); + item('instanceof'); + unary('{}[', ']'); + unary('delete {}[', ']'); + unary('(function() {}).apply(null, ', ')'); +} + +collect(); +collect(); +collect(); + +var keys = 0; +for (var key in net) { + print(key); + keys++; +} + +assertTrue(keys == 0); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-148378.js b/src/3rdparty/v8/test/mjsunit/regress/regress-148378.js new file mode 100644 index 0000000..d37cea1 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-148378.js @@ -0,0 +1,38 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +"a".replace(/a/g, function() { return "c"; }); + +function test() { + try { + test(); + } catch(e) { + "b".replace(/(b)/g, function() { return "c"; }); + } +} + +test(); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-1563.js b/src/3rdparty/v8/test/mjsunit/regress/regress-1563.js index c25b6c7..884b125 100644 --- a/src/3rdparty/v8/test/mjsunit/regress/regress-1563.js +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-1563.js @@ -27,7 +27,7 @@ // Flags: --allow-natives-syntax -obj = new PixelArray(10); +obj = new Uint8ClampedArray(10); // Test that undefined gets properly clamped in Crankshafted pixel array // assignments. diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-1591.js b/src/3rdparty/v8/test/mjsunit/regress/regress-1591.js new file mode 100644 index 0000000..69efd0b --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-1591.js @@ -0,0 +1,48 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var stack; +var used_custom_lookup = false; + +({ + __lookupGetter__ : function() { + used_custom_lookup = true; + }, + + test : function() { + try { + f(); + } catch (err) { + stack = err.stack; + } + } +}).test(); + +var expected_message = "ReferenceError: f is not defined"; +assertTrue(stack.indexOf(expected_message) >= 0); +assertFalse(used_custom_lookup); + diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-1849.js b/src/3rdparty/v8/test/mjsunit/regress/regress-1849.js index 176f918..5b8fc50 100644 --- a/src/3rdparty/v8/test/mjsunit/regress/regress-1849.js +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-1849.js @@ -1,4 +1,4 @@ -// Copyright 2011 the V8 project authors. All rights reserved. +// Copyright 2012 the V8 project authors. All rights reserved. // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: @@ -25,7 +25,7 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// See: http://code.google.com/p/v8/issues/detail?id=1878 +// See: http://code.google.com/p/v8/issues/detail?id=1849 // Flags: --allow-natives-syntax @@ -36,4 +36,4 @@ for (var i = 0; i < count; i++) { arr[i] = 0; } assertFalse(%HasFastDoubleElements(arr)); -assertTrue(%HasFastSmiOnlyElements(arr)); +assertTrue(%HasFastSmiElements(arr)); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-1878.js b/src/3rdparty/v8/test/mjsunit/regress/regress-1878.js index a1648b1..fbc47bd 100644 --- a/src/3rdparty/v8/test/mjsunit/regress/regress-1878.js +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-1878.js @@ -34,11 +34,11 @@ var a = Array(); for (var i = 0; i < 1000; i++) { var ai = natives.InternalArray(10000); assertFalse(%HaveSameMap(ai, a)); - assertTrue(%HasFastElements(ai)); + assertTrue(%HasFastObjectElements(ai)); } for (var i = 0; i < 1000; i++) { var ai = new natives.InternalArray(10000); assertFalse(%HaveSameMap(ai, a)); - assertTrue(%HasFastElements(ai)); + assertTrue(%HasFastObjectElements(ai)); } diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-1969.js b/src/3rdparty/v8/test/mjsunit/regress/regress-1969.js deleted file mode 100644 index 2728c2c..0000000 --- a/src/3rdparty/v8/test/mjsunit/regress/regress-1969.js +++ /dev/null @@ -1,5045 +0,0 @@ -// Copyright 2012 the V8 project authors. All rights reserved. -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following -// disclaimer in the documentation and/or other materials provided -// with the distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived -// from this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Flags: --allow-natives-syntax - -f(); -f(); -%OptimizeFunctionOnNextCall(f); -var start = (new Date()).getTime(); -var array = f(); -var end = (new Date()).getTime(); - -// Assert that recompiling and executing f() takes less than a second. -assertTrue((end - start) < 1000); - -for (var i = 0; i < 5000; i++) assertEquals(0, array[i]); - -function f() { - var a = new Array(5000); - a[0]=0; - a[1]=0; - a[2]=0; - a[3]=0; - a[4]=0; - a[5]=0; - a[6]=0; - a[7]=0; - a[8]=0; - a[9]=0; - a[10]=0; - a[11]=0; - a[12]=0; - a[13]=0; - a[14]=0; - a[15]=0; - a[16]=0; - a[17]=0; - a[18]=0; - a[19]=0; - a[20]=0; - a[21]=0; - a[22]=0; - a[23]=0; - a[24]=0; - a[25]=0; - a[26]=0; - a[27]=0; - a[28]=0; - a[29]=0; - a[30]=0; - a[31]=0; - a[32]=0; - a[33]=0; - a[34]=0; - a[35]=0; - a[36]=0; - a[37]=0; - a[38]=0; - a[39]=0; - a[40]=0; - a[41]=0; - a[42]=0; - a[43]=0; - a[44]=0; - a[45]=0; - a[46]=0; - a[47]=0; - a[48]=0; - a[49]=0; - a[50]=0; - a[51]=0; - a[52]=0; - a[53]=0; - a[54]=0; - a[55]=0; - a[56]=0; - a[57]=0; - a[58]=0; - a[59]=0; - a[60]=0; - a[61]=0; - a[62]=0; - a[63]=0; - a[64]=0; - a[65]=0; - a[66]=0; - a[67]=0; - a[68]=0; - a[69]=0; - a[70]=0; - a[71]=0; - a[72]=0; - a[73]=0; - a[74]=0; - a[75]=0; - a[76]=0; - a[77]=0; - a[78]=0; - a[79]=0; - a[80]=0; - a[81]=0; - a[82]=0; - a[83]=0; - a[84]=0; - a[85]=0; - a[86]=0; - a[87]=0; - a[88]=0; - a[89]=0; - a[90]=0; - a[91]=0; - a[92]=0; - a[93]=0; - a[94]=0; - a[95]=0; - a[96]=0; - a[97]=0; - a[98]=0; - a[99]=0; - a[100]=0; - a[101]=0; - a[102]=0; - a[103]=0; - a[104]=0; - a[105]=0; - a[106]=0; - a[107]=0; - a[108]=0; - a[109]=0; - a[110]=0; - a[111]=0; - a[112]=0; - a[113]=0; - a[114]=0; - a[115]=0; - a[116]=0; - a[117]=0; - a[118]=0; - a[119]=0; - a[120]=0; - a[121]=0; - a[122]=0; - a[123]=0; - a[124]=0; - a[125]=0; - a[126]=0; - a[127]=0; - a[128]=0; - a[129]=0; - a[130]=0; - a[131]=0; - a[132]=0; - a[133]=0; - a[134]=0; - a[135]=0; - a[136]=0; - a[137]=0; - a[138]=0; - a[139]=0; - a[140]=0; - a[141]=0; - a[142]=0; - a[143]=0; - a[144]=0; - a[145]=0; - a[146]=0; - a[147]=0; - a[148]=0; - a[149]=0; - a[150]=0; - a[151]=0; - a[152]=0; - a[153]=0; - a[154]=0; - a[155]=0; - a[156]=0; - a[157]=0; - a[158]=0; - a[159]=0; - a[160]=0; - a[161]=0; - a[162]=0; - a[163]=0; - a[164]=0; - a[165]=0; - a[166]=0; - a[167]=0; - a[168]=0; - a[169]=0; - a[170]=0; - a[171]=0; - a[172]=0; - a[173]=0; - a[174]=0; - a[175]=0; - a[176]=0; - a[177]=0; - a[178]=0; - a[179]=0; - a[180]=0; - a[181]=0; - a[182]=0; - a[183]=0; - a[184]=0; - a[185]=0; - a[186]=0; - a[187]=0; - a[188]=0; - a[189]=0; - a[190]=0; - a[191]=0; - a[192]=0; - a[193]=0; - a[194]=0; - a[195]=0; - a[196]=0; - a[197]=0; - a[198]=0; - a[199]=0; - a[200]=0; - a[201]=0; - a[202]=0; - a[203]=0; - a[204]=0; - a[205]=0; - a[206]=0; - a[207]=0; - a[208]=0; - a[209]=0; - a[210]=0; - a[211]=0; - a[212]=0; - a[213]=0; - a[214]=0; - a[215]=0; - a[216]=0; - a[217]=0; - a[218]=0; - a[219]=0; - a[220]=0; - a[221]=0; - a[222]=0; - a[223]=0; - a[224]=0; - a[225]=0; - a[226]=0; - a[227]=0; - a[228]=0; - a[229]=0; - a[230]=0; - a[231]=0; - a[232]=0; - a[233]=0; - a[234]=0; - a[235]=0; - a[236]=0; - a[237]=0; - a[238]=0; - a[239]=0; - a[240]=0; - a[241]=0; - a[242]=0; - a[243]=0; - a[244]=0; - a[245]=0; - a[246]=0; - a[247]=0; - a[248]=0; - a[249]=0; - a[250]=0; - a[251]=0; - a[252]=0; - a[253]=0; - a[254]=0; - a[255]=0; - a[256]=0; - a[257]=0; - a[258]=0; - a[259]=0; - a[260]=0; - a[261]=0; - a[262]=0; - a[263]=0; - a[264]=0; - a[265]=0; - a[266]=0; - a[267]=0; - a[268]=0; - a[269]=0; - a[270]=0; - a[271]=0; - a[272]=0; - a[273]=0; - a[274]=0; - a[275]=0; - a[276]=0; - a[277]=0; - a[278]=0; - a[279]=0; - a[280]=0; - a[281]=0; - a[282]=0; - a[283]=0; - a[284]=0; - a[285]=0; - a[286]=0; - a[287]=0; - a[288]=0; - a[289]=0; - a[290]=0; - a[291]=0; - a[292]=0; - a[293]=0; - a[294]=0; - a[295]=0; - a[296]=0; - a[297]=0; - a[298]=0; - a[299]=0; - a[300]=0; - a[301]=0; - a[302]=0; - a[303]=0; - a[304]=0; - a[305]=0; - a[306]=0; - a[307]=0; - a[308]=0; - a[309]=0; - a[310]=0; - a[311]=0; - a[312]=0; - a[313]=0; - a[314]=0; - a[315]=0; - a[316]=0; - a[317]=0; - a[318]=0; - a[319]=0; - a[320]=0; - a[321]=0; - a[322]=0; - a[323]=0; - a[324]=0; - a[325]=0; - a[326]=0; - a[327]=0; - a[328]=0; - a[329]=0; - a[330]=0; - a[331]=0; - a[332]=0; - a[333]=0; - a[334]=0; - a[335]=0; - a[336]=0; - a[337]=0; - a[338]=0; - a[339]=0; - a[340]=0; - a[341]=0; - a[342]=0; - a[343]=0; - a[344]=0; - a[345]=0; - a[346]=0; - a[347]=0; - a[348]=0; - a[349]=0; - a[350]=0; - a[351]=0; - a[352]=0; - a[353]=0; - a[354]=0; - a[355]=0; - a[356]=0; - a[357]=0; - a[358]=0; - a[359]=0; - a[360]=0; - a[361]=0; - a[362]=0; - a[363]=0; - a[364]=0; - a[365]=0; - a[366]=0; - a[367]=0; - a[368]=0; - a[369]=0; - a[370]=0; - a[371]=0; - a[372]=0; - a[373]=0; - a[374]=0; - a[375]=0; - a[376]=0; - a[377]=0; - a[378]=0; - a[379]=0; - a[380]=0; - a[381]=0; - a[382]=0; - a[383]=0; - a[384]=0; - a[385]=0; - a[386]=0; - a[387]=0; - a[388]=0; - a[389]=0; - a[390]=0; - a[391]=0; - a[392]=0; - a[393]=0; - a[394]=0; - a[395]=0; - a[396]=0; - a[397]=0; - a[398]=0; - a[399]=0; - a[400]=0; - a[401]=0; - a[402]=0; - a[403]=0; - a[404]=0; - a[405]=0; - a[406]=0; - a[407]=0; - a[408]=0; - a[409]=0; - a[410]=0; - a[411]=0; - a[412]=0; - a[413]=0; - a[414]=0; - a[415]=0; - a[416]=0; - a[417]=0; - a[418]=0; - a[419]=0; - a[420]=0; - a[421]=0; - a[422]=0; - a[423]=0; - a[424]=0; - a[425]=0; - a[426]=0; - a[427]=0; - a[428]=0; - a[429]=0; - a[430]=0; - a[431]=0; - a[432]=0; - a[433]=0; - a[434]=0; - a[435]=0; - a[436]=0; - a[437]=0; - a[438]=0; - a[439]=0; - a[440]=0; - a[441]=0; - a[442]=0; - a[443]=0; - a[444]=0; - a[445]=0; - a[446]=0; - a[447]=0; - a[448]=0; - a[449]=0; - a[450]=0; - a[451]=0; - a[452]=0; - a[453]=0; - a[454]=0; - a[455]=0; - a[456]=0; - a[457]=0; - a[458]=0; - a[459]=0; - a[460]=0; - a[461]=0; - a[462]=0; - a[463]=0; - a[464]=0; - a[465]=0; - a[466]=0; - a[467]=0; - a[468]=0; - a[469]=0; - a[470]=0; - a[471]=0; - a[472]=0; - a[473]=0; - a[474]=0; - a[475]=0; - a[476]=0; - a[477]=0; - a[478]=0; - a[479]=0; - a[480]=0; - a[481]=0; - a[482]=0; - a[483]=0; - a[484]=0; - a[485]=0; - a[486]=0; - a[487]=0; - a[488]=0; - a[489]=0; - a[490]=0; - a[491]=0; - a[492]=0; - a[493]=0; - a[494]=0; - a[495]=0; - a[496]=0; - a[497]=0; - a[498]=0; - a[499]=0; - a[500]=0; - a[501]=0; - a[502]=0; - a[503]=0; - a[504]=0; - a[505]=0; - a[506]=0; - a[507]=0; - a[508]=0; - a[509]=0; - a[510]=0; - a[511]=0; - a[512]=0; - a[513]=0; - a[514]=0; - a[515]=0; - a[516]=0; - a[517]=0; - a[518]=0; - a[519]=0; - a[520]=0; - a[521]=0; - a[522]=0; - a[523]=0; - a[524]=0; - a[525]=0; - a[526]=0; - a[527]=0; - a[528]=0; - a[529]=0; - a[530]=0; - a[531]=0; - a[532]=0; - a[533]=0; - a[534]=0; - a[535]=0; - a[536]=0; - a[537]=0; - a[538]=0; - a[539]=0; - a[540]=0; - a[541]=0; - a[542]=0; - a[543]=0; - a[544]=0; - a[545]=0; - a[546]=0; - a[547]=0; - a[548]=0; - a[549]=0; - a[550]=0; - a[551]=0; - a[552]=0; - a[553]=0; - a[554]=0; - a[555]=0; - a[556]=0; - a[557]=0; - a[558]=0; - a[559]=0; - a[560]=0; - a[561]=0; - a[562]=0; - a[563]=0; - a[564]=0; - a[565]=0; - a[566]=0; - a[567]=0; - a[568]=0; - a[569]=0; - a[570]=0; - a[571]=0; - a[572]=0; - a[573]=0; - a[574]=0; - a[575]=0; - a[576]=0; - a[577]=0; - a[578]=0; - a[579]=0; - a[580]=0; - a[581]=0; - a[582]=0; - a[583]=0; - a[584]=0; - a[585]=0; - a[586]=0; - a[587]=0; - a[588]=0; - a[589]=0; - a[590]=0; - a[591]=0; - a[592]=0; - a[593]=0; - a[594]=0; - a[595]=0; - a[596]=0; - a[597]=0; - a[598]=0; - a[599]=0; - a[600]=0; - a[601]=0; - a[602]=0; - a[603]=0; - a[604]=0; - a[605]=0; - a[606]=0; - a[607]=0; - a[608]=0; - a[609]=0; - a[610]=0; - a[611]=0; - a[612]=0; - a[613]=0; - a[614]=0; - a[615]=0; - a[616]=0; - a[617]=0; - a[618]=0; - a[619]=0; - a[620]=0; - a[621]=0; - a[622]=0; - a[623]=0; - a[624]=0; - a[625]=0; - a[626]=0; - a[627]=0; - a[628]=0; - a[629]=0; - a[630]=0; - a[631]=0; - a[632]=0; - a[633]=0; - a[634]=0; - a[635]=0; - a[636]=0; - a[637]=0; - a[638]=0; - a[639]=0; - a[640]=0; - a[641]=0; - a[642]=0; - a[643]=0; - a[644]=0; - a[645]=0; - a[646]=0; - a[647]=0; - a[648]=0; - a[649]=0; - a[650]=0; - a[651]=0; - a[652]=0; - a[653]=0; - a[654]=0; - a[655]=0; - a[656]=0; - a[657]=0; - a[658]=0; - a[659]=0; - a[660]=0; - a[661]=0; - a[662]=0; - a[663]=0; - a[664]=0; - a[665]=0; - a[666]=0; - a[667]=0; - a[668]=0; - a[669]=0; - a[670]=0; - a[671]=0; - a[672]=0; - a[673]=0; - a[674]=0; - a[675]=0; - a[676]=0; - a[677]=0; - a[678]=0; - a[679]=0; - a[680]=0; - a[681]=0; - a[682]=0; - a[683]=0; - a[684]=0; - a[685]=0; - a[686]=0; - a[687]=0; - a[688]=0; - a[689]=0; - a[690]=0; - a[691]=0; - a[692]=0; - a[693]=0; - a[694]=0; - a[695]=0; - a[696]=0; - a[697]=0; - a[698]=0; - a[699]=0; - a[700]=0; - a[701]=0; - a[702]=0; - a[703]=0; - a[704]=0; - a[705]=0; - a[706]=0; - a[707]=0; - a[708]=0; - a[709]=0; - a[710]=0; - a[711]=0; - a[712]=0; - a[713]=0; - a[714]=0; - a[715]=0; - a[716]=0; - a[717]=0; - a[718]=0; - a[719]=0; - a[720]=0; - a[721]=0; - a[722]=0; - a[723]=0; - a[724]=0; - a[725]=0; - a[726]=0; - a[727]=0; - a[728]=0; - a[729]=0; - a[730]=0; - a[731]=0; - a[732]=0; - a[733]=0; - a[734]=0; - a[735]=0; - a[736]=0; - a[737]=0; - a[738]=0; - a[739]=0; - a[740]=0; - a[741]=0; - a[742]=0; - a[743]=0; - a[744]=0; - a[745]=0; - a[746]=0; - a[747]=0; - a[748]=0; - a[749]=0; - a[750]=0; - a[751]=0; - a[752]=0; - a[753]=0; - a[754]=0; - a[755]=0; - a[756]=0; - a[757]=0; - a[758]=0; - a[759]=0; - a[760]=0; - a[761]=0; - a[762]=0; - a[763]=0; - a[764]=0; - a[765]=0; - a[766]=0; - a[767]=0; - a[768]=0; - a[769]=0; - a[770]=0; - a[771]=0; - a[772]=0; - a[773]=0; - a[774]=0; - a[775]=0; - a[776]=0; - a[777]=0; - a[778]=0; - a[779]=0; - a[780]=0; - a[781]=0; - a[782]=0; - a[783]=0; - a[784]=0; - a[785]=0; - a[786]=0; - a[787]=0; - a[788]=0; - a[789]=0; - a[790]=0; - a[791]=0; - a[792]=0; - a[793]=0; - a[794]=0; - a[795]=0; - a[796]=0; - a[797]=0; - a[798]=0; - a[799]=0; - a[800]=0; - a[801]=0; - a[802]=0; - a[803]=0; - a[804]=0; - a[805]=0; - a[806]=0; - a[807]=0; - a[808]=0; - a[809]=0; - a[810]=0; - a[811]=0; - a[812]=0; - a[813]=0; - a[814]=0; - a[815]=0; - a[816]=0; - a[817]=0; - a[818]=0; - a[819]=0; - a[820]=0; - a[821]=0; - a[822]=0; - a[823]=0; - a[824]=0; - a[825]=0; - a[826]=0; - a[827]=0; - a[828]=0; - a[829]=0; - a[830]=0; - a[831]=0; - a[832]=0; - a[833]=0; - a[834]=0; - a[835]=0; - a[836]=0; - a[837]=0; - a[838]=0; - a[839]=0; - a[840]=0; - a[841]=0; - a[842]=0; - a[843]=0; - a[844]=0; - a[845]=0; - a[846]=0; - a[847]=0; - a[848]=0; - a[849]=0; - a[850]=0; - a[851]=0; - a[852]=0; - a[853]=0; - a[854]=0; - a[855]=0; - a[856]=0; - a[857]=0; - a[858]=0; - a[859]=0; - a[860]=0; - a[861]=0; - a[862]=0; - a[863]=0; - a[864]=0; - a[865]=0; - a[866]=0; - a[867]=0; - a[868]=0; - a[869]=0; - a[870]=0; - a[871]=0; - a[872]=0; - a[873]=0; - a[874]=0; - a[875]=0; - a[876]=0; - a[877]=0; - a[878]=0; - a[879]=0; - a[880]=0; - a[881]=0; - a[882]=0; - a[883]=0; - a[884]=0; - a[885]=0; - a[886]=0; - a[887]=0; - a[888]=0; - a[889]=0; - a[890]=0; - a[891]=0; - a[892]=0; - a[893]=0; - a[894]=0; - a[895]=0; - a[896]=0; - a[897]=0; - a[898]=0; - a[899]=0; - a[900]=0; - a[901]=0; - a[902]=0; - a[903]=0; - a[904]=0; - a[905]=0; - a[906]=0; - a[907]=0; - a[908]=0; - a[909]=0; - a[910]=0; - a[911]=0; - a[912]=0; - a[913]=0; - a[914]=0; - a[915]=0; - a[916]=0; - a[917]=0; - a[918]=0; - a[919]=0; - a[920]=0; - a[921]=0; - a[922]=0; - a[923]=0; - a[924]=0; - a[925]=0; - a[926]=0; - a[927]=0; - a[928]=0; - a[929]=0; - a[930]=0; - a[931]=0; - a[932]=0; - a[933]=0; - a[934]=0; - a[935]=0; - a[936]=0; - a[937]=0; - a[938]=0; - a[939]=0; - a[940]=0; - a[941]=0; - a[942]=0; - a[943]=0; - a[944]=0; - a[945]=0; - a[946]=0; - a[947]=0; - a[948]=0; - a[949]=0; - a[950]=0; - a[951]=0; - a[952]=0; - a[953]=0; - a[954]=0; - a[955]=0; - a[956]=0; - a[957]=0; - a[958]=0; - a[959]=0; - a[960]=0; - a[961]=0; - a[962]=0; - a[963]=0; - a[964]=0; - a[965]=0; - a[966]=0; - a[967]=0; - a[968]=0; - a[969]=0; - a[970]=0; - a[971]=0; - a[972]=0; - a[973]=0; - a[974]=0; - a[975]=0; - a[976]=0; - a[977]=0; - a[978]=0; - a[979]=0; - a[980]=0; - a[981]=0; - a[982]=0; - a[983]=0; - a[984]=0; - a[985]=0; - a[986]=0; - a[987]=0; - a[988]=0; - a[989]=0; - a[990]=0; - a[991]=0; - a[992]=0; - a[993]=0; - a[994]=0; - a[995]=0; - a[996]=0; - a[997]=0; - a[998]=0; - a[999]=0; - a[1000]=0; - a[1001]=0; - a[1002]=0; - a[1003]=0; - a[1004]=0; - a[1005]=0; - a[1006]=0; - a[1007]=0; - a[1008]=0; - a[1009]=0; - a[1010]=0; - a[1011]=0; - a[1012]=0; - a[1013]=0; - a[1014]=0; - a[1015]=0; - a[1016]=0; - a[1017]=0; - a[1018]=0; - a[1019]=0; - a[1020]=0; - a[1021]=0; - a[1022]=0; - a[1023]=0; - a[1024]=0; - a[1025]=0; - a[1026]=0; - a[1027]=0; - a[1028]=0; - a[1029]=0; - a[1030]=0; - a[1031]=0; - a[1032]=0; - a[1033]=0; - a[1034]=0; - a[1035]=0; - a[1036]=0; - a[1037]=0; - a[1038]=0; - a[1039]=0; - a[1040]=0; - a[1041]=0; - a[1042]=0; - a[1043]=0; - a[1044]=0; - a[1045]=0; - a[1046]=0; - a[1047]=0; - a[1048]=0; - a[1049]=0; - a[1050]=0; - a[1051]=0; - a[1052]=0; - a[1053]=0; - a[1054]=0; - a[1055]=0; - a[1056]=0; - a[1057]=0; - a[1058]=0; - a[1059]=0; - a[1060]=0; - a[1061]=0; - a[1062]=0; - a[1063]=0; - a[1064]=0; - a[1065]=0; - a[1066]=0; - a[1067]=0; - a[1068]=0; - a[1069]=0; - a[1070]=0; - a[1071]=0; - a[1072]=0; - a[1073]=0; - a[1074]=0; - a[1075]=0; - a[1076]=0; - a[1077]=0; - a[1078]=0; - a[1079]=0; - a[1080]=0; - a[1081]=0; - a[1082]=0; - a[1083]=0; - a[1084]=0; - a[1085]=0; - a[1086]=0; - a[1087]=0; - a[1088]=0; - a[1089]=0; - a[1090]=0; - a[1091]=0; - a[1092]=0; - a[1093]=0; - a[1094]=0; - a[1095]=0; - a[1096]=0; - a[1097]=0; - a[1098]=0; - a[1099]=0; - a[1100]=0; - a[1101]=0; - a[1102]=0; - a[1103]=0; - a[1104]=0; - a[1105]=0; - a[1106]=0; - a[1107]=0; - a[1108]=0; - a[1109]=0; - a[1110]=0; - a[1111]=0; - a[1112]=0; - a[1113]=0; - a[1114]=0; - a[1115]=0; - a[1116]=0; - a[1117]=0; - a[1118]=0; - a[1119]=0; - a[1120]=0; - a[1121]=0; - a[1122]=0; - a[1123]=0; - a[1124]=0; - a[1125]=0; - a[1126]=0; - a[1127]=0; - a[1128]=0; - a[1129]=0; - a[1130]=0; - a[1131]=0; - a[1132]=0; - a[1133]=0; - a[1134]=0; - a[1135]=0; - a[1136]=0; - a[1137]=0; - a[1138]=0; - a[1139]=0; - a[1140]=0; - a[1141]=0; - a[1142]=0; - a[1143]=0; - a[1144]=0; - a[1145]=0; - a[1146]=0; - a[1147]=0; - a[1148]=0; - a[1149]=0; - a[1150]=0; - a[1151]=0; - a[1152]=0; - a[1153]=0; - a[1154]=0; - a[1155]=0; - a[1156]=0; - a[1157]=0; - a[1158]=0; - a[1159]=0; - a[1160]=0; - a[1161]=0; - a[1162]=0; - a[1163]=0; - a[1164]=0; - a[1165]=0; - a[1166]=0; - a[1167]=0; - a[1168]=0; - a[1169]=0; - a[1170]=0; - a[1171]=0; - a[1172]=0; - a[1173]=0; - a[1174]=0; - a[1175]=0; - a[1176]=0; - a[1177]=0; - a[1178]=0; - a[1179]=0; - a[1180]=0; - a[1181]=0; - a[1182]=0; - a[1183]=0; - a[1184]=0; - a[1185]=0; - a[1186]=0; - a[1187]=0; - a[1188]=0; - a[1189]=0; - a[1190]=0; - a[1191]=0; - a[1192]=0; - a[1193]=0; - a[1194]=0; - a[1195]=0; - a[1196]=0; - a[1197]=0; - a[1198]=0; - a[1199]=0; - a[1200]=0; - a[1201]=0; - a[1202]=0; - a[1203]=0; - a[1204]=0; - a[1205]=0; - a[1206]=0; - a[1207]=0; - a[1208]=0; - a[1209]=0; - a[1210]=0; - a[1211]=0; - a[1212]=0; - a[1213]=0; - a[1214]=0; - a[1215]=0; - a[1216]=0; - a[1217]=0; - a[1218]=0; - a[1219]=0; - a[1220]=0; - a[1221]=0; - a[1222]=0; - a[1223]=0; - a[1224]=0; - a[1225]=0; - a[1226]=0; - a[1227]=0; - a[1228]=0; - a[1229]=0; - a[1230]=0; - a[1231]=0; - a[1232]=0; - a[1233]=0; - a[1234]=0; - a[1235]=0; - a[1236]=0; - a[1237]=0; - a[1238]=0; - a[1239]=0; - a[1240]=0; - a[1241]=0; - a[1242]=0; - a[1243]=0; - a[1244]=0; - a[1245]=0; - a[1246]=0; - a[1247]=0; - a[1248]=0; - a[1249]=0; - a[1250]=0; - a[1251]=0; - a[1252]=0; - a[1253]=0; - a[1254]=0; - a[1255]=0; - a[1256]=0; - a[1257]=0; - a[1258]=0; - a[1259]=0; - a[1260]=0; - a[1261]=0; - a[1262]=0; - a[1263]=0; - a[1264]=0; - a[1265]=0; - a[1266]=0; - a[1267]=0; - a[1268]=0; - a[1269]=0; - a[1270]=0; - a[1271]=0; - a[1272]=0; - a[1273]=0; - a[1274]=0; - a[1275]=0; - a[1276]=0; - a[1277]=0; - a[1278]=0; - a[1279]=0; - a[1280]=0; - a[1281]=0; - a[1282]=0; - a[1283]=0; - a[1284]=0; - a[1285]=0; - a[1286]=0; - a[1287]=0; - a[1288]=0; - a[1289]=0; - a[1290]=0; - a[1291]=0; - a[1292]=0; - a[1293]=0; - a[1294]=0; - a[1295]=0; - a[1296]=0; - a[1297]=0; - a[1298]=0; - a[1299]=0; - a[1300]=0; - a[1301]=0; - a[1302]=0; - a[1303]=0; - a[1304]=0; - a[1305]=0; - a[1306]=0; - a[1307]=0; - a[1308]=0; - a[1309]=0; - a[1310]=0; - a[1311]=0; - a[1312]=0; - a[1313]=0; - a[1314]=0; - a[1315]=0; - a[1316]=0; - a[1317]=0; - a[1318]=0; - a[1319]=0; - a[1320]=0; - a[1321]=0; - a[1322]=0; - a[1323]=0; - a[1324]=0; - a[1325]=0; - a[1326]=0; - a[1327]=0; - a[1328]=0; - a[1329]=0; - a[1330]=0; - a[1331]=0; - a[1332]=0; - a[1333]=0; - a[1334]=0; - a[1335]=0; - a[1336]=0; - a[1337]=0; - a[1338]=0; - a[1339]=0; - a[1340]=0; - a[1341]=0; - a[1342]=0; - a[1343]=0; - a[1344]=0; - a[1345]=0; - a[1346]=0; - a[1347]=0; - a[1348]=0; - a[1349]=0; - a[1350]=0; - a[1351]=0; - a[1352]=0; - a[1353]=0; - a[1354]=0; - a[1355]=0; - a[1356]=0; - a[1357]=0; - a[1358]=0; - a[1359]=0; - a[1360]=0; - a[1361]=0; - a[1362]=0; - a[1363]=0; - a[1364]=0; - a[1365]=0; - a[1366]=0; - a[1367]=0; - a[1368]=0; - a[1369]=0; - a[1370]=0; - a[1371]=0; - a[1372]=0; - a[1373]=0; - a[1374]=0; - a[1375]=0; - a[1376]=0; - a[1377]=0; - a[1378]=0; - a[1379]=0; - a[1380]=0; - a[1381]=0; - a[1382]=0; - a[1383]=0; - a[1384]=0; - a[1385]=0; - a[1386]=0; - a[1387]=0; - a[1388]=0; - a[1389]=0; - a[1390]=0; - a[1391]=0; - a[1392]=0; - a[1393]=0; - a[1394]=0; - a[1395]=0; - a[1396]=0; - a[1397]=0; - a[1398]=0; - a[1399]=0; - a[1400]=0; - a[1401]=0; - a[1402]=0; - a[1403]=0; - a[1404]=0; - a[1405]=0; - a[1406]=0; - a[1407]=0; - a[1408]=0; - a[1409]=0; - a[1410]=0; - a[1411]=0; - a[1412]=0; - a[1413]=0; - a[1414]=0; - a[1415]=0; - a[1416]=0; - a[1417]=0; - a[1418]=0; - a[1419]=0; - a[1420]=0; - a[1421]=0; - a[1422]=0; - a[1423]=0; - a[1424]=0; - a[1425]=0; - a[1426]=0; - a[1427]=0; - a[1428]=0; - a[1429]=0; - a[1430]=0; - a[1431]=0; - a[1432]=0; - a[1433]=0; - a[1434]=0; - a[1435]=0; - a[1436]=0; - a[1437]=0; - a[1438]=0; - a[1439]=0; - a[1440]=0; - a[1441]=0; - a[1442]=0; - a[1443]=0; - a[1444]=0; - a[1445]=0; - a[1446]=0; - a[1447]=0; - a[1448]=0; - a[1449]=0; - a[1450]=0; - a[1451]=0; - a[1452]=0; - a[1453]=0; - a[1454]=0; - a[1455]=0; - a[1456]=0; - a[1457]=0; - a[1458]=0; - a[1459]=0; - a[1460]=0; - a[1461]=0; - a[1462]=0; - a[1463]=0; - a[1464]=0; - a[1465]=0; - a[1466]=0; - a[1467]=0; - a[1468]=0; - a[1469]=0; - a[1470]=0; - a[1471]=0; - a[1472]=0; - a[1473]=0; - a[1474]=0; - a[1475]=0; - a[1476]=0; - a[1477]=0; - a[1478]=0; - a[1479]=0; - a[1480]=0; - a[1481]=0; - a[1482]=0; - a[1483]=0; - a[1484]=0; - a[1485]=0; - a[1486]=0; - a[1487]=0; - a[1488]=0; - a[1489]=0; - a[1490]=0; - a[1491]=0; - a[1492]=0; - a[1493]=0; - a[1494]=0; - a[1495]=0; - a[1496]=0; - a[1497]=0; - a[1498]=0; - a[1499]=0; - a[1500]=0; - a[1501]=0; - a[1502]=0; - a[1503]=0; - a[1504]=0; - a[1505]=0; - a[1506]=0; - a[1507]=0; - a[1508]=0; - a[1509]=0; - a[1510]=0; - a[1511]=0; - a[1512]=0; - a[1513]=0; - a[1514]=0; - a[1515]=0; - a[1516]=0; - a[1517]=0; - a[1518]=0; - a[1519]=0; - a[1520]=0; - a[1521]=0; - a[1522]=0; - a[1523]=0; - a[1524]=0; - a[1525]=0; - a[1526]=0; - a[1527]=0; - a[1528]=0; - a[1529]=0; - a[1530]=0; - a[1531]=0; - a[1532]=0; - a[1533]=0; - a[1534]=0; - a[1535]=0; - a[1536]=0; - a[1537]=0; - a[1538]=0; - a[1539]=0; - a[1540]=0; - a[1541]=0; - a[1542]=0; - a[1543]=0; - a[1544]=0; - a[1545]=0; - a[1546]=0; - a[1547]=0; - a[1548]=0; - a[1549]=0; - a[1550]=0; - a[1551]=0; - a[1552]=0; - a[1553]=0; - a[1554]=0; - a[1555]=0; - a[1556]=0; - a[1557]=0; - a[1558]=0; - a[1559]=0; - a[1560]=0; - a[1561]=0; - a[1562]=0; - a[1563]=0; - a[1564]=0; - a[1565]=0; - a[1566]=0; - a[1567]=0; - a[1568]=0; - a[1569]=0; - a[1570]=0; - a[1571]=0; - a[1572]=0; - a[1573]=0; - a[1574]=0; - a[1575]=0; - a[1576]=0; - a[1577]=0; - a[1578]=0; - a[1579]=0; - a[1580]=0; - a[1581]=0; - a[1582]=0; - a[1583]=0; - a[1584]=0; - a[1585]=0; - a[1586]=0; - a[1587]=0; - a[1588]=0; - a[1589]=0; - a[1590]=0; - a[1591]=0; - a[1592]=0; - a[1593]=0; - a[1594]=0; - a[1595]=0; - a[1596]=0; - a[1597]=0; - a[1598]=0; - a[1599]=0; - a[1600]=0; - a[1601]=0; - a[1602]=0; - a[1603]=0; - a[1604]=0; - a[1605]=0; - a[1606]=0; - a[1607]=0; - a[1608]=0; - a[1609]=0; - a[1610]=0; - a[1611]=0; - a[1612]=0; - a[1613]=0; - a[1614]=0; - a[1615]=0; - a[1616]=0; - a[1617]=0; - a[1618]=0; - a[1619]=0; - a[1620]=0; - a[1621]=0; - a[1622]=0; - a[1623]=0; - a[1624]=0; - a[1625]=0; - a[1626]=0; - a[1627]=0; - a[1628]=0; - a[1629]=0; - a[1630]=0; - a[1631]=0; - a[1632]=0; - a[1633]=0; - a[1634]=0; - a[1635]=0; - a[1636]=0; - a[1637]=0; - a[1638]=0; - a[1639]=0; - a[1640]=0; - a[1641]=0; - a[1642]=0; - a[1643]=0; - a[1644]=0; - a[1645]=0; - a[1646]=0; - a[1647]=0; - a[1648]=0; - a[1649]=0; - a[1650]=0; - a[1651]=0; - a[1652]=0; - a[1653]=0; - a[1654]=0; - a[1655]=0; - a[1656]=0; - a[1657]=0; - a[1658]=0; - a[1659]=0; - a[1660]=0; - a[1661]=0; - a[1662]=0; - a[1663]=0; - a[1664]=0; - a[1665]=0; - a[1666]=0; - a[1667]=0; - a[1668]=0; - a[1669]=0; - a[1670]=0; - a[1671]=0; - a[1672]=0; - a[1673]=0; - a[1674]=0; - a[1675]=0; - a[1676]=0; - a[1677]=0; - a[1678]=0; - a[1679]=0; - a[1680]=0; - a[1681]=0; - a[1682]=0; - a[1683]=0; - a[1684]=0; - a[1685]=0; - a[1686]=0; - a[1687]=0; - a[1688]=0; - a[1689]=0; - a[1690]=0; - a[1691]=0; - a[1692]=0; - a[1693]=0; - a[1694]=0; - a[1695]=0; - a[1696]=0; - a[1697]=0; - a[1698]=0; - a[1699]=0; - a[1700]=0; - a[1701]=0; - a[1702]=0; - a[1703]=0; - a[1704]=0; - a[1705]=0; - a[1706]=0; - a[1707]=0; - a[1708]=0; - a[1709]=0; - a[1710]=0; - a[1711]=0; - a[1712]=0; - a[1713]=0; - a[1714]=0; - a[1715]=0; - a[1716]=0; - a[1717]=0; - a[1718]=0; - a[1719]=0; - a[1720]=0; - a[1721]=0; - a[1722]=0; - a[1723]=0; - a[1724]=0; - a[1725]=0; - a[1726]=0; - a[1727]=0; - a[1728]=0; - a[1729]=0; - a[1730]=0; - a[1731]=0; - a[1732]=0; - a[1733]=0; - a[1734]=0; - a[1735]=0; - a[1736]=0; - a[1737]=0; - a[1738]=0; - a[1739]=0; - a[1740]=0; - a[1741]=0; - a[1742]=0; - a[1743]=0; - a[1744]=0; - a[1745]=0; - a[1746]=0; - a[1747]=0; - a[1748]=0; - a[1749]=0; - a[1750]=0; - a[1751]=0; - a[1752]=0; - a[1753]=0; - a[1754]=0; - a[1755]=0; - a[1756]=0; - a[1757]=0; - a[1758]=0; - a[1759]=0; - a[1760]=0; - a[1761]=0; - a[1762]=0; - a[1763]=0; - a[1764]=0; - a[1765]=0; - a[1766]=0; - a[1767]=0; - a[1768]=0; - a[1769]=0; - a[1770]=0; - a[1771]=0; - a[1772]=0; - a[1773]=0; - a[1774]=0; - a[1775]=0; - a[1776]=0; - a[1777]=0; - a[1778]=0; - a[1779]=0; - a[1780]=0; - a[1781]=0; - a[1782]=0; - a[1783]=0; - a[1784]=0; - a[1785]=0; - a[1786]=0; - a[1787]=0; - a[1788]=0; - a[1789]=0; - a[1790]=0; - a[1791]=0; - a[1792]=0; - a[1793]=0; - a[1794]=0; - a[1795]=0; - a[1796]=0; - a[1797]=0; - a[1798]=0; - a[1799]=0; - a[1800]=0; - a[1801]=0; - a[1802]=0; - a[1803]=0; - a[1804]=0; - a[1805]=0; - a[1806]=0; - a[1807]=0; - a[1808]=0; - a[1809]=0; - a[1810]=0; - a[1811]=0; - a[1812]=0; - a[1813]=0; - a[1814]=0; - a[1815]=0; - a[1816]=0; - a[1817]=0; - a[1818]=0; - a[1819]=0; - a[1820]=0; - a[1821]=0; - a[1822]=0; - a[1823]=0; - a[1824]=0; - a[1825]=0; - a[1826]=0; - a[1827]=0; - a[1828]=0; - a[1829]=0; - a[1830]=0; - a[1831]=0; - a[1832]=0; - a[1833]=0; - a[1834]=0; - a[1835]=0; - a[1836]=0; - a[1837]=0; - a[1838]=0; - a[1839]=0; - a[1840]=0; - a[1841]=0; - a[1842]=0; - a[1843]=0; - a[1844]=0; - a[1845]=0; - a[1846]=0; - a[1847]=0; - a[1848]=0; - a[1849]=0; - a[1850]=0; - a[1851]=0; - a[1852]=0; - a[1853]=0; - a[1854]=0; - a[1855]=0; - a[1856]=0; - a[1857]=0; - a[1858]=0; - a[1859]=0; - a[1860]=0; - a[1861]=0; - a[1862]=0; - a[1863]=0; - a[1864]=0; - a[1865]=0; - a[1866]=0; - a[1867]=0; - a[1868]=0; - a[1869]=0; - a[1870]=0; - a[1871]=0; - a[1872]=0; - a[1873]=0; - a[1874]=0; - a[1875]=0; - a[1876]=0; - a[1877]=0; - a[1878]=0; - a[1879]=0; - a[1880]=0; - a[1881]=0; - a[1882]=0; - a[1883]=0; - a[1884]=0; - a[1885]=0; - a[1886]=0; - a[1887]=0; - a[1888]=0; - a[1889]=0; - a[1890]=0; - a[1891]=0; - a[1892]=0; - a[1893]=0; - a[1894]=0; - a[1895]=0; - a[1896]=0; - a[1897]=0; - a[1898]=0; - a[1899]=0; - a[1900]=0; - a[1901]=0; - a[1902]=0; - a[1903]=0; - a[1904]=0; - a[1905]=0; - a[1906]=0; - a[1907]=0; - a[1908]=0; - a[1909]=0; - a[1910]=0; - a[1911]=0; - a[1912]=0; - a[1913]=0; - a[1914]=0; - a[1915]=0; - a[1916]=0; - a[1917]=0; - a[1918]=0; - a[1919]=0; - a[1920]=0; - a[1921]=0; - a[1922]=0; - a[1923]=0; - a[1924]=0; - a[1925]=0; - a[1926]=0; - a[1927]=0; - a[1928]=0; - a[1929]=0; - a[1930]=0; - a[1931]=0; - a[1932]=0; - a[1933]=0; - a[1934]=0; - a[1935]=0; - a[1936]=0; - a[1937]=0; - a[1938]=0; - a[1939]=0; - a[1940]=0; - a[1941]=0; - a[1942]=0; - a[1943]=0; - a[1944]=0; - a[1945]=0; - a[1946]=0; - a[1947]=0; - a[1948]=0; - a[1949]=0; - a[1950]=0; - a[1951]=0; - a[1952]=0; - a[1953]=0; - a[1954]=0; - a[1955]=0; - a[1956]=0; - a[1957]=0; - a[1958]=0; - a[1959]=0; - a[1960]=0; - a[1961]=0; - a[1962]=0; - a[1963]=0; - a[1964]=0; - a[1965]=0; - a[1966]=0; - a[1967]=0; - a[1968]=0; - a[1969]=0; - a[1970]=0; - a[1971]=0; - a[1972]=0; - a[1973]=0; - a[1974]=0; - a[1975]=0; - a[1976]=0; - a[1977]=0; - a[1978]=0; - a[1979]=0; - a[1980]=0; - a[1981]=0; - a[1982]=0; - a[1983]=0; - a[1984]=0; - a[1985]=0; - a[1986]=0; - a[1987]=0; - a[1988]=0; - a[1989]=0; - a[1990]=0; - a[1991]=0; - a[1992]=0; - a[1993]=0; - a[1994]=0; - a[1995]=0; - a[1996]=0; - a[1997]=0; - a[1998]=0; - a[1999]=0; - a[2000]=0; - a[2001]=0; - a[2002]=0; - a[2003]=0; - a[2004]=0; - a[2005]=0; - a[2006]=0; - a[2007]=0; - a[2008]=0; - a[2009]=0; - a[2010]=0; - a[2011]=0; - a[2012]=0; - a[2013]=0; - a[2014]=0; - a[2015]=0; - a[2016]=0; - a[2017]=0; - a[2018]=0; - a[2019]=0; - a[2020]=0; - a[2021]=0; - a[2022]=0; - a[2023]=0; - a[2024]=0; - a[2025]=0; - a[2026]=0; - a[2027]=0; - a[2028]=0; - a[2029]=0; - a[2030]=0; - a[2031]=0; - a[2032]=0; - a[2033]=0; - a[2034]=0; - a[2035]=0; - a[2036]=0; - a[2037]=0; - a[2038]=0; - a[2039]=0; - a[2040]=0; - a[2041]=0; - a[2042]=0; - a[2043]=0; - a[2044]=0; - a[2045]=0; - a[2046]=0; - a[2047]=0; - a[2048]=0; - a[2049]=0; - a[2050]=0; - a[2051]=0; - a[2052]=0; - a[2053]=0; - a[2054]=0; - a[2055]=0; - a[2056]=0; - a[2057]=0; - a[2058]=0; - a[2059]=0; - a[2060]=0; - a[2061]=0; - a[2062]=0; - a[2063]=0; - a[2064]=0; - a[2065]=0; - a[2066]=0; - a[2067]=0; - a[2068]=0; - a[2069]=0; - a[2070]=0; - a[2071]=0; - a[2072]=0; - a[2073]=0; - a[2074]=0; - a[2075]=0; - a[2076]=0; - a[2077]=0; - a[2078]=0; - a[2079]=0; - a[2080]=0; - a[2081]=0; - a[2082]=0; - a[2083]=0; - a[2084]=0; - a[2085]=0; - a[2086]=0; - a[2087]=0; - a[2088]=0; - a[2089]=0; - a[2090]=0; - a[2091]=0; - a[2092]=0; - a[2093]=0; - a[2094]=0; - a[2095]=0; - a[2096]=0; - a[2097]=0; - a[2098]=0; - a[2099]=0; - a[2100]=0; - a[2101]=0; - a[2102]=0; - a[2103]=0; - a[2104]=0; - a[2105]=0; - a[2106]=0; - a[2107]=0; - a[2108]=0; - a[2109]=0; - a[2110]=0; - a[2111]=0; - a[2112]=0; - a[2113]=0; - a[2114]=0; - a[2115]=0; - a[2116]=0; - a[2117]=0; - a[2118]=0; - a[2119]=0; - a[2120]=0; - a[2121]=0; - a[2122]=0; - a[2123]=0; - a[2124]=0; - a[2125]=0; - a[2126]=0; - a[2127]=0; - a[2128]=0; - a[2129]=0; - a[2130]=0; - a[2131]=0; - a[2132]=0; - a[2133]=0; - a[2134]=0; - a[2135]=0; - a[2136]=0; - a[2137]=0; - a[2138]=0; - a[2139]=0; - a[2140]=0; - a[2141]=0; - a[2142]=0; - a[2143]=0; - a[2144]=0; - a[2145]=0; - a[2146]=0; - a[2147]=0; - a[2148]=0; - a[2149]=0; - a[2150]=0; - a[2151]=0; - a[2152]=0; - a[2153]=0; - a[2154]=0; - a[2155]=0; - a[2156]=0; - a[2157]=0; - a[2158]=0; - a[2159]=0; - a[2160]=0; - a[2161]=0; - a[2162]=0; - a[2163]=0; - a[2164]=0; - a[2165]=0; - a[2166]=0; - a[2167]=0; - a[2168]=0; - a[2169]=0; - a[2170]=0; - a[2171]=0; - a[2172]=0; - a[2173]=0; - a[2174]=0; - a[2175]=0; - a[2176]=0; - a[2177]=0; - a[2178]=0; - a[2179]=0; - a[2180]=0; - a[2181]=0; - a[2182]=0; - a[2183]=0; - a[2184]=0; - a[2185]=0; - a[2186]=0; - a[2187]=0; - a[2188]=0; - a[2189]=0; - a[2190]=0; - a[2191]=0; - a[2192]=0; - a[2193]=0; - a[2194]=0; - a[2195]=0; - a[2196]=0; - a[2197]=0; - a[2198]=0; - a[2199]=0; - a[2200]=0; - a[2201]=0; - a[2202]=0; - a[2203]=0; - a[2204]=0; - a[2205]=0; - a[2206]=0; - a[2207]=0; - a[2208]=0; - a[2209]=0; - a[2210]=0; - a[2211]=0; - a[2212]=0; - a[2213]=0; - a[2214]=0; - a[2215]=0; - a[2216]=0; - a[2217]=0; - a[2218]=0; - a[2219]=0; - a[2220]=0; - a[2221]=0; - a[2222]=0; - a[2223]=0; - a[2224]=0; - a[2225]=0; - a[2226]=0; - a[2227]=0; - a[2228]=0; - a[2229]=0; - a[2230]=0; - a[2231]=0; - a[2232]=0; - a[2233]=0; - a[2234]=0; - a[2235]=0; - a[2236]=0; - a[2237]=0; - a[2238]=0; - a[2239]=0; - a[2240]=0; - a[2241]=0; - a[2242]=0; - a[2243]=0; - a[2244]=0; - a[2245]=0; - a[2246]=0; - a[2247]=0; - a[2248]=0; - a[2249]=0; - a[2250]=0; - a[2251]=0; - a[2252]=0; - a[2253]=0; - a[2254]=0; - a[2255]=0; - a[2256]=0; - a[2257]=0; - a[2258]=0; - a[2259]=0; - a[2260]=0; - a[2261]=0; - a[2262]=0; - a[2263]=0; - a[2264]=0; - a[2265]=0; - a[2266]=0; - a[2267]=0; - a[2268]=0; - a[2269]=0; - a[2270]=0; - a[2271]=0; - a[2272]=0; - a[2273]=0; - a[2274]=0; - a[2275]=0; - a[2276]=0; - a[2277]=0; - a[2278]=0; - a[2279]=0; - a[2280]=0; - a[2281]=0; - a[2282]=0; - a[2283]=0; - a[2284]=0; - a[2285]=0; - a[2286]=0; - a[2287]=0; - a[2288]=0; - a[2289]=0; - a[2290]=0; - a[2291]=0; - a[2292]=0; - a[2293]=0; - a[2294]=0; - a[2295]=0; - a[2296]=0; - a[2297]=0; - a[2298]=0; - a[2299]=0; - a[2300]=0; - a[2301]=0; - a[2302]=0; - a[2303]=0; - a[2304]=0; - a[2305]=0; - a[2306]=0; - a[2307]=0; - a[2308]=0; - a[2309]=0; - a[2310]=0; - a[2311]=0; - a[2312]=0; - a[2313]=0; - a[2314]=0; - a[2315]=0; - a[2316]=0; - a[2317]=0; - a[2318]=0; - a[2319]=0; - a[2320]=0; - a[2321]=0; - a[2322]=0; - a[2323]=0; - a[2324]=0; - a[2325]=0; - a[2326]=0; - a[2327]=0; - a[2328]=0; - a[2329]=0; - a[2330]=0; - a[2331]=0; - a[2332]=0; - a[2333]=0; - a[2334]=0; - a[2335]=0; - a[2336]=0; - a[2337]=0; - a[2338]=0; - a[2339]=0; - a[2340]=0; - a[2341]=0; - a[2342]=0; - a[2343]=0; - a[2344]=0; - a[2345]=0; - a[2346]=0; - a[2347]=0; - a[2348]=0; - a[2349]=0; - a[2350]=0; - a[2351]=0; - a[2352]=0; - a[2353]=0; - a[2354]=0; - a[2355]=0; - a[2356]=0; - a[2357]=0; - a[2358]=0; - a[2359]=0; - a[2360]=0; - a[2361]=0; - a[2362]=0; - a[2363]=0; - a[2364]=0; - a[2365]=0; - a[2366]=0; - a[2367]=0; - a[2368]=0; - a[2369]=0; - a[2370]=0; - a[2371]=0; - a[2372]=0; - a[2373]=0; - a[2374]=0; - a[2375]=0; - a[2376]=0; - a[2377]=0; - a[2378]=0; - a[2379]=0; - a[2380]=0; - a[2381]=0; - a[2382]=0; - a[2383]=0; - a[2384]=0; - a[2385]=0; - a[2386]=0; - a[2387]=0; - a[2388]=0; - a[2389]=0; - a[2390]=0; - a[2391]=0; - a[2392]=0; - a[2393]=0; - a[2394]=0; - a[2395]=0; - a[2396]=0; - a[2397]=0; - a[2398]=0; - a[2399]=0; - a[2400]=0; - a[2401]=0; - a[2402]=0; - a[2403]=0; - a[2404]=0; - a[2405]=0; - a[2406]=0; - a[2407]=0; - a[2408]=0; - a[2409]=0; - a[2410]=0; - a[2411]=0; - a[2412]=0; - a[2413]=0; - a[2414]=0; - a[2415]=0; - a[2416]=0; - a[2417]=0; - a[2418]=0; - a[2419]=0; - a[2420]=0; - a[2421]=0; - a[2422]=0; - a[2423]=0; - a[2424]=0; - a[2425]=0; - a[2426]=0; - a[2427]=0; - a[2428]=0; - a[2429]=0; - a[2430]=0; - a[2431]=0; - a[2432]=0; - a[2433]=0; - a[2434]=0; - a[2435]=0; - a[2436]=0; - a[2437]=0; - a[2438]=0; - a[2439]=0; - a[2440]=0; - a[2441]=0; - a[2442]=0; - a[2443]=0; - a[2444]=0; - a[2445]=0; - a[2446]=0; - a[2447]=0; - a[2448]=0; - a[2449]=0; - a[2450]=0; - a[2451]=0; - a[2452]=0; - a[2453]=0; - a[2454]=0; - a[2455]=0; - a[2456]=0; - a[2457]=0; - a[2458]=0; - a[2459]=0; - a[2460]=0; - a[2461]=0; - a[2462]=0; - a[2463]=0; - a[2464]=0; - a[2465]=0; - a[2466]=0; - a[2467]=0; - a[2468]=0; - a[2469]=0; - a[2470]=0; - a[2471]=0; - a[2472]=0; - a[2473]=0; - a[2474]=0; - a[2475]=0; - a[2476]=0; - a[2477]=0; - a[2478]=0; - a[2479]=0; - a[2480]=0; - a[2481]=0; - a[2482]=0; - a[2483]=0; - a[2484]=0; - a[2485]=0; - a[2486]=0; - a[2487]=0; - a[2488]=0; - a[2489]=0; - a[2490]=0; - a[2491]=0; - a[2492]=0; - a[2493]=0; - a[2494]=0; - a[2495]=0; - a[2496]=0; - a[2497]=0; - a[2498]=0; - a[2499]=0; - a[2500]=0; - a[2501]=0; - a[2502]=0; - a[2503]=0; - a[2504]=0; - a[2505]=0; - a[2506]=0; - a[2507]=0; - a[2508]=0; - a[2509]=0; - a[2510]=0; - a[2511]=0; - a[2512]=0; - a[2513]=0; - a[2514]=0; - a[2515]=0; - a[2516]=0; - a[2517]=0; - a[2518]=0; - a[2519]=0; - a[2520]=0; - a[2521]=0; - a[2522]=0; - a[2523]=0; - a[2524]=0; - a[2525]=0; - a[2526]=0; - a[2527]=0; - a[2528]=0; - a[2529]=0; - a[2530]=0; - a[2531]=0; - a[2532]=0; - a[2533]=0; - a[2534]=0; - a[2535]=0; - a[2536]=0; - a[2537]=0; - a[2538]=0; - a[2539]=0; - a[2540]=0; - a[2541]=0; - a[2542]=0; - a[2543]=0; - a[2544]=0; - a[2545]=0; - a[2546]=0; - a[2547]=0; - a[2548]=0; - a[2549]=0; - a[2550]=0; - a[2551]=0; - a[2552]=0; - a[2553]=0; - a[2554]=0; - a[2555]=0; - a[2556]=0; - a[2557]=0; - a[2558]=0; - a[2559]=0; - a[2560]=0; - a[2561]=0; - a[2562]=0; - a[2563]=0; - a[2564]=0; - a[2565]=0; - a[2566]=0; - a[2567]=0; - a[2568]=0; - a[2569]=0; - a[2570]=0; - a[2571]=0; - a[2572]=0; - a[2573]=0; - a[2574]=0; - a[2575]=0; - a[2576]=0; - a[2577]=0; - a[2578]=0; - a[2579]=0; - a[2580]=0; - a[2581]=0; - a[2582]=0; - a[2583]=0; - a[2584]=0; - a[2585]=0; - a[2586]=0; - a[2587]=0; - a[2588]=0; - a[2589]=0; - a[2590]=0; - a[2591]=0; - a[2592]=0; - a[2593]=0; - a[2594]=0; - a[2595]=0; - a[2596]=0; - a[2597]=0; - a[2598]=0; - a[2599]=0; - a[2600]=0; - a[2601]=0; - a[2602]=0; - a[2603]=0; - a[2604]=0; - a[2605]=0; - a[2606]=0; - a[2607]=0; - a[2608]=0; - a[2609]=0; - a[2610]=0; - a[2611]=0; - a[2612]=0; - a[2613]=0; - a[2614]=0; - a[2615]=0; - a[2616]=0; - a[2617]=0; - a[2618]=0; - a[2619]=0; - a[2620]=0; - a[2621]=0; - a[2622]=0; - a[2623]=0; - a[2624]=0; - a[2625]=0; - a[2626]=0; - a[2627]=0; - a[2628]=0; - a[2629]=0; - a[2630]=0; - a[2631]=0; - a[2632]=0; - a[2633]=0; - a[2634]=0; - a[2635]=0; - a[2636]=0; - a[2637]=0; - a[2638]=0; - a[2639]=0; - a[2640]=0; - a[2641]=0; - a[2642]=0; - a[2643]=0; - a[2644]=0; - a[2645]=0; - a[2646]=0; - a[2647]=0; - a[2648]=0; - a[2649]=0; - a[2650]=0; - a[2651]=0; - a[2652]=0; - a[2653]=0; - a[2654]=0; - a[2655]=0; - a[2656]=0; - a[2657]=0; - a[2658]=0; - a[2659]=0; - a[2660]=0; - a[2661]=0; - a[2662]=0; - a[2663]=0; - a[2664]=0; - a[2665]=0; - a[2666]=0; - a[2667]=0; - a[2668]=0; - a[2669]=0; - a[2670]=0; - a[2671]=0; - a[2672]=0; - a[2673]=0; - a[2674]=0; - a[2675]=0; - a[2676]=0; - a[2677]=0; - a[2678]=0; - a[2679]=0; - a[2680]=0; - a[2681]=0; - a[2682]=0; - a[2683]=0; - a[2684]=0; - a[2685]=0; - a[2686]=0; - a[2687]=0; - a[2688]=0; - a[2689]=0; - a[2690]=0; - a[2691]=0; - a[2692]=0; - a[2693]=0; - a[2694]=0; - a[2695]=0; - a[2696]=0; - a[2697]=0; - a[2698]=0; - a[2699]=0; - a[2700]=0; - a[2701]=0; - a[2702]=0; - a[2703]=0; - a[2704]=0; - a[2705]=0; - a[2706]=0; - a[2707]=0; - a[2708]=0; - a[2709]=0; - a[2710]=0; - a[2711]=0; - a[2712]=0; - a[2713]=0; - a[2714]=0; - a[2715]=0; - a[2716]=0; - a[2717]=0; - a[2718]=0; - a[2719]=0; - a[2720]=0; - a[2721]=0; - a[2722]=0; - a[2723]=0; - a[2724]=0; - a[2725]=0; - a[2726]=0; - a[2727]=0; - a[2728]=0; - a[2729]=0; - a[2730]=0; - a[2731]=0; - a[2732]=0; - a[2733]=0; - a[2734]=0; - a[2735]=0; - a[2736]=0; - a[2737]=0; - a[2738]=0; - a[2739]=0; - a[2740]=0; - a[2741]=0; - a[2742]=0; - a[2743]=0; - a[2744]=0; - a[2745]=0; - a[2746]=0; - a[2747]=0; - a[2748]=0; - a[2749]=0; - a[2750]=0; - a[2751]=0; - a[2752]=0; - a[2753]=0; - a[2754]=0; - a[2755]=0; - a[2756]=0; - a[2757]=0; - a[2758]=0; - a[2759]=0; - a[2760]=0; - a[2761]=0; - a[2762]=0; - a[2763]=0; - a[2764]=0; - a[2765]=0; - a[2766]=0; - a[2767]=0; - a[2768]=0; - a[2769]=0; - a[2770]=0; - a[2771]=0; - a[2772]=0; - a[2773]=0; - a[2774]=0; - a[2775]=0; - a[2776]=0; - a[2777]=0; - a[2778]=0; - a[2779]=0; - a[2780]=0; - a[2781]=0; - a[2782]=0; - a[2783]=0; - a[2784]=0; - a[2785]=0; - a[2786]=0; - a[2787]=0; - a[2788]=0; - a[2789]=0; - a[2790]=0; - a[2791]=0; - a[2792]=0; - a[2793]=0; - a[2794]=0; - a[2795]=0; - a[2796]=0; - a[2797]=0; - a[2798]=0; - a[2799]=0; - a[2800]=0; - a[2801]=0; - a[2802]=0; - a[2803]=0; - a[2804]=0; - a[2805]=0; - a[2806]=0; - a[2807]=0; - a[2808]=0; - a[2809]=0; - a[2810]=0; - a[2811]=0; - a[2812]=0; - a[2813]=0; - a[2814]=0; - a[2815]=0; - a[2816]=0; - a[2817]=0; - a[2818]=0; - a[2819]=0; - a[2820]=0; - a[2821]=0; - a[2822]=0; - a[2823]=0; - a[2824]=0; - a[2825]=0; - a[2826]=0; - a[2827]=0; - a[2828]=0; - a[2829]=0; - a[2830]=0; - a[2831]=0; - a[2832]=0; - a[2833]=0; - a[2834]=0; - a[2835]=0; - a[2836]=0; - a[2837]=0; - a[2838]=0; - a[2839]=0; - a[2840]=0; - a[2841]=0; - a[2842]=0; - a[2843]=0; - a[2844]=0; - a[2845]=0; - a[2846]=0; - a[2847]=0; - a[2848]=0; - a[2849]=0; - a[2850]=0; - a[2851]=0; - a[2852]=0; - a[2853]=0; - a[2854]=0; - a[2855]=0; - a[2856]=0; - a[2857]=0; - a[2858]=0; - a[2859]=0; - a[2860]=0; - a[2861]=0; - a[2862]=0; - a[2863]=0; - a[2864]=0; - a[2865]=0; - a[2866]=0; - a[2867]=0; - a[2868]=0; - a[2869]=0; - a[2870]=0; - a[2871]=0; - a[2872]=0; - a[2873]=0; - a[2874]=0; - a[2875]=0; - a[2876]=0; - a[2877]=0; - a[2878]=0; - a[2879]=0; - a[2880]=0; - a[2881]=0; - a[2882]=0; - a[2883]=0; - a[2884]=0; - a[2885]=0; - a[2886]=0; - a[2887]=0; - a[2888]=0; - a[2889]=0; - a[2890]=0; - a[2891]=0; - a[2892]=0; - a[2893]=0; - a[2894]=0; - a[2895]=0; - a[2896]=0; - a[2897]=0; - a[2898]=0; - a[2899]=0; - a[2900]=0; - a[2901]=0; - a[2902]=0; - a[2903]=0; - a[2904]=0; - a[2905]=0; - a[2906]=0; - a[2907]=0; - a[2908]=0; - a[2909]=0; - a[2910]=0; - a[2911]=0; - a[2912]=0; - a[2913]=0; - a[2914]=0; - a[2915]=0; - a[2916]=0; - a[2917]=0; - a[2918]=0; - a[2919]=0; - a[2920]=0; - a[2921]=0; - a[2922]=0; - a[2923]=0; - a[2924]=0; - a[2925]=0; - a[2926]=0; - a[2927]=0; - a[2928]=0; - a[2929]=0; - a[2930]=0; - a[2931]=0; - a[2932]=0; - a[2933]=0; - a[2934]=0; - a[2935]=0; - a[2936]=0; - a[2937]=0; - a[2938]=0; - a[2939]=0; - a[2940]=0; - a[2941]=0; - a[2942]=0; - a[2943]=0; - a[2944]=0; - a[2945]=0; - a[2946]=0; - a[2947]=0; - a[2948]=0; - a[2949]=0; - a[2950]=0; - a[2951]=0; - a[2952]=0; - a[2953]=0; - a[2954]=0; - a[2955]=0; - a[2956]=0; - a[2957]=0; - a[2958]=0; - a[2959]=0; - a[2960]=0; - a[2961]=0; - a[2962]=0; - a[2963]=0; - a[2964]=0; - a[2965]=0; - a[2966]=0; - a[2967]=0; - a[2968]=0; - a[2969]=0; - a[2970]=0; - a[2971]=0; - a[2972]=0; - a[2973]=0; - a[2974]=0; - a[2975]=0; - a[2976]=0; - a[2977]=0; - a[2978]=0; - a[2979]=0; - a[2980]=0; - a[2981]=0; - a[2982]=0; - a[2983]=0; - a[2984]=0; - a[2985]=0; - a[2986]=0; - a[2987]=0; - a[2988]=0; - a[2989]=0; - a[2990]=0; - a[2991]=0; - a[2992]=0; - a[2993]=0; - a[2994]=0; - a[2995]=0; - a[2996]=0; - a[2997]=0; - a[2998]=0; - a[2999]=0; - a[3000]=0; - a[3001]=0; - a[3002]=0; - a[3003]=0; - a[3004]=0; - a[3005]=0; - a[3006]=0; - a[3007]=0; - a[3008]=0; - a[3009]=0; - a[3010]=0; - a[3011]=0; - a[3012]=0; - a[3013]=0; - a[3014]=0; - a[3015]=0; - a[3016]=0; - a[3017]=0; - a[3018]=0; - a[3019]=0; - a[3020]=0; - a[3021]=0; - a[3022]=0; - a[3023]=0; - a[3024]=0; - a[3025]=0; - a[3026]=0; - a[3027]=0; - a[3028]=0; - a[3029]=0; - a[3030]=0; - a[3031]=0; - a[3032]=0; - a[3033]=0; - a[3034]=0; - a[3035]=0; - a[3036]=0; - a[3037]=0; - a[3038]=0; - a[3039]=0; - a[3040]=0; - a[3041]=0; - a[3042]=0; - a[3043]=0; - a[3044]=0; - a[3045]=0; - a[3046]=0; - a[3047]=0; - a[3048]=0; - a[3049]=0; - a[3050]=0; - a[3051]=0; - a[3052]=0; - a[3053]=0; - a[3054]=0; - a[3055]=0; - a[3056]=0; - a[3057]=0; - a[3058]=0; - a[3059]=0; - a[3060]=0; - a[3061]=0; - a[3062]=0; - a[3063]=0; - a[3064]=0; - a[3065]=0; - a[3066]=0; - a[3067]=0; - a[3068]=0; - a[3069]=0; - a[3070]=0; - a[3071]=0; - a[3072]=0; - a[3073]=0; - a[3074]=0; - a[3075]=0; - a[3076]=0; - a[3077]=0; - a[3078]=0; - a[3079]=0; - a[3080]=0; - a[3081]=0; - a[3082]=0; - a[3083]=0; - a[3084]=0; - a[3085]=0; - a[3086]=0; - a[3087]=0; - a[3088]=0; - a[3089]=0; - a[3090]=0; - a[3091]=0; - a[3092]=0; - a[3093]=0; - a[3094]=0; - a[3095]=0; - a[3096]=0; - a[3097]=0; - a[3098]=0; - a[3099]=0; - a[3100]=0; - a[3101]=0; - a[3102]=0; - a[3103]=0; - a[3104]=0; - a[3105]=0; - a[3106]=0; - a[3107]=0; - a[3108]=0; - a[3109]=0; - a[3110]=0; - a[3111]=0; - a[3112]=0; - a[3113]=0; - a[3114]=0; - a[3115]=0; - a[3116]=0; - a[3117]=0; - a[3118]=0; - a[3119]=0; - a[3120]=0; - a[3121]=0; - a[3122]=0; - a[3123]=0; - a[3124]=0; - a[3125]=0; - a[3126]=0; - a[3127]=0; - a[3128]=0; - a[3129]=0; - a[3130]=0; - a[3131]=0; - a[3132]=0; - a[3133]=0; - a[3134]=0; - a[3135]=0; - a[3136]=0; - a[3137]=0; - a[3138]=0; - a[3139]=0; - a[3140]=0; - a[3141]=0; - a[3142]=0; - a[3143]=0; - a[3144]=0; - a[3145]=0; - a[3146]=0; - a[3147]=0; - a[3148]=0; - a[3149]=0; - a[3150]=0; - a[3151]=0; - a[3152]=0; - a[3153]=0; - a[3154]=0; - a[3155]=0; - a[3156]=0; - a[3157]=0; - a[3158]=0; - a[3159]=0; - a[3160]=0; - a[3161]=0; - a[3162]=0; - a[3163]=0; - a[3164]=0; - a[3165]=0; - a[3166]=0; - a[3167]=0; - a[3168]=0; - a[3169]=0; - a[3170]=0; - a[3171]=0; - a[3172]=0; - a[3173]=0; - a[3174]=0; - a[3175]=0; - a[3176]=0; - a[3177]=0; - a[3178]=0; - a[3179]=0; - a[3180]=0; - a[3181]=0; - a[3182]=0; - a[3183]=0; - a[3184]=0; - a[3185]=0; - a[3186]=0; - a[3187]=0; - a[3188]=0; - a[3189]=0; - a[3190]=0; - a[3191]=0; - a[3192]=0; - a[3193]=0; - a[3194]=0; - a[3195]=0; - a[3196]=0; - a[3197]=0; - a[3198]=0; - a[3199]=0; - a[3200]=0; - a[3201]=0; - a[3202]=0; - a[3203]=0; - a[3204]=0; - a[3205]=0; - a[3206]=0; - a[3207]=0; - a[3208]=0; - a[3209]=0; - a[3210]=0; - a[3211]=0; - a[3212]=0; - a[3213]=0; - a[3214]=0; - a[3215]=0; - a[3216]=0; - a[3217]=0; - a[3218]=0; - a[3219]=0; - a[3220]=0; - a[3221]=0; - a[3222]=0; - a[3223]=0; - a[3224]=0; - a[3225]=0; - a[3226]=0; - a[3227]=0; - a[3228]=0; - a[3229]=0; - a[3230]=0; - a[3231]=0; - a[3232]=0; - a[3233]=0; - a[3234]=0; - a[3235]=0; - a[3236]=0; - a[3237]=0; - a[3238]=0; - a[3239]=0; - a[3240]=0; - a[3241]=0; - a[3242]=0; - a[3243]=0; - a[3244]=0; - a[3245]=0; - a[3246]=0; - a[3247]=0; - a[3248]=0; - a[3249]=0; - a[3250]=0; - a[3251]=0; - a[3252]=0; - a[3253]=0; - a[3254]=0; - a[3255]=0; - a[3256]=0; - a[3257]=0; - a[3258]=0; - a[3259]=0; - a[3260]=0; - a[3261]=0; - a[3262]=0; - a[3263]=0; - a[3264]=0; - a[3265]=0; - a[3266]=0; - a[3267]=0; - a[3268]=0; - a[3269]=0; - a[3270]=0; - a[3271]=0; - a[3272]=0; - a[3273]=0; - a[3274]=0; - a[3275]=0; - a[3276]=0; - a[3277]=0; - a[3278]=0; - a[3279]=0; - a[3280]=0; - a[3281]=0; - a[3282]=0; - a[3283]=0; - a[3284]=0; - a[3285]=0; - a[3286]=0; - a[3287]=0; - a[3288]=0; - a[3289]=0; - a[3290]=0; - a[3291]=0; - a[3292]=0; - a[3293]=0; - a[3294]=0; - a[3295]=0; - a[3296]=0; - a[3297]=0; - a[3298]=0; - a[3299]=0; - a[3300]=0; - a[3301]=0; - a[3302]=0; - a[3303]=0; - a[3304]=0; - a[3305]=0; - a[3306]=0; - a[3307]=0; - a[3308]=0; - a[3309]=0; - a[3310]=0; - a[3311]=0; - a[3312]=0; - a[3313]=0; - a[3314]=0; - a[3315]=0; - a[3316]=0; - a[3317]=0; - a[3318]=0; - a[3319]=0; - a[3320]=0; - a[3321]=0; - a[3322]=0; - a[3323]=0; - a[3324]=0; - a[3325]=0; - a[3326]=0; - a[3327]=0; - a[3328]=0; - a[3329]=0; - a[3330]=0; - a[3331]=0; - a[3332]=0; - a[3333]=0; - a[3334]=0; - a[3335]=0; - a[3336]=0; - a[3337]=0; - a[3338]=0; - a[3339]=0; - a[3340]=0; - a[3341]=0; - a[3342]=0; - a[3343]=0; - a[3344]=0; - a[3345]=0; - a[3346]=0; - a[3347]=0; - a[3348]=0; - a[3349]=0; - a[3350]=0; - a[3351]=0; - a[3352]=0; - a[3353]=0; - a[3354]=0; - a[3355]=0; - a[3356]=0; - a[3357]=0; - a[3358]=0; - a[3359]=0; - a[3360]=0; - a[3361]=0; - a[3362]=0; - a[3363]=0; - a[3364]=0; - a[3365]=0; - a[3366]=0; - a[3367]=0; - a[3368]=0; - a[3369]=0; - a[3370]=0; - a[3371]=0; - a[3372]=0; - a[3373]=0; - a[3374]=0; - a[3375]=0; - a[3376]=0; - a[3377]=0; - a[3378]=0; - a[3379]=0; - a[3380]=0; - a[3381]=0; - a[3382]=0; - a[3383]=0; - a[3384]=0; - a[3385]=0; - a[3386]=0; - a[3387]=0; - a[3388]=0; - a[3389]=0; - a[3390]=0; - a[3391]=0; - a[3392]=0; - a[3393]=0; - a[3394]=0; - a[3395]=0; - a[3396]=0; - a[3397]=0; - a[3398]=0; - a[3399]=0; - a[3400]=0; - a[3401]=0; - a[3402]=0; - a[3403]=0; - a[3404]=0; - a[3405]=0; - a[3406]=0; - a[3407]=0; - a[3408]=0; - a[3409]=0; - a[3410]=0; - a[3411]=0; - a[3412]=0; - a[3413]=0; - a[3414]=0; - a[3415]=0; - a[3416]=0; - a[3417]=0; - a[3418]=0; - a[3419]=0; - a[3420]=0; - a[3421]=0; - a[3422]=0; - a[3423]=0; - a[3424]=0; - a[3425]=0; - a[3426]=0; - a[3427]=0; - a[3428]=0; - a[3429]=0; - a[3430]=0; - a[3431]=0; - a[3432]=0; - a[3433]=0; - a[3434]=0; - a[3435]=0; - a[3436]=0; - a[3437]=0; - a[3438]=0; - a[3439]=0; - a[3440]=0; - a[3441]=0; - a[3442]=0; - a[3443]=0; - a[3444]=0; - a[3445]=0; - a[3446]=0; - a[3447]=0; - a[3448]=0; - a[3449]=0; - a[3450]=0; - a[3451]=0; - a[3452]=0; - a[3453]=0; - a[3454]=0; - a[3455]=0; - a[3456]=0; - a[3457]=0; - a[3458]=0; - a[3459]=0; - a[3460]=0; - a[3461]=0; - a[3462]=0; - a[3463]=0; - a[3464]=0; - a[3465]=0; - a[3466]=0; - a[3467]=0; - a[3468]=0; - a[3469]=0; - a[3470]=0; - a[3471]=0; - a[3472]=0; - a[3473]=0; - a[3474]=0; - a[3475]=0; - a[3476]=0; - a[3477]=0; - a[3478]=0; - a[3479]=0; - a[3480]=0; - a[3481]=0; - a[3482]=0; - a[3483]=0; - a[3484]=0; - a[3485]=0; - a[3486]=0; - a[3487]=0; - a[3488]=0; - a[3489]=0; - a[3490]=0; - a[3491]=0; - a[3492]=0; - a[3493]=0; - a[3494]=0; - a[3495]=0; - a[3496]=0; - a[3497]=0; - a[3498]=0; - a[3499]=0; - a[3500]=0; - a[3501]=0; - a[3502]=0; - a[3503]=0; - a[3504]=0; - a[3505]=0; - a[3506]=0; - a[3507]=0; - a[3508]=0; - a[3509]=0; - a[3510]=0; - a[3511]=0; - a[3512]=0; - a[3513]=0; - a[3514]=0; - a[3515]=0; - a[3516]=0; - a[3517]=0; - a[3518]=0; - a[3519]=0; - a[3520]=0; - a[3521]=0; - a[3522]=0; - a[3523]=0; - a[3524]=0; - a[3525]=0; - a[3526]=0; - a[3527]=0; - a[3528]=0; - a[3529]=0; - a[3530]=0; - a[3531]=0; - a[3532]=0; - a[3533]=0; - a[3534]=0; - a[3535]=0; - a[3536]=0; - a[3537]=0; - a[3538]=0; - a[3539]=0; - a[3540]=0; - a[3541]=0; - a[3542]=0; - a[3543]=0; - a[3544]=0; - a[3545]=0; - a[3546]=0; - a[3547]=0; - a[3548]=0; - a[3549]=0; - a[3550]=0; - a[3551]=0; - a[3552]=0; - a[3553]=0; - a[3554]=0; - a[3555]=0; - a[3556]=0; - a[3557]=0; - a[3558]=0; - a[3559]=0; - a[3560]=0; - a[3561]=0; - a[3562]=0; - a[3563]=0; - a[3564]=0; - a[3565]=0; - a[3566]=0; - a[3567]=0; - a[3568]=0; - a[3569]=0; - a[3570]=0; - a[3571]=0; - a[3572]=0; - a[3573]=0; - a[3574]=0; - a[3575]=0; - a[3576]=0; - a[3577]=0; - a[3578]=0; - a[3579]=0; - a[3580]=0; - a[3581]=0; - a[3582]=0; - a[3583]=0; - a[3584]=0; - a[3585]=0; - a[3586]=0; - a[3587]=0; - a[3588]=0; - a[3589]=0; - a[3590]=0; - a[3591]=0; - a[3592]=0; - a[3593]=0; - a[3594]=0; - a[3595]=0; - a[3596]=0; - a[3597]=0; - a[3598]=0; - a[3599]=0; - a[3600]=0; - a[3601]=0; - a[3602]=0; - a[3603]=0; - a[3604]=0; - a[3605]=0; - a[3606]=0; - a[3607]=0; - a[3608]=0; - a[3609]=0; - a[3610]=0; - a[3611]=0; - a[3612]=0; - a[3613]=0; - a[3614]=0; - a[3615]=0; - a[3616]=0; - a[3617]=0; - a[3618]=0; - a[3619]=0; - a[3620]=0; - a[3621]=0; - a[3622]=0; - a[3623]=0; - a[3624]=0; - a[3625]=0; - a[3626]=0; - a[3627]=0; - a[3628]=0; - a[3629]=0; - a[3630]=0; - a[3631]=0; - a[3632]=0; - a[3633]=0; - a[3634]=0; - a[3635]=0; - a[3636]=0; - a[3637]=0; - a[3638]=0; - a[3639]=0; - a[3640]=0; - a[3641]=0; - a[3642]=0; - a[3643]=0; - a[3644]=0; - a[3645]=0; - a[3646]=0; - a[3647]=0; - a[3648]=0; - a[3649]=0; - a[3650]=0; - a[3651]=0; - a[3652]=0; - a[3653]=0; - a[3654]=0; - a[3655]=0; - a[3656]=0; - a[3657]=0; - a[3658]=0; - a[3659]=0; - a[3660]=0; - a[3661]=0; - a[3662]=0; - a[3663]=0; - a[3664]=0; - a[3665]=0; - a[3666]=0; - a[3667]=0; - a[3668]=0; - a[3669]=0; - a[3670]=0; - a[3671]=0; - a[3672]=0; - a[3673]=0; - a[3674]=0; - a[3675]=0; - a[3676]=0; - a[3677]=0; - a[3678]=0; - a[3679]=0; - a[3680]=0; - a[3681]=0; - a[3682]=0; - a[3683]=0; - a[3684]=0; - a[3685]=0; - a[3686]=0; - a[3687]=0; - a[3688]=0; - a[3689]=0; - a[3690]=0; - a[3691]=0; - a[3692]=0; - a[3693]=0; - a[3694]=0; - a[3695]=0; - a[3696]=0; - a[3697]=0; - a[3698]=0; - a[3699]=0; - a[3700]=0; - a[3701]=0; - a[3702]=0; - a[3703]=0; - a[3704]=0; - a[3705]=0; - a[3706]=0; - a[3707]=0; - a[3708]=0; - a[3709]=0; - a[3710]=0; - a[3711]=0; - a[3712]=0; - a[3713]=0; - a[3714]=0; - a[3715]=0; - a[3716]=0; - a[3717]=0; - a[3718]=0; - a[3719]=0; - a[3720]=0; - a[3721]=0; - a[3722]=0; - a[3723]=0; - a[3724]=0; - a[3725]=0; - a[3726]=0; - a[3727]=0; - a[3728]=0; - a[3729]=0; - a[3730]=0; - a[3731]=0; - a[3732]=0; - a[3733]=0; - a[3734]=0; - a[3735]=0; - a[3736]=0; - a[3737]=0; - a[3738]=0; - a[3739]=0; - a[3740]=0; - a[3741]=0; - a[3742]=0; - a[3743]=0; - a[3744]=0; - a[3745]=0; - a[3746]=0; - a[3747]=0; - a[3748]=0; - a[3749]=0; - a[3750]=0; - a[3751]=0; - a[3752]=0; - a[3753]=0; - a[3754]=0; - a[3755]=0; - a[3756]=0; - a[3757]=0; - a[3758]=0; - a[3759]=0; - a[3760]=0; - a[3761]=0; - a[3762]=0; - a[3763]=0; - a[3764]=0; - a[3765]=0; - a[3766]=0; - a[3767]=0; - a[3768]=0; - a[3769]=0; - a[3770]=0; - a[3771]=0; - a[3772]=0; - a[3773]=0; - a[3774]=0; - a[3775]=0; - a[3776]=0; - a[3777]=0; - a[3778]=0; - a[3779]=0; - a[3780]=0; - a[3781]=0; - a[3782]=0; - a[3783]=0; - a[3784]=0; - a[3785]=0; - a[3786]=0; - a[3787]=0; - a[3788]=0; - a[3789]=0; - a[3790]=0; - a[3791]=0; - a[3792]=0; - a[3793]=0; - a[3794]=0; - a[3795]=0; - a[3796]=0; - a[3797]=0; - a[3798]=0; - a[3799]=0; - a[3800]=0; - a[3801]=0; - a[3802]=0; - a[3803]=0; - a[3804]=0; - a[3805]=0; - a[3806]=0; - a[3807]=0; - a[3808]=0; - a[3809]=0; - a[3810]=0; - a[3811]=0; - a[3812]=0; - a[3813]=0; - a[3814]=0; - a[3815]=0; - a[3816]=0; - a[3817]=0; - a[3818]=0; - a[3819]=0; - a[3820]=0; - a[3821]=0; - a[3822]=0; - a[3823]=0; - a[3824]=0; - a[3825]=0; - a[3826]=0; - a[3827]=0; - a[3828]=0; - a[3829]=0; - a[3830]=0; - a[3831]=0; - a[3832]=0; - a[3833]=0; - a[3834]=0; - a[3835]=0; - a[3836]=0; - a[3837]=0; - a[3838]=0; - a[3839]=0; - a[3840]=0; - a[3841]=0; - a[3842]=0; - a[3843]=0; - a[3844]=0; - a[3845]=0; - a[3846]=0; - a[3847]=0; - a[3848]=0; - a[3849]=0; - a[3850]=0; - a[3851]=0; - a[3852]=0; - a[3853]=0; - a[3854]=0; - a[3855]=0; - a[3856]=0; - a[3857]=0; - a[3858]=0; - a[3859]=0; - a[3860]=0; - a[3861]=0; - a[3862]=0; - a[3863]=0; - a[3864]=0; - a[3865]=0; - a[3866]=0; - a[3867]=0; - a[3868]=0; - a[3869]=0; - a[3870]=0; - a[3871]=0; - a[3872]=0; - a[3873]=0; - a[3874]=0; - a[3875]=0; - a[3876]=0; - a[3877]=0; - a[3878]=0; - a[3879]=0; - a[3880]=0; - a[3881]=0; - a[3882]=0; - a[3883]=0; - a[3884]=0; - a[3885]=0; - a[3886]=0; - a[3887]=0; - a[3888]=0; - a[3889]=0; - a[3890]=0; - a[3891]=0; - a[3892]=0; - a[3893]=0; - a[3894]=0; - a[3895]=0; - a[3896]=0; - a[3897]=0; - a[3898]=0; - a[3899]=0; - a[3900]=0; - a[3901]=0; - a[3902]=0; - a[3903]=0; - a[3904]=0; - a[3905]=0; - a[3906]=0; - a[3907]=0; - a[3908]=0; - a[3909]=0; - a[3910]=0; - a[3911]=0; - a[3912]=0; - a[3913]=0; - a[3914]=0; - a[3915]=0; - a[3916]=0; - a[3917]=0; - a[3918]=0; - a[3919]=0; - a[3920]=0; - a[3921]=0; - a[3922]=0; - a[3923]=0; - a[3924]=0; - a[3925]=0; - a[3926]=0; - a[3927]=0; - a[3928]=0; - a[3929]=0; - a[3930]=0; - a[3931]=0; - a[3932]=0; - a[3933]=0; - a[3934]=0; - a[3935]=0; - a[3936]=0; - a[3937]=0; - a[3938]=0; - a[3939]=0; - a[3940]=0; - a[3941]=0; - a[3942]=0; - a[3943]=0; - a[3944]=0; - a[3945]=0; - a[3946]=0; - a[3947]=0; - a[3948]=0; - a[3949]=0; - a[3950]=0; - a[3951]=0; - a[3952]=0; - a[3953]=0; - a[3954]=0; - a[3955]=0; - a[3956]=0; - a[3957]=0; - a[3958]=0; - a[3959]=0; - a[3960]=0; - a[3961]=0; - a[3962]=0; - a[3963]=0; - a[3964]=0; - a[3965]=0; - a[3966]=0; - a[3967]=0; - a[3968]=0; - a[3969]=0; - a[3970]=0; - a[3971]=0; - a[3972]=0; - a[3973]=0; - a[3974]=0; - a[3975]=0; - a[3976]=0; - a[3977]=0; - a[3978]=0; - a[3979]=0; - a[3980]=0; - a[3981]=0; - a[3982]=0; - a[3983]=0; - a[3984]=0; - a[3985]=0; - a[3986]=0; - a[3987]=0; - a[3988]=0; - a[3989]=0; - a[3990]=0; - a[3991]=0; - a[3992]=0; - a[3993]=0; - a[3994]=0; - a[3995]=0; - a[3996]=0; - a[3997]=0; - a[3998]=0; - a[3999]=0; - a[4000]=0; - a[4001]=0; - a[4002]=0; - a[4003]=0; - a[4004]=0; - a[4005]=0; - a[4006]=0; - a[4007]=0; - a[4008]=0; - a[4009]=0; - a[4010]=0; - a[4011]=0; - a[4012]=0; - a[4013]=0; - a[4014]=0; - a[4015]=0; - a[4016]=0; - a[4017]=0; - a[4018]=0; - a[4019]=0; - a[4020]=0; - a[4021]=0; - a[4022]=0; - a[4023]=0; - a[4024]=0; - a[4025]=0; - a[4026]=0; - a[4027]=0; - a[4028]=0; - a[4029]=0; - a[4030]=0; - a[4031]=0; - a[4032]=0; - a[4033]=0; - a[4034]=0; - a[4035]=0; - a[4036]=0; - a[4037]=0; - a[4038]=0; - a[4039]=0; - a[4040]=0; - a[4041]=0; - a[4042]=0; - a[4043]=0; - a[4044]=0; - a[4045]=0; - a[4046]=0; - a[4047]=0; - a[4048]=0; - a[4049]=0; - a[4050]=0; - a[4051]=0; - a[4052]=0; - a[4053]=0; - a[4054]=0; - a[4055]=0; - a[4056]=0; - a[4057]=0; - a[4058]=0; - a[4059]=0; - a[4060]=0; - a[4061]=0; - a[4062]=0; - a[4063]=0; - a[4064]=0; - a[4065]=0; - a[4066]=0; - a[4067]=0; - a[4068]=0; - a[4069]=0; - a[4070]=0; - a[4071]=0; - a[4072]=0; - a[4073]=0; - a[4074]=0; - a[4075]=0; - a[4076]=0; - a[4077]=0; - a[4078]=0; - a[4079]=0; - a[4080]=0; - a[4081]=0; - a[4082]=0; - a[4083]=0; - a[4084]=0; - a[4085]=0; - a[4086]=0; - a[4087]=0; - a[4088]=0; - a[4089]=0; - a[4090]=0; - a[4091]=0; - a[4092]=0; - a[4093]=0; - a[4094]=0; - a[4095]=0; - a[4096]=0; - a[4097]=0; - a[4098]=0; - a[4099]=0; - a[4100]=0; - a[4101]=0; - a[4102]=0; - a[4103]=0; - a[4104]=0; - a[4105]=0; - a[4106]=0; - a[4107]=0; - a[4108]=0; - a[4109]=0; - a[4110]=0; - a[4111]=0; - a[4112]=0; - a[4113]=0; - a[4114]=0; - a[4115]=0; - a[4116]=0; - a[4117]=0; - a[4118]=0; - a[4119]=0; - a[4120]=0; - a[4121]=0; - a[4122]=0; - a[4123]=0; - a[4124]=0; - a[4125]=0; - a[4126]=0; - a[4127]=0; - a[4128]=0; - a[4129]=0; - a[4130]=0; - a[4131]=0; - a[4132]=0; - a[4133]=0; - a[4134]=0; - a[4135]=0; - a[4136]=0; - a[4137]=0; - a[4138]=0; - a[4139]=0; - a[4140]=0; - a[4141]=0; - a[4142]=0; - a[4143]=0; - a[4144]=0; - a[4145]=0; - a[4146]=0; - a[4147]=0; - a[4148]=0; - a[4149]=0; - a[4150]=0; - a[4151]=0; - a[4152]=0; - a[4153]=0; - a[4154]=0; - a[4155]=0; - a[4156]=0; - a[4157]=0; - a[4158]=0; - a[4159]=0; - a[4160]=0; - a[4161]=0; - a[4162]=0; - a[4163]=0; - a[4164]=0; - a[4165]=0; - a[4166]=0; - a[4167]=0; - a[4168]=0; - a[4169]=0; - a[4170]=0; - a[4171]=0; - a[4172]=0; - a[4173]=0; - a[4174]=0; - a[4175]=0; - a[4176]=0; - a[4177]=0; - a[4178]=0; - a[4179]=0; - a[4180]=0; - a[4181]=0; - a[4182]=0; - a[4183]=0; - a[4184]=0; - a[4185]=0; - a[4186]=0; - a[4187]=0; - a[4188]=0; - a[4189]=0; - a[4190]=0; - a[4191]=0; - a[4192]=0; - a[4193]=0; - a[4194]=0; - a[4195]=0; - a[4196]=0; - a[4197]=0; - a[4198]=0; - a[4199]=0; - a[4200]=0; - a[4201]=0; - a[4202]=0; - a[4203]=0; - a[4204]=0; - a[4205]=0; - a[4206]=0; - a[4207]=0; - a[4208]=0; - a[4209]=0; - a[4210]=0; - a[4211]=0; - a[4212]=0; - a[4213]=0; - a[4214]=0; - a[4215]=0; - a[4216]=0; - a[4217]=0; - a[4218]=0; - a[4219]=0; - a[4220]=0; - a[4221]=0; - a[4222]=0; - a[4223]=0; - a[4224]=0; - a[4225]=0; - a[4226]=0; - a[4227]=0; - a[4228]=0; - a[4229]=0; - a[4230]=0; - a[4231]=0; - a[4232]=0; - a[4233]=0; - a[4234]=0; - a[4235]=0; - a[4236]=0; - a[4237]=0; - a[4238]=0; - a[4239]=0; - a[4240]=0; - a[4241]=0; - a[4242]=0; - a[4243]=0; - a[4244]=0; - a[4245]=0; - a[4246]=0; - a[4247]=0; - a[4248]=0; - a[4249]=0; - a[4250]=0; - a[4251]=0; - a[4252]=0; - a[4253]=0; - a[4254]=0; - a[4255]=0; - a[4256]=0; - a[4257]=0; - a[4258]=0; - a[4259]=0; - a[4260]=0; - a[4261]=0; - a[4262]=0; - a[4263]=0; - a[4264]=0; - a[4265]=0; - a[4266]=0; - a[4267]=0; - a[4268]=0; - a[4269]=0; - a[4270]=0; - a[4271]=0; - a[4272]=0; - a[4273]=0; - a[4274]=0; - a[4275]=0; - a[4276]=0; - a[4277]=0; - a[4278]=0; - a[4279]=0; - a[4280]=0; - a[4281]=0; - a[4282]=0; - a[4283]=0; - a[4284]=0; - a[4285]=0; - a[4286]=0; - a[4287]=0; - a[4288]=0; - a[4289]=0; - a[4290]=0; - a[4291]=0; - a[4292]=0; - a[4293]=0; - a[4294]=0; - a[4295]=0; - a[4296]=0; - a[4297]=0; - a[4298]=0; - a[4299]=0; - a[4300]=0; - a[4301]=0; - a[4302]=0; - a[4303]=0; - a[4304]=0; - a[4305]=0; - a[4306]=0; - a[4307]=0; - a[4308]=0; - a[4309]=0; - a[4310]=0; - a[4311]=0; - a[4312]=0; - a[4313]=0; - a[4314]=0; - a[4315]=0; - a[4316]=0; - a[4317]=0; - a[4318]=0; - a[4319]=0; - a[4320]=0; - a[4321]=0; - a[4322]=0; - a[4323]=0; - a[4324]=0; - a[4325]=0; - a[4326]=0; - a[4327]=0; - a[4328]=0; - a[4329]=0; - a[4330]=0; - a[4331]=0; - a[4332]=0; - a[4333]=0; - a[4334]=0; - a[4335]=0; - a[4336]=0; - a[4337]=0; - a[4338]=0; - a[4339]=0; - a[4340]=0; - a[4341]=0; - a[4342]=0; - a[4343]=0; - a[4344]=0; - a[4345]=0; - a[4346]=0; - a[4347]=0; - a[4348]=0; - a[4349]=0; - a[4350]=0; - a[4351]=0; - a[4352]=0; - a[4353]=0; - a[4354]=0; - a[4355]=0; - a[4356]=0; - a[4357]=0; - a[4358]=0; - a[4359]=0; - a[4360]=0; - a[4361]=0; - a[4362]=0; - a[4363]=0; - a[4364]=0; - a[4365]=0; - a[4366]=0; - a[4367]=0; - a[4368]=0; - a[4369]=0; - a[4370]=0; - a[4371]=0; - a[4372]=0; - a[4373]=0; - a[4374]=0; - a[4375]=0; - a[4376]=0; - a[4377]=0; - a[4378]=0; - a[4379]=0; - a[4380]=0; - a[4381]=0; - a[4382]=0; - a[4383]=0; - a[4384]=0; - a[4385]=0; - a[4386]=0; - a[4387]=0; - a[4388]=0; - a[4389]=0; - a[4390]=0; - a[4391]=0; - a[4392]=0; - a[4393]=0; - a[4394]=0; - a[4395]=0; - a[4396]=0; - a[4397]=0; - a[4398]=0; - a[4399]=0; - a[4400]=0; - a[4401]=0; - a[4402]=0; - a[4403]=0; - a[4404]=0; - a[4405]=0; - a[4406]=0; - a[4407]=0; - a[4408]=0; - a[4409]=0; - a[4410]=0; - a[4411]=0; - a[4412]=0; - a[4413]=0; - a[4414]=0; - a[4415]=0; - a[4416]=0; - a[4417]=0; - a[4418]=0; - a[4419]=0; - a[4420]=0; - a[4421]=0; - a[4422]=0; - a[4423]=0; - a[4424]=0; - a[4425]=0; - a[4426]=0; - a[4427]=0; - a[4428]=0; - a[4429]=0; - a[4430]=0; - a[4431]=0; - a[4432]=0; - a[4433]=0; - a[4434]=0; - a[4435]=0; - a[4436]=0; - a[4437]=0; - a[4438]=0; - a[4439]=0; - a[4440]=0; - a[4441]=0; - a[4442]=0; - a[4443]=0; - a[4444]=0; - a[4445]=0; - a[4446]=0; - a[4447]=0; - a[4448]=0; - a[4449]=0; - a[4450]=0; - a[4451]=0; - a[4452]=0; - a[4453]=0; - a[4454]=0; - a[4455]=0; - a[4456]=0; - a[4457]=0; - a[4458]=0; - a[4459]=0; - a[4460]=0; - a[4461]=0; - a[4462]=0; - a[4463]=0; - a[4464]=0; - a[4465]=0; - a[4466]=0; - a[4467]=0; - a[4468]=0; - a[4469]=0; - a[4470]=0; - a[4471]=0; - a[4472]=0; - a[4473]=0; - a[4474]=0; - a[4475]=0; - a[4476]=0; - a[4477]=0; - a[4478]=0; - a[4479]=0; - a[4480]=0; - a[4481]=0; - a[4482]=0; - a[4483]=0; - a[4484]=0; - a[4485]=0; - a[4486]=0; - a[4487]=0; - a[4488]=0; - a[4489]=0; - a[4490]=0; - a[4491]=0; - a[4492]=0; - a[4493]=0; - a[4494]=0; - a[4495]=0; - a[4496]=0; - a[4497]=0; - a[4498]=0; - a[4499]=0; - a[4500]=0; - a[4501]=0; - a[4502]=0; - a[4503]=0; - a[4504]=0; - a[4505]=0; - a[4506]=0; - a[4507]=0; - a[4508]=0; - a[4509]=0; - a[4510]=0; - a[4511]=0; - a[4512]=0; - a[4513]=0; - a[4514]=0; - a[4515]=0; - a[4516]=0; - a[4517]=0; - a[4518]=0; - a[4519]=0; - a[4520]=0; - a[4521]=0; - a[4522]=0; - a[4523]=0; - a[4524]=0; - a[4525]=0; - a[4526]=0; - a[4527]=0; - a[4528]=0; - a[4529]=0; - a[4530]=0; - a[4531]=0; - a[4532]=0; - a[4533]=0; - a[4534]=0; - a[4535]=0; - a[4536]=0; - a[4537]=0; - a[4538]=0; - a[4539]=0; - a[4540]=0; - a[4541]=0; - a[4542]=0; - a[4543]=0; - a[4544]=0; - a[4545]=0; - a[4546]=0; - a[4547]=0; - a[4548]=0; - a[4549]=0; - a[4550]=0; - a[4551]=0; - a[4552]=0; - a[4553]=0; - a[4554]=0; - a[4555]=0; - a[4556]=0; - a[4557]=0; - a[4558]=0; - a[4559]=0; - a[4560]=0; - a[4561]=0; - a[4562]=0; - a[4563]=0; - a[4564]=0; - a[4565]=0; - a[4566]=0; - a[4567]=0; - a[4568]=0; - a[4569]=0; - a[4570]=0; - a[4571]=0; - a[4572]=0; - a[4573]=0; - a[4574]=0; - a[4575]=0; - a[4576]=0; - a[4577]=0; - a[4578]=0; - a[4579]=0; - a[4580]=0; - a[4581]=0; - a[4582]=0; - a[4583]=0; - a[4584]=0; - a[4585]=0; - a[4586]=0; - a[4587]=0; - a[4588]=0; - a[4589]=0; - a[4590]=0; - a[4591]=0; - a[4592]=0; - a[4593]=0; - a[4594]=0; - a[4595]=0; - a[4596]=0; - a[4597]=0; - a[4598]=0; - a[4599]=0; - a[4600]=0; - a[4601]=0; - a[4602]=0; - a[4603]=0; - a[4604]=0; - a[4605]=0; - a[4606]=0; - a[4607]=0; - a[4608]=0; - a[4609]=0; - a[4610]=0; - a[4611]=0; - a[4612]=0; - a[4613]=0; - a[4614]=0; - a[4615]=0; - a[4616]=0; - a[4617]=0; - a[4618]=0; - a[4619]=0; - a[4620]=0; - a[4621]=0; - a[4622]=0; - a[4623]=0; - a[4624]=0; - a[4625]=0; - a[4626]=0; - a[4627]=0; - a[4628]=0; - a[4629]=0; - a[4630]=0; - a[4631]=0; - a[4632]=0; - a[4633]=0; - a[4634]=0; - a[4635]=0; - a[4636]=0; - a[4637]=0; - a[4638]=0; - a[4639]=0; - a[4640]=0; - a[4641]=0; - a[4642]=0; - a[4643]=0; - a[4644]=0; - a[4645]=0; - a[4646]=0; - a[4647]=0; - a[4648]=0; - a[4649]=0; - a[4650]=0; - a[4651]=0; - a[4652]=0; - a[4653]=0; - a[4654]=0; - a[4655]=0; - a[4656]=0; - a[4657]=0; - a[4658]=0; - a[4659]=0; - a[4660]=0; - a[4661]=0; - a[4662]=0; - a[4663]=0; - a[4664]=0; - a[4665]=0; - a[4666]=0; - a[4667]=0; - a[4668]=0; - a[4669]=0; - a[4670]=0; - a[4671]=0; - a[4672]=0; - a[4673]=0; - a[4674]=0; - a[4675]=0; - a[4676]=0; - a[4677]=0; - a[4678]=0; - a[4679]=0; - a[4680]=0; - a[4681]=0; - a[4682]=0; - a[4683]=0; - a[4684]=0; - a[4685]=0; - a[4686]=0; - a[4687]=0; - a[4688]=0; - a[4689]=0; - a[4690]=0; - a[4691]=0; - a[4692]=0; - a[4693]=0; - a[4694]=0; - a[4695]=0; - a[4696]=0; - a[4697]=0; - a[4698]=0; - a[4699]=0; - a[4700]=0; - a[4701]=0; - a[4702]=0; - a[4703]=0; - a[4704]=0; - a[4705]=0; - a[4706]=0; - a[4707]=0; - a[4708]=0; - a[4709]=0; - a[4710]=0; - a[4711]=0; - a[4712]=0; - a[4713]=0; - a[4714]=0; - a[4715]=0; - a[4716]=0; - a[4717]=0; - a[4718]=0; - a[4719]=0; - a[4720]=0; - a[4721]=0; - a[4722]=0; - a[4723]=0; - a[4724]=0; - a[4725]=0; - a[4726]=0; - a[4727]=0; - a[4728]=0; - a[4729]=0; - a[4730]=0; - a[4731]=0; - a[4732]=0; - a[4733]=0; - a[4734]=0; - a[4735]=0; - a[4736]=0; - a[4737]=0; - a[4738]=0; - a[4739]=0; - a[4740]=0; - a[4741]=0; - a[4742]=0; - a[4743]=0; - a[4744]=0; - a[4745]=0; - a[4746]=0; - a[4747]=0; - a[4748]=0; - a[4749]=0; - a[4750]=0; - a[4751]=0; - a[4752]=0; - a[4753]=0; - a[4754]=0; - a[4755]=0; - a[4756]=0; - a[4757]=0; - a[4758]=0; - a[4759]=0; - a[4760]=0; - a[4761]=0; - a[4762]=0; - a[4763]=0; - a[4764]=0; - a[4765]=0; - a[4766]=0; - a[4767]=0; - a[4768]=0; - a[4769]=0; - a[4770]=0; - a[4771]=0; - a[4772]=0; - a[4773]=0; - a[4774]=0; - a[4775]=0; - a[4776]=0; - a[4777]=0; - a[4778]=0; - a[4779]=0; - a[4780]=0; - a[4781]=0; - a[4782]=0; - a[4783]=0; - a[4784]=0; - a[4785]=0; - a[4786]=0; - a[4787]=0; - a[4788]=0; - a[4789]=0; - a[4790]=0; - a[4791]=0; - a[4792]=0; - a[4793]=0; - a[4794]=0; - a[4795]=0; - a[4796]=0; - a[4797]=0; - a[4798]=0; - a[4799]=0; - a[4800]=0; - a[4801]=0; - a[4802]=0; - a[4803]=0; - a[4804]=0; - a[4805]=0; - a[4806]=0; - a[4807]=0; - a[4808]=0; - a[4809]=0; - a[4810]=0; - a[4811]=0; - a[4812]=0; - a[4813]=0; - a[4814]=0; - a[4815]=0; - a[4816]=0; - a[4817]=0; - a[4818]=0; - a[4819]=0; - a[4820]=0; - a[4821]=0; - a[4822]=0; - a[4823]=0; - a[4824]=0; - a[4825]=0; - a[4826]=0; - a[4827]=0; - a[4828]=0; - a[4829]=0; - a[4830]=0; - a[4831]=0; - a[4832]=0; - a[4833]=0; - a[4834]=0; - a[4835]=0; - a[4836]=0; - a[4837]=0; - a[4838]=0; - a[4839]=0; - a[4840]=0; - a[4841]=0; - a[4842]=0; - a[4843]=0; - a[4844]=0; - a[4845]=0; - a[4846]=0; - a[4847]=0; - a[4848]=0; - a[4849]=0; - a[4850]=0; - a[4851]=0; - a[4852]=0; - a[4853]=0; - a[4854]=0; - a[4855]=0; - a[4856]=0; - a[4857]=0; - a[4858]=0; - a[4859]=0; - a[4860]=0; - a[4861]=0; - a[4862]=0; - a[4863]=0; - a[4864]=0; - a[4865]=0; - a[4866]=0; - a[4867]=0; - a[4868]=0; - a[4869]=0; - a[4870]=0; - a[4871]=0; - a[4872]=0; - a[4873]=0; - a[4874]=0; - a[4875]=0; - a[4876]=0; - a[4877]=0; - a[4878]=0; - a[4879]=0; - a[4880]=0; - a[4881]=0; - a[4882]=0; - a[4883]=0; - a[4884]=0; - a[4885]=0; - a[4886]=0; - a[4887]=0; - a[4888]=0; - a[4889]=0; - a[4890]=0; - a[4891]=0; - a[4892]=0; - a[4893]=0; - a[4894]=0; - a[4895]=0; - a[4896]=0; - a[4897]=0; - a[4898]=0; - a[4899]=0; - a[4900]=0; - a[4901]=0; - a[4902]=0; - a[4903]=0; - a[4904]=0; - a[4905]=0; - a[4906]=0; - a[4907]=0; - a[4908]=0; - a[4909]=0; - a[4910]=0; - a[4911]=0; - a[4912]=0; - a[4913]=0; - a[4914]=0; - a[4915]=0; - a[4916]=0; - a[4917]=0; - a[4918]=0; - a[4919]=0; - a[4920]=0; - a[4921]=0; - a[4922]=0; - a[4923]=0; - a[4924]=0; - a[4925]=0; - a[4926]=0; - a[4927]=0; - a[4928]=0; - a[4929]=0; - a[4930]=0; - a[4931]=0; - a[4932]=0; - a[4933]=0; - a[4934]=0; - a[4935]=0; - a[4936]=0; - a[4937]=0; - a[4938]=0; - a[4939]=0; - a[4940]=0; - a[4941]=0; - a[4942]=0; - a[4943]=0; - a[4944]=0; - a[4945]=0; - a[4946]=0; - a[4947]=0; - a[4948]=0; - a[4949]=0; - a[4950]=0; - a[4951]=0; - a[4952]=0; - a[4953]=0; - a[4954]=0; - a[4955]=0; - a[4956]=0; - a[4957]=0; - a[4958]=0; - a[4959]=0; - a[4960]=0; - a[4961]=0; - a[4962]=0; - a[4963]=0; - a[4964]=0; - a[4965]=0; - a[4966]=0; - a[4967]=0; - a[4968]=0; - a[4969]=0; - a[4970]=0; - a[4971]=0; - a[4972]=0; - a[4973]=0; - a[4974]=0; - a[4975]=0; - a[4976]=0; - a[4977]=0; - a[4978]=0; - a[4979]=0; - a[4980]=0; - a[4981]=0; - a[4982]=0; - a[4983]=0; - a[4984]=0; - a[4985]=0; - a[4986]=0; - a[4987]=0; - a[4988]=0; - a[4989]=0; - a[4990]=0; - a[4991]=0; - a[4992]=0; - a[4993]=0; - a[4994]=0; - a[4995]=0; - a[4996]=0; - a[4997]=0; - a[4998]=0; - a[4999]=0; - return a; -} diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2119.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2119.js new file mode 100644 index 0000000..54840c2 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2119.js @@ -0,0 +1,36 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --nouse-ic + +function strict_function() { + "use strict" + undeclared = 1; +} + +assertThrows(strict_function); + diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2153.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2153.js new file mode 100644 index 0000000..3170042 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2153.js @@ -0,0 +1,32 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var o = {}; +o.__defineGetter__('foo', function () { return null; }); +var o = {}; +o.foo = 42; +assertEquals(42, o.foo); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2156.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2156.js new file mode 100644 index 0000000..3482571 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2156.js @@ -0,0 +1,39 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax --harmony-collections + +var key1 = {}; +var key2 = {}; +var map = new WeakMap; + +// Adding hidden properties preserves map sharing. Putting the key into +// a WeakMap will cause the first hidden property to be added. +assertTrue(%HaveSameMap(key1, key2)); +map.set(key1, 1); +map.set(key2, 2); +assertTrue(%HaveSameMap(key1, key2)); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2163.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2163.js new file mode 100644 index 0000000..bfce9ff --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2163.js @@ -0,0 +1,70 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-gc + +// Handy abbreviation. +var dp = Object.defineProperty; + +function getter() { return 111; } +function setter(x) { print(222); } +function anotherGetter() { return 333; } +function anotherSetter(x) { print(444); } +var obj1, obj2; + +// obj1 and obj2 share the getter accessor. +obj1 = {}; +dp(obj1, "alpha", { get: getter, set: setter }); +obj2 = {} +dp(obj2, "alpha", { get: getter }); +obj1 = {}; +assertEquals(111, obj2.alpha); +gc(); +assertEquals(111, obj2.alpha); + +// obj1, obj2, and obj3 share the getter accessor. +obj1 = {}; +dp(obj1, "alpha", { get: getter, set: setter }); +obj2 = {} +dp(obj2, "alpha", { get: getter }); +obj1 = {}; +gc(); +obj3 = {} +dp(obj3, "alpha", { get: getter }); + + +// obj1 and obj2 share the getter and setter accessor. +obj1 = {}; +dp(obj1, "alpha", { get: getter, set: setter }); +obj1.beta = 10; +obj2 = {} +dp(obj2, "alpha", { get: getter, set: setter }); +obj1 = {}; +assertEquals(111, obj2.alpha); +gc(); +obj2.alpha = 100 +assertEquals(111, obj2.alpha); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2170.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2170.js new file mode 100644 index 0000000..01cb1ea --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2170.js @@ -0,0 +1,58 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +function array_fun() { + for (var i = 0; i < 2; i++) { + var a = [1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8]; + var x = new Array(); + x.fixed$length = true; + for (var j = 0; j < a.length; j++) { + x.push(a[j]); + } + for(var j = 0; j < x.length; j++) { + if (typeof x[j] != 'number') { + throw "foo"; + } + x[j] = x[j]; + } + } +} + +try { + for (var i = 0; i < 10; ++i) { + array_fun(); + } + %OptimizeFunctionOnNextCall(array_fun); + for (var i = 0; i < 10; ++i) { + array_fun(); + } +} catch (e) { + assertUnreachable(); +} + diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2172.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2172.js new file mode 100644 index 0000000..5d06f4e --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2172.js @@ -0,0 +1,35 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +for (var i = 0; i < 10000; i++){ + (i + "\0").split(/(.)\1/i); +} + +for (var i = 0; i < 10000; i++){ + (i + "\u1234\0").split(/(.)\1/i); +} + diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2185-2.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2185-2.js new file mode 100644 index 0000000..b1eedb9 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2185-2.js @@ -0,0 +1,145 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// These tests used to time out before this was fixed. + +var LEN = 2e4; + +function short() { + var sum = 0; + for (var i = 0; i < 1000; i++) { + var a = [1, 4, 34, 23, 6, 123, 3, 2, 11, 515, 4, 33, 22, 2, 2, 1, 0, 123, + 23, 42, 43, 1002, 44, 43, 101, 23, 55, 11, 101, 102, 45, 11, 404, + 31415, 34, 53, 453, 45, 34, 5, 2, 35, 5, 345, 36, 45, 345, 3, 45, + 3, 5, 5, 2, 2342344, 2234, 23, 2718, 1500, 2, 19, 22, 43, 41, 0, + -1, 33, 45, 78]; + a.sort(function(a, b) { return a - b; }); + sum += a[0]; + } + return sum; +} + +function short_bench(name, array) { + var start = new Date(); + short(); + var end = new Date(); + var ms = end - start; + print("Short " + Math.floor(ms) + "ms"); +} + +function sawseq(a, tooth) { + var count = 0; + while (true) { + for (var i = 0; i < tooth; i++) { + a.push(i); + if (++count >= LEN) return a; + } + } +} + +function sawseq2(a, tooth) { + var count = 0; + while (true) { + for (var i = 0; i < tooth; i++) { + a.push(i); + if (++count >= LEN) return a; + } + for (var i = 0; i < tooth; i++) { + a.push(tooth - i); + if (++count >= LEN) return a; + } + } +} + +function sawseq3(a, tooth) { + var count = 0; + while (true) { + for (var i = 0; i < tooth; i++) { + a.push(tooth - i); + if (++count >= LEN) return a; + } + } +} + +function up(a) { + for (var i = 0; i < LEN; i++) { + a.push(i); + } + return a; +} + +function down(a) { + for (var i = 0; i < LEN; i++) { + a.push(LEN - i); + } + return a; +} + +function ran(a) { + for (var i = 0; i < LEN; i++) { + a.push(Math.floor(Math.random() * LEN)); + } + return a; +} + +var random = ran([]); +var asc = up([]); +var desc = down([]); +var asc_desc = down(up([])); +var desc_asc = up(down([])); +var asc_asc = up(up([])); +var desc_desc = down(down([])); +var saw1 = sawseq([], 1000); +var saw2 = sawseq([], 500); +var saw3 = sawseq([], 200); +var saw4 = sawseq2([], 200); +var saw5 = sawseq3([], 200); + +function bench(name, array) { + var start = new Date(); + array.sort(function(a, b) { return a - b; }); + var end = new Date(); + for (var i = 0; i < array.length - 1; i++) { + if (array[i] > array[i + 1]) throw name + " " + i; + } + var ms = end - start; + print(name + " " + Math.floor(ms) + "ms"); +} + +short_bench(); +bench("random", random); +bench("up", asc); +bench("down", desc); +bench("saw 1000", saw1); +bench("saw 500", saw2); +bench("saw 200", saw3); +bench("saw 200 symmetric", saw4); +bench("saw 200 down", saw4); +bench("up, down", asc_desc); +bench("up, up", asc_asc); +bench("down, down", desc_desc); +bench("down, up", desc_asc); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2185.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2185.js new file mode 100644 index 0000000..895f322 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2185.js @@ -0,0 +1,36 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var a = []; + +for (var i = 0; i < 2; i++) { + for (var j = 0; j < 30000; j++) { + a.push(j); + } +} + +a.sort(function(a, b) { return a - b; } ); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2186.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2186.js new file mode 100644 index 0000000..0921dce --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2186.js @@ -0,0 +1,49 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --harmony-collections + +function heapify(i) { + return 2.0 * (i / 2); +} +heapify(1); + +var ONE = 1; +var ANOTHER_ONE = heapify(ONE); +assertSame(ONE, ANOTHER_ONE); +assertEquals("number", typeof ONE); +assertEquals("number", typeof ANOTHER_ONE); + +var set = new Set; +set.add(ONE); +assertTrue(set.has(ONE)); +assertTrue(set.has(ANOTHER_ONE)); + +var map = new Map; +map.set(ONE, 23); +assertSame(23, map.get(ONE)); +assertSame(23, map.get(ANOTHER_ONE)); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2193.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2193.js new file mode 100644 index 0000000..50509bf --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2193.js @@ -0,0 +1,58 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax --cache-optimized-code + +function bozo() {}; +function MakeClosure() { + return function f(use_literals) { + if (use_literals) { + return [1,2,3,3,4,5,6,7,8,9,bozo]; + } else { + return 0; + } + } +} + +// Create two closures that share the same literal boilerplates. +var closure1 = MakeClosure(); +var closure2 = MakeClosure(); +var expected = [1,2,3,3,4,5,6,7,8,9,bozo]; + +// Make sure we generate optimized code for the first closure after +// warming it up properly so that the literals boilerplate is generated +// and the optimized code uses CreateArrayLiteralShallow runtime call. +assertEquals(0, closure1(false)); +assertEquals(expected, closure1(true)); +%OptimizeFunctionOnNextCall(closure1); +assertEquals(expected, closure1(true)); + +// Optimize the second closure, which should reuse the optimized code +// from the first closure with the same literal boilerplates. +assertEquals(0, closure2(false)); +%OptimizeFunctionOnNextCall(closure2); +assertEquals(expected, closure2(true)); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2219.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2219.js new file mode 100644 index 0000000..946c75b --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2219.js @@ -0,0 +1,32 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --harmony-proxies --expose-gc + +var p = Proxy.create({getPropertyDescriptor: function() { gc() }}); +var o = Object.create(p); +assertSame(23, o.x = 23); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2225.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2225.js new file mode 100644 index 0000000..9957d8d --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2225.js @@ -0,0 +1,65 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --harmony-proxies + +var proxy_has_x = false; +var proxy = Proxy.create({ getPropertyDescriptor:function(key) { + assertSame('x', key); + if (proxy_has_x) { + return { configurable:true, writable:false, value:19 }; + } +}}); + +// Test __lookupGetter__/__lookupSetter__ with proxy. +assertSame(undefined, Object.prototype.__lookupGetter__.call(proxy, 'foo')); +assertSame(undefined, Object.prototype.__lookupSetter__.call(proxy, 'bar')); +assertSame(undefined, Object.prototype.__lookupGetter__.call(proxy, '123')); +assertSame(undefined, Object.prototype.__lookupSetter__.call(proxy, '456')); + +// Test __lookupGetter__/__lookupSetter__ with proxy in prototype chain. +var object = Object.create(proxy); +assertSame(undefined, Object.prototype.__lookupGetter__.call(object, 'foo')); +assertSame(undefined, Object.prototype.__lookupSetter__.call(object, 'bar')); +assertSame(undefined, Object.prototype.__lookupGetter__.call(object, '123')); +assertSame(undefined, Object.prototype.__lookupSetter__.call(object, '456')); + +// Test inline constructors with proxy as prototype. +function f() { this.x = 23; } +f.prototype = proxy; +proxy_has_x = false; +assertSame(23, new f().x); +proxy_has_x = true; +assertSame(19, new f().x); + +// Test inline constructors with proxy in prototype chain. +function g() { this.x = 42; } +g.prototype.__proto__ = proxy; +proxy_has_x = false; +assertSame(42, new g().x); +proxy_has_x = true; +assertSame(19, new g().x); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2226.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2226.js new file mode 100644 index 0000000..1ac3d30 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2226.js @@ -0,0 +1,36 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var foo = function() { 0; /* foo function */ }; +var bar = function() { 1; /* bar function */ }; +var baz = function() { 2; /* baz function */ }; + +var test = foo.test = bar.test = baz; + +assertEquals(baz, test); +assertEquals(baz, foo.test); +assertEquals(baz, bar.test); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2234.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2234.js new file mode 100644 index 0000000..8da513e --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2234.js @@ -0,0 +1,41 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +function test(i) { + // Overwrite random parts of the transcendental cache. + Math.sin(i / 1779 * Math.PI); + // Check whether the first cache line has been accidentally overwritten + // with incorrect key. + assertEquals(0, Math.sin(0)); +} + +for (i = 0; i < 10000; ++i) { + test(i); + if (i == 0) %OptimizeFunctionOnNextCall(test); +} diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2249.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2249.js new file mode 100644 index 0000000..07d687d --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2249.js @@ -0,0 +1,33 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --gc-interval=10 --stress-compaction + +var o = {}; +o[Math.pow(2,30)-1] = 0; +o[Math.pow(2,31)-1] = 0; +o[1] = 0; diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2250.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2250.js new file mode 100644 index 0000000..b3b0db3 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2250.js @@ -0,0 +1,68 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +// The original problem from the bug: In the example below SMI check for b +// generated for inlining of equals invocation (marked with (*)) will be hoisted +// out of the loop across the typeof b === "object" condition and cause an +// immediate deopt. Another problem here is that no matter how many time we +// deopt and reopt we will continue to produce the wrong code. +// +// The fix is to notice when a deopt and subsequent reopt doesn't find +// additional type information, indicating that optimistic LICM should be +// disabled during compilation. + +function eq(a, b) { + if (typeof b === "object") { + return b.equals(a); // (*) + } + return a === b; +} + +Object.prototype.equals = function (other) { + return (this === other); +}; + +function test() { + for (var i = 0; !eq(i, 10); i++) + ; +} + +eq({}, {}); +eq({}, {}); +eq(1, 1); +eq(1, 1); +test(); +%OptimizeFunctionOnNextCall(test); +test(); +%OptimizeFunctionOnNextCall(test); +// Second compilation should have noticed that LICM wasn't a good idea, and now +// function should no longer deopt when called. +test(); +assertTrue(2 != %GetOptimizationStatus(test)); + diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2261.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2261.js new file mode 100644 index 0000000..000e07d --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2261.js @@ -0,0 +1,113 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +// Test materialization of the arguments object when deoptimizing a +// strict mode closure after modifying an argument. + +(function () { + var forceDeopt = 0; + function inner(x) { + "use strict"; + x = 2; + // Do not remove this %DebugPrint as it makes sure the deopt happens + // after the assignment and is not hoisted above the assignment. + %DebugPrint(arguments[0]); + forceDeopt + 1; + return arguments[0]; + } + + assertEquals(1, inner(1)); + assertEquals(1, inner(1)); + %OptimizeFunctionOnNextCall(inner); + assertEquals(1, inner(1)); + forceDeopt = "not a number"; + assertEquals(1, inner(1)); +})(); + + +// Test materialization of the arguments object when deoptimizing an +// inlined strict mode closure after modifying an argument. + +(function () { + var forceDeopt = 0; + function inner(x) { + "use strict"; + x = 2; + // Do not remove this %DebugPrint as it makes sure the deopt happens + // after the assignment and is not hoisted above the assignment. + %DebugPrint(arguments[0]); + forceDeopt + 1; + return arguments[0]; + } + + function outer(x) { + return inner(x); + } + + assertEquals(1, outer(1)); + assertEquals(1, outer(1)); + %OptimizeFunctionOnNextCall(outer); + assertEquals(1, outer(1)); + forceDeopt = "not a number"; + assertEquals(1, outer(1)); +})(); + + +// Test materialization of the multiple arguments objects when +// deoptimizing several inlined closure after modifying an argument. + +(function () { + var forceDeopt = 0; + function inner(x,y,z) { + "use strict"; + x = 3; + // Do not remove this %DebugPrint as it makes sure the deopt happens + // after the assignment and is not hoisted above the assignment. + %DebugPrint(arguments[0]); + forceDeopt + 1; + return arguments[0]; + } + + function middle(x) { + "use strict"; + x = 2; + return inner(10*x, 20*x, 30*x) + arguments[0]; + } + + function outer(x) { + return middle(x); + } + + assertEquals(21, outer(1)); + assertEquals(21, outer(1)); + %OptimizeFunctionOnNextCall(outer); + assertEquals(21, outer(1)); + forceDeopt = "not a number"; + assertEquals(21, outer(1)); +})(); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2284.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2284.js new file mode 100644 index 0000000..5614019 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2284.js @@ -0,0 +1,32 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +assertThrows("%foobar();", TypeError); +assertThrows("%constructor();", TypeError); +assertThrows("%constructor(23);", TypeError); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2285.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2285.js new file mode 100644 index 0000000..efda4cd --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2285.js @@ -0,0 +1,32 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +assertThrows(function() { %_CallFunction(null, 0, ""); }); +assertThrows(function() { %_CallFunction(null, 0, 1); }); + diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2286.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2286.js new file mode 100644 index 0000000..372451e --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2286.js @@ -0,0 +1,32 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +assertThrows("f()", ReferenceError); +assertThrows("%f()", TypeError); +assertThrows("%_f()", SyntaxError); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2289.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2289.js new file mode 100644 index 0000000..e89ec6e --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2289.js @@ -0,0 +1,34 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var foo = "a"; +for (var i = 0; i < 12; i++) foo += foo; +foo = foo + 'b' + foo; + +foo.replace(/b/, "a"); + + diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2291.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2291.js new file mode 100644 index 0000000..96627fc --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2291.js @@ -0,0 +1,36 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +function StrictCompare(x) { return x === Object(x); } + +var obj = new Object(); +var obj2 = new Object(); +obj == obj; // Populate IC cache with non-strict comparison. + +StrictCompare(obj); // Set IC in StrictCompare from IC cache. + +assertFalse(StrictCompare('foo')); // Use == stub for === operation. diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2294.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2294.js new file mode 100644 index 0000000..43ba10d --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2294.js @@ -0,0 +1,70 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +var clampedArray = new Uint8ClampedArray(10); + +function test() { + clampedArray[0] = 0.499; + assertEquals(0, clampedArray[0]); + clampedArray[0] = 0.5; + assertEquals(0, clampedArray[0]); + clampedArray[0] = 0.501; + assertEquals(1, clampedArray[0]); + clampedArray[0] = 1.499; + assertEquals(1, clampedArray[0]); + clampedArray[0] = 1.5; + assertEquals(2, clampedArray[0]); + clampedArray[0] = 1.501; + assertEquals(2, clampedArray[0]); + clampedArray[0] = 2.5; + assertEquals(2, clampedArray[0]); + clampedArray[0] = 3.5; + assertEquals(4, clampedArray[0]); + clampedArray[0] = 252.5; + assertEquals(252, clampedArray[0]); + clampedArray[0] = 253.5; + assertEquals(254, clampedArray[0]); + clampedArray[0] = 254.5; + assertEquals(254, clampedArray[0]); + clampedArray[0] = 256.5; + assertEquals(255, clampedArray[0]); + clampedArray[0] = -0.5; + assertEquals(0, clampedArray[0]); + clampedArray[0] = -1.5; + assertEquals(0, clampedArray[0]); + clampedArray[0] = 1000000000000; + assertEquals(255, clampedArray[0]); + clampedArray[0] = -1000000000000; + assertEquals(0, clampedArray[0]); +} + +test(); +test(); +%OptimizeFunctionOnNextCall(test); +test(); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2296.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2296.js new file mode 100644 index 0000000..c00f14f --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2296.js @@ -0,0 +1,40 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-debug-as debug + +Debug = debug.Debug + +function listener(event, exec_state, event_data, data) { + event_data.script().setSource(1); +}; + +Debug.setListener(listener); + +eval('0'); + +Debug.setListener(null); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2318.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2318.js new file mode 100644 index 0000000..ca67ab2 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2318.js @@ -0,0 +1,66 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-debug-as debug --nostack-trace-on-abort + +function f() { + var i = 0; + + // Stack-allocate to reach the end of stack quickly. + var _A0 = 00; var _A1 = 01; var _A2 = 02; var _A3 = 03; var _A4 = 04; + var _B0 = 05; var _B1 = 06; var _B2 = 07; var _B3 = 08; var _B4 = 09; + var _C0 = 10; var _C1 = 11; var _C2 = 12; var _C3 = 13; var _C4 = 14; + var _D0 = 15; var _D1 = 16; var _D2 = 17; var _D3 = 18; var _D4 = 19; + var _E0 = 20; var _E1 = 21; var _E2 = 22; var _E3 = 23; var _E4 = 24; + var _F0 = 25; var _F1 = 26; var _F2 = 27; var _F3 = 28; var _F4 = 29; + var _G0 = 30; var _G1 = 31; var _G2 = 32; var _G3 = 33; var _G4 = 34; + var _H0 = 35; var _H1 = 36; var _H2 = 37; var _H3 = 38; var _H4 = 39; + var _I0 = 40; var _I1 = 41; var _I2 = 42; var _I3 = 43; var _I4 = 44; + var _J0 = 45; var _J1 = 46; var _J2 = 47; var _J3 = 48; var _J4 = 49; + var _K0 = 50; var _K1 = 51; var _K2 = 52; var _K3 = 53; var _K4 = 54; + var _L0 = 55; var _L1 = 56; var _L2 = 57; var _L3 = 58; var _L4 = 59; + var _M0 = 60; var _M1 = 61; var _M2 = 62; var _M3 = 63; var _M4 = 64; + var _N0 = 65; var _N1 = 66; var _N2 = 67; var _N3 = 68; var _N4 = 69; + var _O0 = 70; var _O1 = 71; var _O2 = 72; var _O3 = 73; var _O4 = 74; + var _P0 = 75; var _P1 = 76; var _P2 = 77; var _P3 = 78; var _P4 = 79; + var _Q0 = 80; var _Q1 = 81; var _Q2 = 82; var _Q3 = 83; var _Q4 = 84; + var _R0 = 85; var _R1 = 86; var _R2 = 87; var _R3 = 88; var _R4 = 89; + var _S0 = 90; var _S1 = 91; var _S2 = 92; var _S3 = 93; var _S4 = 94; + var _T0 = 95; var _T1 = 96; var _T2 = 97; var _T3 = 98; var _T4 = 99; + + f(); +}; + +Debug = debug.Debug; +var bp = Debug.setBreakPoint(f, 0); + +function listener(event, exec_state, event_data, data) { + result = exec_state.frame().evaluate("i").value(); +}; + +Debug.setListener(listener); +assertThrows(function() { f(); }, RangeError); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2322.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2322.js new file mode 100644 index 0000000..1195bab --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2322.js @@ -0,0 +1,36 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --harmony-scoping + +"use strict"; + +assertThrows("'use strict'; for (let x in x);", ReferenceError); + +let s; +for (let pppp in {}) {}; +assertThrows(function() { pppp = true }, ReferenceError); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2326.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2326.js new file mode 100644 index 0000000..d2edf2b --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2326.js @@ -0,0 +1,54 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// This tests that we do not share optimized code across closures that +// were optimized using OSR (for a particular OSR entry AST id) even if +// caching of optimized code kicks in. + +function makeClosure() { + function f(mode, iterations) { + var accumulator = 0; + if (mode == 1) { + while (--iterations > 0) accumulator = Math.ceil(accumulator); + return 1; + } else { + while (--iterations > 0) accumulator = Math.floor(accumulator); + return 2; + } + } + return f; +} + +// Generate two closures sharing the same underlying function literal. +var f1 = makeClosure(); +var f2 = makeClosure(); + +// This function should be optimized via OSR in the first tight loop. +assertSame(1, f1(1, 100000)); + +// This function should be optimized via OSR in the second tight loop. +assertSame(2, f2(2, 100000)); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2336.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2336.js new file mode 100644 index 0000000..edfff60 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2336.js @@ -0,0 +1,53 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-debug-as debug --expose-gc + +// Check that we can cope with a debug listener that runs in the +// GC epilogue and causes enough allocation to trigger a new GC during +// the epilogue. + +var f = eval("(function f() { return 42; })"); + +Debug = debug.Debug; + +var called = false; + +function listener(event, exec_state, event_data, data) { + if (event == Debug.DebugEvent.ScriptCollected) { + if (!called) { + called = true; + gc(); + } + } +}; + +Debug.scripts(); +Debug.setListener(listener); +f = void 0; +gc(); +assertTrue(called); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2339.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2339.js new file mode 100644 index 0000000..b16821d --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2339.js @@ -0,0 +1,59 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax --expose-gc + +/** + * The possible optimization states of a function. Must be in sync with the + * return values of Runtime_GetOptimizationStatus() in runtime.cc! + */ + +var OptimizationState = { + YES: 1, + NO: 2, + ALWAYS: 3, + NEVER: 4 +}; + +function simple() { + return simple_two_args(0, undefined); +} + +function simple_two_args(always_zero, always_undefined) { + var always_five = always_undefined || 5; + return always_zero * always_five * .5; +} + + +simple(); +simple(); +%OptimizeFunctionOnNextCall(simple); +simple(); +var raw_optimized = %GetOptimizationStatus(simple); +assertFalse(raw_optimized == OptimizationState.NO); +gc(); + diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2346.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2346.js new file mode 100644 index 0000000..4c88b3e --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2346.js @@ -0,0 +1,123 @@ +// Copyright 2010 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// This file only tests very simple descriptors that always have +// configurable, enumerable, and writable set to true. +// A range of more elaborate tests are performed in +// object-define-property.js + +// Flags: --stress-runs=5 + +function get() { return x; } +function set(x) { this.x = x; } + +var obj = {x: 1}; +obj.__defineGetter__("accessor", get); +obj.__defineSetter__("accessor", set); +var a = new Array(); +a[1] = 42; +obj[1] = 42; + +var descIsData = Object.getOwnPropertyDescriptor(obj, 'x'); +assertTrue(descIsData.enumerable); +assertTrue(descIsData.writable); +assertTrue(descIsData.configurable); + +var descIsAccessor = Object.getOwnPropertyDescriptor(obj, 'accessor'); +assertTrue(descIsAccessor.enumerable); +assertTrue(descIsAccessor.configurable); +assertTrue(descIsAccessor.get == get); +assertTrue(descIsAccessor.set == set); + +var descIsNotData = Object.getOwnPropertyDescriptor(obj, 'not-x'); +assertTrue(descIsNotData == undefined); + +var descIsNotAccessor = Object.getOwnPropertyDescriptor(obj, 'not-accessor'); +assertTrue(descIsNotAccessor == undefined); + +var descArray = Object.getOwnPropertyDescriptor(a, '1'); +assertTrue(descArray.enumerable); +assertTrue(descArray.configurable); +assertTrue(descArray.writable); +assertEquals(descArray.value, 42); + +var descObjectElement = Object.getOwnPropertyDescriptor(obj, '1'); +assertTrue(descObjectElement.enumerable); +assertTrue(descObjectElement.configurable); +assertTrue(descObjectElement.writable); +assertEquals(descObjectElement.value, 42); + +// String objects. +var a = new String('foobar'); +for (var i = 0; i < a.length; i++) { + var descStringObject = Object.getOwnPropertyDescriptor(a, i); + assertTrue(descStringObject.enumerable); + assertFalse(descStringObject.configurable); + assertFalse(descStringObject.writable); + assertEquals(descStringObject.value, a.substring(i, i+1)); +} + +// Support for additional attributes on string objects. +a.x = 42; +a[10] = 'foo'; +var descStringProperty = Object.getOwnPropertyDescriptor(a, 'x'); +assertTrue(descStringProperty.enumerable); +assertTrue(descStringProperty.configurable); +assertTrue(descStringProperty.writable); +assertEquals(descStringProperty.value, 42); + +var descStringElement = Object.getOwnPropertyDescriptor(a, '10'); +assertTrue(descStringElement.enumerable); +assertTrue(descStringElement.configurable); +assertTrue(descStringElement.writable); +assertEquals(descStringElement.value, 'foo'); + +// Test that elements in the prototype chain is not returned. +var proto = {}; +proto[10] = 42; + +var objWithProto = new Array(); +objWithProto.prototype = proto; +objWithProto[0] = 'bar'; +var descWithProto = Object.getOwnPropertyDescriptor(objWithProto, '10'); +assertEquals(undefined, descWithProto); + +// Test elements on global proxy object. +var global = (function() { return this; })(); + +global[42] = 42; + +function el_getter() { return 239; }; +function el_setter() {}; +Object.defineProperty(global, '239', {get: el_getter, set: el_setter}); + +var descRegularElement = Object.getOwnPropertyDescriptor(global, '42'); +assertEquals(42, descRegularElement.value); + +var descAccessorElement = Object.getOwnPropertyDescriptor(global, '239'); +assertEquals(el_getter, descAccessorElement.get); +assertEquals(el_setter, descAccessorElement.set); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2373.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2373.js new file mode 100644 index 0000000..16a87ec --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2373.js @@ -0,0 +1,29 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var o = JSON.parse('{"a":2600753951}'); +assertEquals(2600753951, o.a); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2374.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2374.js new file mode 100644 index 0000000..b12e5f2 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2374.js @@ -0,0 +1,33 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var msg = '{"result":{"profile":{"head":{"functionName":"(root)","url":"","lineNumber":0,"totalTime":495.7243772462511,"selfTime":0,"numberOfCalls":0,"visible":true,"callUID":2771605942,"children":[{"functionName":"(program)","url":"","lineNumber":0,"totalTime":495.7243772462511,"selfTime":495.7243772462511,"numberOfCalls":0,"visible":true,"callUID":1902715303,"children":[]}]},"bottomUpHead":{"functionName":"(root)","url":"","lineNumber":0,"totalTime":495.7243772462511,"selfTime":0,"numberOfCalls":0,"visible":true,"callUID":2771605942,"children":[{"functionName":"(program)","url":"","lineNumber":0,"totalTime":495.7243772462511,"selfTime":495.7243772462511,"numberOfCalls":0,"visible":true,"callUID":1902715303,"children":[]}]}}},"id":41}'; + +var obj = JSON.parse(msg); +var obj2 = JSON.parse(msg); + +assertEquals(JSON.stringify(obj), JSON.stringify(obj2)); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-2398.js b/src/3rdparty/v8/test/mjsunit/regress/regress-2398.js new file mode 100644 index 0000000..1c66e7f --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-2398.js @@ -0,0 +1,41 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +"use strict"; + +var observed = false; + +var object = { get toString() { observed = true; } }; +Object.defineProperty(object, "ro", { value: 1 }); + +try { + object.ro = 2; // TypeError caused by trying to write to read-only. +} catch (e) { + e.message; // Forces formatting of the message object. +} + +assertFalse(observed); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-334.js b/src/3rdparty/v8/test/mjsunit/regress/regress-334.js index 024fc9e..37dd299 100644 --- a/src/3rdparty/v8/test/mjsunit/regress/regress-334.js +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-334.js @@ -40,7 +40,7 @@ var object = {__proto__:{}}; %SetProperty(object, "foo", func1, DONT_ENUM | DONT_DELETE); %SetProperty(object, "bar", func1, DONT_ENUM | READ_ONLY); %SetProperty(object, "baz", func1, DONT_DELETE | READ_ONLY); -%SetProperty(object.__proto__, "bif", func1, DONT_ENUM | DONT_DELETE | READ_ONLY); +%SetProperty(object.__proto__, "bif", func1, DONT_ENUM | DONT_DELETE); object.bif = func2; function enumerable(obj) { diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-builtin-array-op.js b/src/3rdparty/v8/test/mjsunit/regress/regress-builtin-array-op.js new file mode 100644 index 0000000..1e37af3 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-builtin-array-op.js @@ -0,0 +1,38 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Test that we invoke the correct sort function in +// array operations. + +var foo = "hest"; +Array.prototype.sort = function(fn) { foo = "fisk"; }; +Function.prototype.call = function() { foo = "caramel"; }; +var a = [2,3,1]; +a[100000] = 0; +a.join(); +assertEquals("hest", foo); + diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-cnlt-elements.js b/src/3rdparty/v8/test/mjsunit/regress/regress-cnlt-elements.js new file mode 100644 index 0000000..634534c --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-cnlt-elements.js @@ -0,0 +1,43 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-gc + +var a = JSON.parse('{"b":1,"c":2,"d":3,"e":4}'); +var b = JSON.parse('{"12040200":1, "a":2, "b":2}'); +var c = JSON.parse('{"24050300":1}'); +b = null; +gc(); +gc(); +c.a1 = 2; +c.a2 = 2; +c.a3 = 2; +c.a4 = 2; +c.a5 = 2; +c.a6 = 2; +c.a7 = 2; +c.a8 = 2; diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-cnlt-enum-indices.js b/src/3rdparty/v8/test/mjsunit/regress/regress-cnlt-enum-indices.js new file mode 100644 index 0000000..03582bb --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-cnlt-enum-indices.js @@ -0,0 +1,45 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax --expose-gc + +var o = {}; +var o2 = {}; + +o.a = 1; +o2.a = 1; +function f() { return 10; } +// Adds a non-field enumerable property. +Object.defineProperty(o, "b", { get: f, enumerable: true }); +Object.defineProperty(o2, "b", { get: f, enumerable: true }); +assertTrue(%HaveSameMap(o, o2)); +o.c = 2; + +for (var x in o) { } +o = null; + +gc(); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-cntl-descriptors-enum.js b/src/3rdparty/v8/test/mjsunit/regress/regress-cntl-descriptors-enum.js new file mode 100644 index 0000000..ee72faf --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-cntl-descriptors-enum.js @@ -0,0 +1,46 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax --expose-gc + +DontEnum = 2; + +var o = {}; +%SetProperty(o, "a", 0, DontEnum); + +var o2 = {}; +%SetProperty(o2, "a", 0, DontEnum); + +assertTrue(%HaveSameMap(o, o2)); + +o.y = 2; + +for (var v in o) { print(v); } +o = {}; +gc(); + +for (var v in o2) { print(v); } diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-convert-enum.js b/src/3rdparty/v8/test/mjsunit/regress/regress-convert-enum.js new file mode 100644 index 0000000..c624cad --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-convert-enum.js @@ -0,0 +1,60 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --expose-gc + +// Create a transition tree A (no descriptors) -> B (descriptor for a) -> C +// (descriptor for a and c), that all share the descriptor array [a,c]. C is the +// owner of the descriptor array. +var o = {}; +o.a = 1; +o.c = 2; + +// Add a transition B -> D where D has its own descriptor array [a,b] where b is +// a constant function. +var o1 = {}; +o1.a = 1; + +// Install an enumeration cache in the descriptor array [a,c] at map B. +for (var x in o1) { } +o1.b = function() { return 1; }; + +// Return ownership of the descriptor array [a,c] to B and trim it to [a]. +o = null; +gc(); + +// Convert the transition B -> D into a transition to B -> E so that E uses the +// instance descriptors [a,b] with b being a field. +var o2 = {}; +o2.a = 1; +o2.b = 10; + +// Create an object with map B and iterate over it. +var o3 = {}; +o3.a = 1; + +for (var y in o3) { } diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-convert-enum2.js b/src/3rdparty/v8/test/mjsunit/regress/regress-convert-enum2.js new file mode 100644 index 0000000..cdc7fbe --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-convert-enum2.js @@ -0,0 +1,46 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var o = {}; +o.a = 1; +o.b = function() { return 1; }; +o.d = 2; + +for (var x in o) { } + +var o1 = {}; +o1.a = 1; +o1.b = 10; +o1.c = 20; + +var keys = ["a", "b", "c"]; + +var i = 0; +for (var y in o1) { + assertEquals(keys[i], y); + i += 1; +} diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-convert-transition.js b/src/3rdparty/v8/test/mjsunit/regress/regress-convert-transition.js new file mode 100644 index 0000000..057dc80 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-convert-transition.js @@ -0,0 +1,40 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var input = '{ "a1":1, "a2":1, "a3":1, "a4":1, "a5":1, "a6":1, "a7":1,\ + "a8":1, "a9":1, "a10":1, "a11":1, "a12":1, "a13":1}'; +var a = JSON.parse(input); +a.a = function() { return 10; }; + +// Force conversion of field to slow mode. +var b = JSON.parse(input); +b.a = 10; + +// Add another property to the object that would transition to a. +var c = JSON.parse(input); +c.x = 10; +assertEquals(undefined, c.a); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-119926.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-119926.js index 26b84fa..1ad250a 100644 --- a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-119926.js +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-119926.js @@ -25,9 +25,11 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Flags: --gc-global + // Test that array elements don't break upon garbage collection. var a = new Array(500); -for (var i = 0; i < 500000; i++) { +for (var i = 0; i < 100000; i++) { a[i] = new Object(); } diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-122271.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-122271.js index 3a99a7f..8ae91e8 100644 --- a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-122271.js +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-122271.js @@ -39,11 +39,11 @@ function foo(array) { array.foo = "bar"; } -assertTrue(%HasFastSmiOnlyElements(a)); -assertTrue(%HasFastElements(b)); +assertTrue(%HasFastSmiElements(a)); +assertTrue(%HasFastObjectElements(b)); foo(a); foo(b); -assertTrue(%HasFastSmiOnlyElements(a)); -assertTrue(%HasFastElements(b)); +assertTrue(%HasFastSmiElements(a)); +assertTrue(%HasFastObjectElements(b)); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-125148.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-125148.js new file mode 100644 index 0000000..0f7bcd8 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-125148.js @@ -0,0 +1,90 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +function ToDictionaryMode(x) { + %OptimizeObjectForAddingMultipleProperties(x, 100); +} + +var A, B, C; + +// The initial bug report was about calling a know function... +A = {}; +Object.defineProperty(A, "foo", { value: function() { assertUnreachable(); }}); + +B = Object.create(A); +Object.defineProperty(B, "foo", { value: function() { return 111; }}); + +C = Object.create(B); + +function bar(x) { return x.foo(); } + +assertEquals(111, bar(C)); +assertEquals(111, bar(C)); +ToDictionaryMode(B); +%OptimizeFunctionOnNextCall(bar); +assertEquals(111, bar(C)); + +// Although this was not in the initial bug report: The same for getters... +A = {}; +Object.defineProperty(A, "baz", { get: function() { assertUnreachable(); }}); + +B = Object.create(A); +Object.defineProperty(B, "baz", { get: function() { return 111; }}); + +C = Object.create(B); + +function boo(x) { return x.baz; } + +assertEquals(111, boo(C)); +assertEquals(111, boo(C)); +ToDictionaryMode(B); +%OptimizeFunctionOnNextCall(boo); +assertEquals(111, boo(C)); + +// And once more for setters... +A = {}; +Object.defineProperty(A, "huh", { set: function(x) { assertUnreachable(); }}); + +B = Object.create(A); +var setterValue; +Object.defineProperty(B, "huh", { set: function(x) { setterValue = x; }}); + +C = Object.create(B); + +function fuu(x) { + setterValue = 222; + x.huh = 111; + return setterValue; +} + +assertEquals(111, fuu(C)); +assertEquals(111, fuu(C)); +ToDictionaryMode(B); +%OptimizeFunctionOnNextCall(fuu); +assertEquals(111, fuu(C)); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-134055.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-134055.js new file mode 100644 index 0000000..9b658fb --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-134055.js @@ -0,0 +1,63 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +function crash(obj) { + return obj.foo; +} + +function base(number_of_properties) { + var result = new Array(); + for (var i = 0; i < number_of_properties; i++) { + result["property" + i] = "value" + i; + } + result.foo = number_of_properties; + return result; +} + +var a = base(12); +var b = base(13); +var c = base(14); +var d = base(15); + +crash(a); // Premonomorphic. +crash(a); +crash(b); +crash(c); +crash(d); // Polymorphic, degree 4. + +//Prepare ElementsKind transition map chain. +var x = base(13); +x[0] = "object"; +x = base(14); +x[0] = "object"; +x = base(15); +x[0] = "object"; + +%OptimizeFunctionOnNextCall(crash); +crash(a); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-134609.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-134609.js new file mode 100644 index 0000000..da7d85d --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-134609.js @@ -0,0 +1,59 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax --inline-accessors + +var forceDeopt = {x:0}; + +var objectWithGetterProperty = (function (value) { + var obj = {}; + Object.defineProperty(obj, "getterProperty", { + get: function foo() { + forceDeopt.x; + return value; + }, + }); + return obj; +})("bad"); + +function test() { + var iAmContextAllocated = "good"; + objectWithGetterProperty.getterProperty; + return iAmContextAllocated; + + // Make sure that the local variable is context allocated. + function unused() { iAmContextAllocated; } +} + +assertEquals("good", test()); +assertEquals("good", test()); +%OptimizeFunctionOnNextCall(test); +assertEquals("good", test()); + +// At this point, foo should have been inlined into test. Let's deopt... +delete forceDeopt.x; +assertEquals("good", test()); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-135008.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-135008.js new file mode 100644 index 0000000..2be396e --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-135008.js @@ -0,0 +1,45 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Filler long enough to trigger lazy parsing. +var filler = "//" + new Array(1024).join('x'); + +var scope = { x:23 }; + +with(scope) { + eval( + "scope.f = (function outer() {" + + " function inner() {" + + " return x;" + + " }" + + " return inner;" + + "})();" + + filler + ); +}; + +assertSame(23, scope.f()); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-135066.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-135066.js new file mode 100644 index 0000000..1aeca8b --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-135066.js @@ -0,0 +1,53 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Filler long enough to trigger lazy parsing. +var filler = "//" + new Array(1024).join('x'); + +// Test strict eval in global context. +eval( + "'use strict';" + + "var x = 23;" + + "var f = function bozo1() {" + + " return x;" + + "};" + + "assertSame(23, f());" + + filler +); + +// Test default eval in strict context. +(function() { + "use strict"; + eval( + "var y = 42;" + + "var g = function bozo2() {" + + " return y;" + + "};" + + "assertSame(42, g());" + + filler + ); +})(); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-137689.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-137689.js new file mode 100644 index 0000000..ef79d24 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-137689.js @@ -0,0 +1,47 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +function getter() { return 10; } +function setter(v) { } +function getter2() { return 20; } + +var o = {}; +var o2 = {}; + +Object.defineProperty(o, "foo", { get: getter, configurable: true }); +Object.defineProperty(o2, "foo", { get: getter, configurable: true }); +assertTrue(%HaveSameMap(o, o2)); + +Object.defineProperty(o, "bar", { get: getter2 }); +Object.defineProperty(o2, "bar", { get: getter2 }); +assertTrue(%HaveSameMap(o, o2)); + +Object.defineProperty(o, "foo", { set: setter, configurable: true }); +Object.defineProperty(o2, "foo", { set: setter, configurable: true }); +assertTrue(%HaveSameMap(o, o2)); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-138887.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-138887.js new file mode 100644 index 0000000..8d8e169 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-138887.js @@ -0,0 +1,48 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +function worker1(ignored) { + return 100; +} + +function factory(worker) { + return function(call_depth) { + if (call_depth == 0) return 10; + return 1 + worker(call_depth - 1); + } +} + +var f1 = factory(worker1); +var f2 = factory(f1); +assertEquals(11, f2(1)); // Result: 1 + f1(0) == 1 + 10. +assertEquals(11, f2(1)); +%OptimizeFunctionOnNextCall(f1); +assertEquals(10, f1(0)); // Terminates immediately -> returns 10. +%OptimizeFunctionOnNextCall(f2); +assertEquals(102, f2(1000)); // 1 + f1(999) == 1 + 1 + worker1(998) == 102 diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-140083.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-140083.js new file mode 100644 index 0000000..e38192c --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-140083.js @@ -0,0 +1,44 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +// Test that the absence of a setter in a compound/count operation works. + +Object.defineProperty(Object.prototype, "foo", + { get: function() { return 123; } }); + +function bar(o) { + o.foo += 42; + o.foo++; +} + +var baz = {}; +bar(baz); +bar(baz); +%OptimizeFunctionOnNextCall(bar) +bar(baz); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-142087.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-142087.js new file mode 100644 index 0000000..881ca60 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-142087.js @@ -0,0 +1,38 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var string = "What are you looking for?"; + +var expected_match = [""]; +for (var i = 0; i < string.length; i++) { + expected_match.push(""); +} + +string.replace(/(_)|(_|)/g, ""); +assertArrayEquals(expected_match, string.match(/(_)|(_|)/g, "")); + +'***************************************'.match(/((\\)|(\*)|(\$))/g, "."); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-142218.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-142218.js new file mode 100644 index 0000000..373f83b --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-142218.js @@ -0,0 +1,44 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +length = 1 << 16; +a = new Array(length); + +function insert_element(key) { + a[key] = 42; +} + +insert_element(1); +%OptimizeFunctionOnNextCall(insert_element); +insert_element(new Object()); +count = 0; +for (var i = 0; i < length; i++) { + if (a[i] != undefined) count++; +} +assertEquals(1, count); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-145961.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-145961.js new file mode 100644 index 0000000..eb88945 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-145961.js @@ -0,0 +1,39 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// This test causes the operands to be passed in as Integer32 registers. +// Flags: --allow-natives-syntax +function test() { + var a = new Int32Array(2); + var x = a[0]; + return Math.min(x, x); +} + +assertEquals(0, test()); +assertEquals(0, test()); +%OptimizeFunctionOnNextCall(test); +assertEquals(0, test()); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-146910.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-146910.js new file mode 100644 index 0000000..120f809 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-146910.js @@ -0,0 +1,38 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var x = []; +assertSame(0, x.length); +assertSame(undefined, x[0]); + +Object.defineProperty(x, '0', { value: 7, configurable: false }); +assertSame(1, x.length); +assertSame(7, x[0]); + +x.length = 0; +assertSame(1, x.length); +assertSame(7, x[0]); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-147475.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-147475.js new file mode 100644 index 0000000..180744c --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-147475.js @@ -0,0 +1,48 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +function worker1(ignored) { + return 100; +} + +function factory(worker) { + return function(call_depth) { + if (call_depth == 0) return 10; + return 1 + worker(call_depth - 1); + } +} + +var f1 = factory(worker1); +var f2 = factory(f1); +assertEquals(11, f2(1)); +%OptimizeFunctionOnNextCall(f1); +assertEquals(10, f1(0)); +%OptimizeFunctionOnNextCall(f2); +assertEquals(102, f2(2)); +assertEquals(102, f2(2)); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-148376.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-148376.js new file mode 100644 index 0000000..55bb5f1 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-148376.js @@ -0,0 +1,35 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +function defineSetter(o) { + o.__defineSetter__('property', function() {}); +} + +defineSetter(Object.prototype); +property = 0; +defineSetter(this); +var keys = Object.keys(this); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-150545.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-150545.js new file mode 100644 index 0000000..68efdbf --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-150545.js @@ -0,0 +1,53 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +// Test that we do not generate OSR entry points that have an arguments +// stack height different from zero. The OSR machinery cannot generate +// frames for that. + +(function() { + "use strict"; + + var instantReturn = false; + function inner() { + if (instantReturn) return; + assertSame(3, arguments.length); + assertSame(1, arguments[0]); + assertSame(2, arguments[1]); + assertSame(3, arguments[2]); + } + + function outer() { + inner(1,2,3); + // Trigger OSR. + while (%GetOptimizationStatus(outer) == 2) {} + } + + outer(); +})(); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-150729.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-150729.js new file mode 100644 index 0000000..15aa587 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-150729.js @@ -0,0 +1,39 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +var t = 0; +function burn() { + i = [t, 1]; + var M = [i[0], Math.cos(t) + i[7074959]]; + t += .05; +} +for (var j = 0; j < 5; j++) { + if (j == 2) %OptimizeFunctionOnNextCall(burn); + burn(); +} diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-157019.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-157019.js new file mode 100644 index 0000000..1c54089 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-157019.js @@ -0,0 +1,54 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax --nocrankshaft + +function makeConstructor() { + return function() { + this.a = 1; + this.b = 2; + }; +} + +var c1 = makeConstructor(); +var o1 = new c1(); + +c1.prototype = {}; + +for (var i = 0; i < 10; i++) { + var o = new c1(); + for (var j = 0; j < 8; j++) { + o["x" + j] = 0; + } +} + +var c2 = makeConstructor(); +var o2 = new c2(); + +for (var i = 0; i < 50000; i++) { + new c2(); +} diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-157520.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-157520.js new file mode 100644 index 0000000..17081df --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-157520.js @@ -0,0 +1,38 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --nocrankshaft + +(function(){ + var f = function(arg) { + arg = 2; + return arguments[0]; + }; + for (var i = 0; i < 50000; i++) { + assertSame(2, f(1)); + } +})(); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-158185.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-158185.js new file mode 100644 index 0000000..99f19c7 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-158185.js @@ -0,0 +1,39 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +assertEquals("0023456", + Object.keys(JSON.parse('{"0023456": 1}'))[0]); +assertEquals("1234567890123", + Object.keys(JSON.parse('{"1234567890123": 1}'))[0]); +assertEquals("123456789ABCD", + Object.keys(JSON.parse('{"123456789ABCD": 1}'))[0]); +assertEquals("12A", + Object.keys(JSON.parse('{"12A": 1}'))[0]); + +assertEquals(1, JSON.parse('{"0":1}')[0]); +assertEquals(undefined, JSON.parse('{"00":1}')[0]); + diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-160010.js b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-160010.js new file mode 100644 index 0000000..266e545 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-crbug-160010.js @@ -0,0 +1,33 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var str = "a"; +for (var i = 0; i < 28; i++) { + str += str; +} +JSON.stringify(str); + diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-debug-code-recompilation.js b/src/3rdparty/v8/test/mjsunit/regress/regress-debug-code-recompilation.js index 1a608b1..4723ec1 100644 --- a/src/3rdparty/v8/test/mjsunit/regress/regress-debug-code-recompilation.js +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-debug-code-recompilation.js @@ -25,7 +25,8 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Flags: --allow-natives-syntax --hydrogen-filter=Debug.setBreakPoint --expose-debug-as debug +// Flags: --allow-natives-syntax --hydrogen-filter=Debug.setBreakPoint +// Flags: --expose-debug-as debug Debug = debug.Debug diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-deep-proto.js b/src/3rdparty/v8/test/mjsunit/regress/regress-deep-proto.js new file mode 100644 index 0000000..5d2758c --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-deep-proto.js @@ -0,0 +1,45 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +function poly(x) { + return x.foo; +} + +var one = {foo: 0}; +var two = {foo: 0, bar: 1}; +var three = {bar: 0}; +three.__proto__ = {}; +three.__proto__.__proto__ = {}; +three.__proto__.__proto__.__proto__ = {}; +three.__proto__.__proto__.__proto__.__proto__ = {}; +three.__proto__.__proto__.__proto__.__proto__.__proto__ = {}; + +for (var i = 0; i < 1e6; i++) { + poly(one); + poly(two); + poly(three); +} diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-delete-empty-double.js b/src/3rdparty/v8/test/mjsunit/regress/regress-delete-empty-double.js new file mode 100644 index 0000000..f7af2b1 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-delete-empty-double.js @@ -0,0 +1,40 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +a = [1.1,2.2,3.3]; +a.length = 1; +delete a[1]; + +assertTrue(%HasFastDoubleElements(a)); +assertFalse(%HasFastHoleyElements(a)); + +delete a[0]; + +assertTrue(%HasFastDoubleElements(a)); +assertTrue(%HasFastHoleyElements(a)); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-iteration-order.js b/src/3rdparty/v8/test/mjsunit/regress/regress-iteration-order.js new file mode 100644 index 0000000..76f5c3f --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-iteration-order.js @@ -0,0 +1,42 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var x = {a: 1, b: 2, c: 3}; + +x.__proto__ = {}; + +delete x.b; + +x.d = 4; + +s = ""; + +for (key in x) { + s += x[key]; +} + +assertEquals("134", s); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-json-stringify-gc.js b/src/3rdparty/v8/test/mjsunit/regress/regress-json-stringify-gc.js new file mode 100644 index 0000000..d732ebc --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-json-stringify-gc.js @@ -0,0 +1,41 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var a = []; +var new_space_string = ""; +for (var i = 0; i < 128; i++) { + new_space_string += String.fromCharCode((Math.random() * 26 + 65) | 0); +} +for (var i = 0; i < 10000; i++) a.push(new_space_string); + +// At some point during the first stringify, allocation causes a GC and +// new_space_string is moved to old space. Make sure that this does not +// screw up reading from the correct location. +json1 = JSON.stringify(a); +json2 = JSON.stringify(a); +assertEquals(json1, json2, "GC caused JSON.stringify to fail."); + diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-load-elements.js b/src/3rdparty/v8/test/mjsunit/regress/regress-load-elements.js new file mode 100644 index 0000000..68cdc8e --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-load-elements.js @@ -0,0 +1,49 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +function bad_func(o,a) { + for (var i = 0; i < 1; ++i) { + o.prop = 0; + var x = a[0]; + } +} + +o = new Object(); +a = {}; +a[0] = 1; +bad_func(o, a); + +o = new Object(); +bad_func(o, a); + +// Optimize. Before the fix, the elements-load and subsequent fixed-array-length +// were hoisted above the map check. This is invalid since not all types +// necessarily have elements. +%OptimizeFunctionOnNextCall(bad_func); +bad_func(o, ""); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-smi-only-concat.js b/src/3rdparty/v8/test/mjsunit/regress/regress-smi-only-concat.js index a9a6d89..55ca299 100644 --- a/src/3rdparty/v8/test/mjsunit/regress/regress-smi-only-concat.js +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-smi-only-concat.js @@ -33,5 +33,5 @@ var fast_array = ['a', 'b']; var array = fast_array.concat(fast_array); -assertTrue(%HasFastElements(fast_array)); -assertTrue(%HasFastElements(array));
\ No newline at end of file +assertTrue(%HasFastObjectElements(fast_array)); +assertTrue(%HasFastObjectElements(array)); diff --git a/src/3rdparty/v8/test/mjsunit/regress/regress-undefined-store-keyed-fast-element.js b/src/3rdparty/v8/test/mjsunit/regress/regress-undefined-store-keyed-fast-element.js new file mode 100644 index 0000000..9e6ec9d --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/regress/regress-undefined-store-keyed-fast-element.js @@ -0,0 +1,37 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +function f(v) { + return [0.0, 0.1, 0.2, v]; +} + +assertEquals([0.0, 0.1, 0.2, NaN], f(NaN)); +assertEquals([0.0, 0.1, 0.2, NaN], f(NaN)); +%OptimizeFunctionOnNextCall(f); +assertEquals([0.0, 0.1, 0.2, undefined], f(undefined)); diff --git a/src/3rdparty/v8/test/mjsunit/stack-traces.js b/src/3rdparty/v8/test/mjsunit/stack-traces.js index 536e71b..438eec9 100644 --- a/src/3rdparty/v8/test/mjsunit/stack-traces.js +++ b/src/3rdparty/v8/test/mjsunit/stack-traces.js @@ -111,6 +111,18 @@ function testStrippedCustomError() { throw new CustomError("hep-hey", CustomError); } +MyObj = function() { FAIL; } + +MyObjCreator = function() {} + +MyObjCreator.prototype.Create = function() { + return new MyObj(); +} + +function testClassNames() { + (new MyObjCreator).Create(); +} + // Utility function for testing that the expected strings occur // in the stack trace produced when running the given function. function testTrace(name, fun, expected, unexpected) { @@ -254,6 +266,8 @@ testTrace("testDefaultCustomError", testDefaultCustomError, ["collectStackTrace"]); testTrace("testStrippedCustomError", testStrippedCustomError, ["hep-hey"], ["new CustomError", "collectStackTrace"]); +testTrace("testClassNames", testClassNames, + ["new MyObj", "MyObjCreator.Create"], ["as Create"]); testCallerCensorship(); testUnintendedCallerCensorship(); testErrorsDuringFormatting(); diff --git a/src/3rdparty/v8/test/mjsunit/str-to-num.js b/src/3rdparty/v8/test/mjsunit/str-to-num.js index bbfa7d3..cbec87f 100644 --- a/src/3rdparty/v8/test/mjsunit/str-to-num.js +++ b/src/3rdparty/v8/test/mjsunit/str-to-num.js @@ -147,7 +147,6 @@ assertEquals(15, toNumber("0Xf")); assertEquals(15, toNumber("0XF")); assertEquals(0, toNumber("0x000")); -assertEquals(-Infinity, 1 / toNumber("-0x000")); assertEquals(0, toNumber("0x000" + repeat('0', 1000))); assertEquals(9, toNumber("0x009")); assertEquals(10, toNumber("0x00a")); @@ -157,7 +156,6 @@ assertEquals(15, toNumber("0x00F")); assertEquals(15, toNumber("0x00F ")); assertEquals(Infinity, toNumber("0x" + repeat('0', 1000) + '1' + repeat('0', 1000))); -assertEquals(-Infinity, toNumber("-0x1" + repeat('0', 1000))); assertEquals(0x1000000 * 0x10000000, toNumber("0x10000000000000")); assertEquals(0x1000000 * 0x10000000 + 1, toNumber("0x10000000000001")); @@ -207,3 +205,10 @@ assertTrue(isNaN(toNumber("1" + repeat('0', 1000) + 'junk')), "1e1000 junk"); for (var i = 1; i < 12; i++) { assertEquals(toNumber('1' + repeat('0', i)), Math.pow(10.0, i)); } + +assertTrue(isNaN(toNumber("+0x0"))); +assertTrue(isNaN(toNumber("+0xFF"))); +assertTrue(isNaN(toNumber("+0x012"))); +assertTrue(isNaN(toNumber("-0x0"))); +assertTrue(isNaN(toNumber("-0xFF"))); +assertTrue(isNaN(toNumber("-0x012")));
\ No newline at end of file diff --git a/src/3rdparty/v8/test/mjsunit/string-charcodeat.js b/src/3rdparty/v8/test/mjsunit/string-charcodeat.js index 8be6a09..72dc819 100644 --- a/src/3rdparty/v8/test/mjsunit/string-charcodeat.js +++ b/src/3rdparty/v8/test/mjsunit/string-charcodeat.js @@ -231,3 +231,6 @@ for (var i = 0; i < 5; i++) { } %OptimizeFunctionOnNextCall(directlyOnPrototype); directlyOnPrototype(); + +assertTrue(isNaN(%_StringCharCodeAt("ABC", -1))); +assertTrue(isNaN(%_StringCharCodeAt("ABC", 4))); diff --git a/src/3rdparty/v8/test/mjsunit/testcfg.py b/src/3rdparty/v8/test/mjsunit/testcfg.py index 87ed4fa..c8b972c 100644 --- a/src/3rdparty/v8/test/mjsunit/testcfg.py +++ b/src/3rdparty/v8/test/mjsunit/testcfg.py @@ -25,17 +25,87 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import test import os -from os.path import join, dirname, exists import re -import tempfile + +from testrunner.local import testsuite +from testrunner.objects import testcase FLAGS_PATTERN = re.compile(r"//\s+Flags:(.*)") FILES_PATTERN = re.compile(r"//\s+Files:(.*)") SELF_SCRIPT_PATTERN = re.compile(r"//\s+Env: TEST_FILE_NAME") +class MjsunitTestSuite(testsuite.TestSuite): + + def __init__(self, name, root): + super(MjsunitTestSuite, self).__init__(name, root) + + def ListTests(self, context): + tests = [] + for dirname, dirs, files in os.walk(self.root): + for dotted in [x for x in dirs if x.startswith('.')]: + dirs.remove(dotted) + dirs.sort() + files.sort() + for filename in files: + if filename.endswith(".js") and filename != "mjsunit.js": + testname = join(dirname[len(self.root) + 1:], filename[:-3]) + test = testcase.TestCase(self, testname) + tests.append(test) + return tests + + def GetFlagsForTestCase(self, testcase, context): + source = self.GetSourceForTest(testcase) + flags = [] + context.mode_flags + flags_match = re.findall(FLAGS_PATTERN, source) + for match in flags_match: + flags += match.strip().split() + + files_list = [] # List of file names to append to command arguments. + files_match = FILES_PATTERN.search(source); + # Accept several lines of 'Files:'. + while True: + if files_match: + files_list += files_match.group(1).strip().split() + files_match = FILES_PATTERN.search(source, files_match.end()) + else: + break + files = [ os.path.normpath(os.path.join(self.root, '..', '..', f)) + for f in files_list ] + testfilename = os.path.join(self.root, testcase.path + self.suffix()) + if SELF_SCRIPT_PATTERN.search(source): + env = ["-e", "TEST_FILE_NAME=\"%s\"" % testfilename] + files = env + files + files.append(os.path.join(self.root, "mjsunit.js")) + files.append(testfilename) + + flags += files + if context.isolates: + flags.append("--isolate") + flags += files + + return testcase.flags + flags + + def GetSourceForTest(self, testcase): + filename = os.path.join(self.root, testcase.path + self.suffix()) + with open(filename) as f: + return f.read() + + +def GetSuite(name, root): + return MjsunitTestSuite(name, root) + + +# Deprecated definitions below. +# TODO(jkummerow): Remove when SCons is no longer supported. + + +from os.path import dirname, exists, join, normpath +import tempfile +import test + + class MjsunitTestCase(test.TestCase): def __init__(self, path, file, mode, context, config, isolates): @@ -56,9 +126,9 @@ class MjsunitTestCase(test.TestCase): def GetVmCommand(self, source): result = self.config.context.GetVmCommand(self, self.mode) - flags_match = FLAGS_PATTERN.search(source) - if flags_match: - result += flags_match.group(1).strip().split() + flags_match = re.findall(FLAGS_PATTERN, source); + for match in flags_match: + result += match.strip().split() return result def GetVmArguments(self, source): diff --git a/src/3rdparty/v8/test/mjsunit/try-finally-continue.js b/src/3rdparty/v8/test/mjsunit/try-finally-continue.js new file mode 100644 index 0000000..b55e7ac --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/try-finally-continue.js @@ -0,0 +1,72 @@ +// Copyright 2012 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Test that we correctly restore the stack when continuing from a +// finally block inside a for-in. + +var f = 0; +var a = [1, 2, 3]; + +for (x in a) { + try{ + throw 'error'; + } finally { + f++; + continue; + } +} +assertEquals(3, f); + +f = 0; +for (x in a) { + try { + f++; + } finally { + f++; + continue; + } +} +assertEquals(6, f); + +f = 0; +for (x in a) { + try { + f++; + } finally { + try { + throw 'error' + } finally { + try { + f++; + } finally { + f++; + continue; + } + } + } +} +assertEquals(9, f);
\ No newline at end of file diff --git a/src/3rdparty/v8/test/mjsunit/typed-array-slice.js b/src/3rdparty/v8/test/mjsunit/typed-array-slice.js new file mode 100644 index 0000000..c6e7e94 --- /dev/null +++ b/src/3rdparty/v8/test/mjsunit/typed-array-slice.js @@ -0,0 +1,61 @@ +// Copyright 2011 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +// This is a regression test for overlapping key and value registers. + +var types = [Array, Int8Array, Uint8Array, Int16Array, Uint16Array, + Int32Array, Uint32Array, Uint8ClampedArray, Float32Array, + Float64Array]; + +var results1 = [-2, -2, 254, -2, 65534, -2, 4294967294, 0, -2, -2]; +var results2 = [undefined, -1, 255, -1, 65535, -1, 4294967295, 0, -1, -1]; +var results3 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; +var results4 = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]; + +const kElementCount = 40; + +function do_slice(a) { + return Array.prototype.slice.call(a, 4, 8); +} + +for (var t = 0; t < types.length; t++) { + var type = types[t]; + var a = new type(kElementCount); + for (var i = 0; i < kElementCount; ++i ) { + a[i] = i-6; + } + delete a[5]; + var sliced = do_slice(a); + + %ClearFunctionTypeFeedback(do_slice); + assertEquals(results1[t], sliced[0]); + assertEquals(results2[t], sliced[1]); + assertEquals(results3[t], sliced[2]); + assertEquals(results4[t], sliced[3]); +} diff --git a/src/3rdparty/v8/test/mjsunit/unbox-double-arrays.js b/src/3rdparty/v8/test/mjsunit/unbox-double-arrays.js index fd7db28..5d061ae 100644 --- a/src/3rdparty/v8/test/mjsunit/unbox-double-arrays.js +++ b/src/3rdparty/v8/test/mjsunit/unbox-double-arrays.js @@ -1,4 +1,4 @@ -// Copyright 2011 the V8 project authors. All rights reserved. +// Copyright 2012 the V8 project authors. All rights reserved. // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: @@ -28,6 +28,8 @@ // Test dictionary -> double elements -> dictionary elements round trip // Flags: --allow-natives-syntax --unbox-double-arrays --expose-gc +// Flags: --noparallel-recompilation + var large_array_size = 100000; var approx_dict_to_elements_threshold = 70000; @@ -278,7 +280,8 @@ function testOneArrayType(allocator) { expected_array_value(7)); %DeoptimizeFunction(test_various_loads6); - gc(); + %ClearFunctionTypeFeedback(test_various_stores); + %ClearFunctionTypeFeedback(test_various_loads7); // Test stores for non-NaN. var large_array = new allocator(large_array_size); @@ -376,7 +379,7 @@ delete large_array2[5]; // Convert back to fast elements and make sure the contents of the array are // unchanged. large_array2[25] = new Object(); -assertTrue(%HasFastElements(large_array2)); +assertTrue(%HasFastObjectElements(large_array2)); for (var i= 0; i < approx_dict_to_elements_threshold; i += 500 ) { if (i != 25 && i != 5) { assertEquals(expected_array_value(i), large_array2[i]); diff --git a/src/3rdparty/v8/test/mjsunit/with-readonly.js b/src/3rdparty/v8/test/mjsunit/with-readonly.js index e29520a..29982b3 100644 --- a/src/3rdparty/v8/test/mjsunit/with-readonly.js +++ b/src/3rdparty/v8/test/mjsunit/with-readonly.js @@ -27,6 +27,8 @@ // Test that readonly variables are treated correctly. +// Flags: --es5_readonly + // Create an object with a read-only length property in the prototype // chain by putting the string split function in the prototype chain. var o = {}; @@ -36,8 +38,8 @@ function f() { with (o) { length = 23; length = 24; - assertEquals(24, length); + assertEquals(2, length); } + assertEquals(2, o.length); } f(); - |